shotgun-sh 0.2.23.dev1__py3-none-any.whl → 0.2.29.dev2__py3-none-any.whl

shotgun/agents/agent_manager.py

@@ -17,7 +17,7 @@ from tenacity import (
 )
 
 if TYPE_CHECKING:
-    from shotgun.agents.conversation_history import ConversationState
+    from shotgun.agents.conversation import ConversationState
 
 from pydantic_ai import (
     Agent,
@@ -68,8 +68,8 @@ from shotgun.posthog_telemetry import track_event
 from shotgun.tui.screens.chat_screen.hint_message import HintMessage
 from shotgun.utils.source_detection import detect_source
 
+from .conversation.history.compaction import apply_persistent_compaction
 from .export import create_export_agent
-from .history.compaction import apply_persistent_compaction
 from .messages import AgentSystemPrompt
 from .models import AgentDeps, AgentRuntimeOptions
 from .plan import create_plan_agent
@@ -1314,7 +1314,7 @@ class AgentManager(Widget):
         Returns:
             ConversationState object containing UI and agent messages and current type
         """
-        from shotgun.agents.conversation_history import ConversationState
+        from shotgun.agents.conversation import ConversationState
 
         return ConversationState(
             agent_messages=self.message_history.copy(),

shotgun/agents/common.py

@@ -25,7 +25,7 @@ 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 .conversation.history import token_limit_compactor
 from .messages import AgentSystemPrompt, SystemStatusPrompt
 from .models import AgentDeps, AgentRuntimeOptions, PipelineConfigEntry
 from .tools import (

shotgun/agents/config/manager.py

@@ -307,29 +307,41 @@ class ConfigManager:
             # Convert plain text secrets to SecretStr objects
             self._convert_secrets_to_secretstr(data)
 
+            # Clean up invalid selected_model before Pydantic validation
+            if "selected_model" in data and data["selected_model"] is not None:
+                from .models import MODEL_SPECS, ModelName
+
+                try:
+                    # Try to convert to ModelName enum
+                    model_name = ModelName(data["selected_model"])
+                    # Check if it exists in MODEL_SPECS
+                    if model_name not in MODEL_SPECS:
+                        data["selected_model"] = None
+                except (ValueError, KeyError):
+                    # Invalid model name - reset to None
+                    data["selected_model"] = None
+
             self._config = ShotgunConfig.model_validate(data)
             logger.debug("Configuration loaded successfully from %s", self.config_path)
 
-            # Validate selected_model if in BYOK mode (no Shotgun key)
-            if not self._provider_has_api_key(self._config.shotgun):
-                should_save = False
+            # Clear migration_failed flag if config loaded successfully
+            should_save = False
+            if self._config.migration_failed:
+                self._config.migration_failed = False
+                self._config.migration_backup_path = None
+                should_save = True
 
+            # Validate selected_model for BYOK mode - verify provider has a key
+            if not self._provider_has_api_key(self._config.shotgun):
                 # 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 await 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:
+                    spec = MODEL_SPECS[self._config.selected_model]
+                    if not await self.has_provider_key(spec.provider):
+                        # Provider has no key - reset to None
                         logger.info(
-                            "Selected model %s not found in MODEL_SPECS, resetting",
+                            "Selected model %s provider has no API key, finding available model",
                             self._config.selected_model.value,
                         )
                         self._config.selected_model = None
@@ -344,17 +356,13 @@ class ConfigManager:
 
                             # Find default model for this provider
                             provider_models = {
-                                ProviderType.OPENAI: ModelName.GPT_5,
+                                ProviderType.OPENAI: ModelName.GPT_5_1,
                                 ProviderType.ANTHROPIC: ModelName.CLAUDE_HAIKU_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
 
@@ -498,7 +506,7 @@ class ConfigManager:
                 from .models import ModelName
 
                 provider_models = {
-                    ProviderType.OPENAI: ModelName.GPT_5,
+                    ProviderType.OPENAI: ModelName.GPT_5_1,
                     ProviderType.ANTHROPIC: ModelName.CLAUDE_HAIKU_4_5,
                     ProviderType.GOOGLE: ModelName.GEMINI_2_5_PRO,
                 }
@@ -736,13 +744,17 @@ class ConfigManager:
         return config.shotgun_instance_id
 
     async def update_shotgun_account(
-        self, api_key: str | None = None, supabase_jwt: str | None = None
+        self,
+        api_key: str | None = None,
+        supabase_jwt: str | None = None,
+        workspace_id: str | None = None,
     ) -> None:
         """Update Shotgun Account configuration.
 
         Args:
             api_key: LiteLLM proxy API key (optional)
             supabase_jwt: Supabase authentication JWT (optional)
+            workspace_id: Default workspace ID for shared specs (optional)
         """
         config = await self.load()
 
@@ -754,6 +766,9 @@ class ConfigManager:
                 SecretStr(supabase_jwt) if supabase_jwt else None
             )
 
+        if workspace_id is not None:
+            config.shotgun.workspace_id = workspace_id
+
         await self.save(config)
         logger.info("Updated Shotgun Account configuration")
 

shotgun/agents/config/models.py

@@ -27,6 +27,9 @@ class ModelName(StrEnum):
 
     GPT_5 = "gpt-5"
     GPT_5_MINI = "gpt-5-mini"
+    GPT_5_1 = "gpt-5.1"
+    GPT_5_1_CODEX = "gpt-5.1-codex"
+    GPT_5_1_CODEX_MINI = "gpt-5.1-codex-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"
@@ -114,6 +117,30 @@ MODEL_SPECS: dict[ModelName, ModelSpec] = {
         litellm_proxy_model_name="openai/gpt-5-mini",
         short_name="GPT-5 Mini",
     ),
+    ModelName.GPT_5_1: ModelSpec(
+        name=ModelName.GPT_5_1,
+        provider=ProviderType.OPENAI,
+        max_input_tokens=272_000,
+        max_output_tokens=128_000,
+        litellm_proxy_model_name="openai/gpt-5.1",
+        short_name="GPT-5.1",
+    ),
+    ModelName.GPT_5_1_CODEX: ModelSpec(
+        name=ModelName.GPT_5_1_CODEX,
+        provider=ProviderType.OPENAI,
+        max_input_tokens=272_000,
+        max_output_tokens=128_000,
+        litellm_proxy_model_name="openai/gpt-5.1-codex",
+        short_name="GPT-5.1 Codex",
+    ),
+    ModelName.GPT_5_1_CODEX_MINI: ModelSpec(
+        name=ModelName.GPT_5_1_CODEX_MINI,
+        provider=ProviderType.OPENAI,
+        max_input_tokens=272_000,
+        max_output_tokens=128_000,
+        litellm_proxy_model_name="openai/gpt-5.1-codex-mini",
+        short_name="GPT-5.1 Codex Mini",
+    ),
     ModelName.CLAUDE_OPUS_4_1: ModelSpec(
         name=ModelName.CLAUDE_OPUS_4_1,
         provider=ProviderType.ANTHROPIC,
@@ -186,6 +213,9 @@ class ShotgunAccountConfig(BaseModel):
     supabase_jwt: SecretStr | None = Field(
         default=None, description="Supabase authentication JWT"
     )
+    workspace_id: str | None = Field(
+        default=None, description="Default workspace ID for shared specs"
+    )
 
 
 class MarketingMessageRecord(BaseModel):

shotgun/agents/config/provider.py

@@ -47,13 +47,13 @@ def get_default_model_for_provider(config: ShotgunConfig) -> ModelName:
     """
     # Priority 1: Shotgun Account
     if _get_api_key(config.shotgun.api_key):
-        return ModelName.GPT_5
+        return ModelName.GPT_5_1
 
     # 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
+        return ModelName.GPT_5_1
     if _get_api_key(config.google.api_key):
         return ModelName.GEMINI_2_5_PRO
 
@@ -201,10 +201,12 @@ async def get_provider_model(
             model_name = provider_or_model
         else:
             # No specific model requested - use selected or default
-            model_name = config.selected_model or ModelName.GPT_5
+            model_name = config.selected_model or get_default_model_for_provider(config)
 
+        # Gracefully fall back if the selected model doesn't exist (backwards compatibility)
         if model_name not in MODEL_SPECS:
-            raise ValueError(f"Model '{model_name.value}' not found")
+            model_name = get_default_model_for_provider(config)
+
         spec = MODEL_SPECS[model_name]
 
         # Use Shotgun Account with determined model (provider = actual LLM provider)
@@ -225,10 +227,12 @@ async def get_provider_model(
     if isinstance(provider_or_model, ModelName):
         # Look up the model spec
         if provider_or_model not in MODEL_SPECS:
-            raise ValueError(f"Model '{provider_or_model.value}' not found")
-        spec = MODEL_SPECS[provider_or_model]
-        provider_enum = spec.provider
-        requested_model = provider_or_model
+            requested_model = None  # Fall back to provider default
+            provider_enum = None  # Will be determined below
+        else:
+            spec = MODEL_SPECS[provider_or_model]
+            provider_enum = spec.provider
+            requested_model = provider_or_model
     else:
         # Convert string to ProviderType enum if needed (backward compatible)
         if provider_or_model:
@@ -257,15 +261,22 @@ async def get_provider_model(
         if not api_key:
             raise ValueError("OpenAI API key not configured. Set via config.")
 
-        # Use requested model or default to gpt-5
-        model_name = requested_model if requested_model else ModelName.GPT_5
+        # Use requested model or default to gpt-5.1
+        model_name = requested_model if requested_model else ModelName.GPT_5_1
+        # Gracefully fall back if model doesn't exist
         if model_name not in MODEL_SPECS:
-            raise ValueError(f"Model '{model_name.value}' not found")
+            model_name = ModelName.GPT_5_1
         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):
+        if model_name in (
+            ModelName.GPT_5,
+            ModelName.GPT_5_MINI,
+            ModelName.GPT_5_1,
+            ModelName.GPT_5_1_CODEX,
+            ModelName.GPT_5_1_CODEX_MINI,
+        ):
             # Check if streaming capability has been tested
             streaming_capability = config.openai.supports_streaming
 
@@ -304,8 +315,9 @@ async def get_provider_model(
 
         # Use requested model or default to claude-haiku-4-5
         model_name = requested_model if requested_model else ModelName.CLAUDE_HAIKU_4_5
+        # Gracefully fall back if model doesn't exist
         if model_name not in MODEL_SPECS:
-            raise ValueError(f"Model '{model_name.value}' not found")
+            model_name = ModelName.CLAUDE_HAIKU_4_5
         spec = MODEL_SPECS[model_name]
 
         # Create fully configured ModelConfig
@@ -325,8 +337,9 @@ async def get_provider_model(
 
         # Use requested model or default to gemini-2.5-pro
         model_name = requested_model if requested_model else ModelName.GEMINI_2_5_PRO
+        # Gracefully fall back if model doesn't exist
         if model_name not in MODEL_SPECS:
-            raise ValueError(f"Model '{model_name.value}' not found")
+            model_name = ModelName.GEMINI_2_5_PRO
         spec = MODEL_SPECS[model_name]
 
         # Create fully configured ModelConfig

shotgun/agents/context_analyzer/analyzer.py

@@ -15,8 +15,12 @@ from pydantic_ai.messages import (
 )
 
 from shotgun.agents.config.models import ModelConfig
-from shotgun.agents.history.token_counting.utils import count_tokens_from_messages
-from shotgun.agents.history.token_estimation import estimate_tokens_from_messages
+from shotgun.agents.conversation.history.token_counting.utils import (
+    count_tokens_from_messages,
+)
+from shotgun.agents.conversation.history.token_estimation import (
+    estimate_tokens_from_messages,
+)
 from shotgun.agents.messages import AgentSystemPrompt, SystemStatusPrompt
 from shotgun.logging_config import get_logger
 from shotgun.tui.screens.chat_screen.hint_message import HintMessage

shotgun/agents/conversation/__init__.py

@@ -0,0 +1,18 @@
+"""Conversation module for managing conversation history and persistence."""
+
+from .filters import (
+    filter_incomplete_messages,
+    filter_orphaned_tool_responses,
+    is_tool_call_complete,
+)
+from .manager import ConversationManager
+from .models import ConversationHistory, ConversationState
+
+__all__ = [
+    "ConversationHistory",
+    "ConversationManager",
+    "ConversationState",
+    "filter_incomplete_messages",
+    "filter_orphaned_tool_responses",
+    "is_tool_call_complete",
+]

shotgun/agents/conversation/filters.py

@@ -0,0 +1,164 @@
+"""Filter functions for conversation message validation."""
+
+import json
+import logging
+
+from pydantic_ai.messages import (
+    ModelMessage,
+    ModelRequest,
+    ModelRequestPart,
+    ModelResponse,
+    ToolCallPart,
+    ToolReturnPart,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def is_tool_call_complete(tool_call: ToolCallPart) -> bool:
+    """Check if a tool call has valid, complete JSON arguments.
+
+    Args:
+        tool_call: The tool call part to validate
+
+    Returns:
+        True if the tool call args are valid JSON, False otherwise
+    """
+    if tool_call.args is None:
+        return True  # No args is valid
+
+    if isinstance(tool_call.args, dict):
+        return True  # Already parsed dict is valid
+
+    if not isinstance(tool_call.args, str):
+        return False
+
+    # Try to parse the JSON string
+    try:
+        json.loads(tool_call.args)
+        return True
+    except (json.JSONDecodeError, ValueError) as e:
+        # Log incomplete tool call detection
+        args_preview = (
+            tool_call.args[:100] + "..."
+            if len(tool_call.args) > 100
+            else tool_call.args
+        )
+        logger.info(
+            "Detected incomplete tool call in validation",
+            extra={
+                "tool_name": tool_call.tool_name,
+                "tool_call_id": tool_call.tool_call_id,
+                "args_preview": args_preview,
+                "error": str(e),
+            },
+        )
+        return False
+
+
+def filter_incomplete_messages(messages: list[ModelMessage]) -> list[ModelMessage]:
+    """Filter out messages with incomplete tool calls.
+
+    Args:
+        messages: List of messages to filter
+
+    Returns:
+        List of messages with only complete tool calls
+    """
+    filtered: list[ModelMessage] = []
+    filtered_count = 0
+    filtered_tool_names: list[str] = []
+
+    for message in messages:
+        # Only check ModelResponse messages for tool calls
+        if not isinstance(message, ModelResponse):
+            filtered.append(message)
+            continue
+
+        # Check if any tool calls are incomplete
+        has_incomplete_tool_call = False
+        for part in message.parts:
+            if isinstance(part, ToolCallPart) and not is_tool_call_complete(part):
+                has_incomplete_tool_call = True
+                filtered_tool_names.append(part.tool_name)
+                break
+
+        # Only include messages without incomplete tool calls
+        if not has_incomplete_tool_call:
+            filtered.append(message)
+        else:
+            filtered_count += 1
+
+    # Log if any messages were filtered
+    if filtered_count > 0:
+        logger.info(
+            "Filtered incomplete messages before saving",
+            extra={
+                "filtered_count": filtered_count,
+                "total_messages": len(messages),
+                "filtered_tool_names": filtered_tool_names,
+            },
+        )
+
+    return filtered
+
+
+def filter_orphaned_tool_responses(messages: list[ModelMessage]) -> list[ModelMessage]:
+    """Filter out tool responses without corresponding tool calls.
+
+    This ensures message history is valid for OpenAI API which requires
+    tool responses to follow their corresponding tool calls.
+
+    Args:
+        messages: List of messages to filter
+
+    Returns:
+        List of messages with orphaned tool responses removed
+    """
+    # Collect all tool_call_ids from ToolCallPart in ModelResponse
+    valid_tool_call_ids: set[str] = set()
+    for msg in messages:
+        if isinstance(msg, ModelResponse):
+            for part in msg.parts:
+                if isinstance(part, ToolCallPart) and part.tool_call_id:
+                    valid_tool_call_ids.add(part.tool_call_id)
+
+    # Filter out orphaned ToolReturnPart from ModelRequest
+    filtered: list[ModelMessage] = []
+    orphaned_count = 0
+    orphaned_tool_names: list[str] = []
+
+    for msg in messages:
+        if isinstance(msg, ModelRequest):
+            # Filter parts, removing orphaned ToolReturnPart
+            filtered_parts: list[ModelRequestPart] = []
+            request_part: ModelRequestPart
+            for request_part in msg.parts:
+                if isinstance(request_part, ToolReturnPart):
+                    if request_part.tool_call_id in valid_tool_call_ids:
+                        filtered_parts.append(request_part)
+                    else:
+                        # Skip orphaned tool response
+                        orphaned_count += 1
+                        orphaned_tool_names.append(request_part.tool_name or "unknown")
+                else:
+                    filtered_parts.append(request_part)
+
+            # Only add if there are remaining parts
+            if filtered_parts:
+                filtered.append(ModelRequest(parts=filtered_parts))
+        else:
+            filtered.append(msg)
+
+    # Log if any tool responses were filtered
+    if orphaned_count > 0:
+        logger.info(
+            "Filtered orphaned tool responses",
+            extra={
+                "orphaned_count": orphaned_count,
+                "total_messages": len(messages),
+                "orphaned_tool_names": orphaned_tool_names,
+            },
+        )
+
+    return filtered