shotgun-sh 0.1.0.dev12__py3-none-any.whl → 0.1.0.dev14__py3-none-any.whl

shotgun/agents/config/models.py

@@ -1,9 +1,13 @@
 """Pydantic models for configuration."""
 
 from enum import Enum
+from typing import Any
 
 from pydantic import BaseModel, Field, PrivateAttr, SecretStr
+from pydantic_ai.direct import model_request
+from pydantic_ai.messages import ModelMessage, ModelResponse
 from pydantic_ai.models import Model
+from pydantic_ai.settings import ModelSettings
 
 
 class ProviderType(str, Enum):
@@ -57,6 +61,22 @@ class ModelConfig(BaseModel):
         }
         return f"{provider_prefix[self.provider]}:{self.name}"
 
+    def get_model_settings(self, max_tokens: int | None = None) -> ModelSettings:
+        """Get ModelSettings with optional token override.
+
+        This provides flexibility for specific use cases that need different
+        token limits while defaulting to maximum utilization.
+
+        Args:
+            max_tokens: Optional override for max_tokens. If None, uses max_output_tokens
+
+        Returns:
+            ModelSettings configured with specified or maximum tokens
+        """
+        return ModelSettings(
+            max_tokens=max_tokens if max_tokens is not None else self.max_output_tokens
+        )
+
 
 # Model specifications registry (static metadata)
 MODEL_SPECS: dict[str, ModelSpec] = {
@@ -125,3 +145,44 @@ class ShotgunConfig(BaseModel):
     )
     user_id: str = Field(description="Unique anonymous user identifier")
     config_version: int = Field(default=1, description="Configuration schema version")
+
+
+async def shotgun_model_request(
+    model_config: ModelConfig,
+    messages: list[ModelMessage],
+    max_tokens: int | None = None,
+    **kwargs: Any,
+) -> ModelResponse:
+    """Model request wrapper that uses full token capacity by default.
+
+    This wrapper ensures all LLM calls in Shotgun use the maximum available
+    token capacity of each model, improving response quality and completeness.
+    The most common issue this fixes is truncated summaries that were cut off
+    at default token limits (e.g., 4096 for Claude models).
+
+    Args:
+        model_config: ModelConfig instance with model settings and API key
+        messages: Messages to send to the model
+        max_tokens: Optional override for max_tokens. If None, uses model's max_output_tokens
+        **kwargs: Additional arguments passed to model_request
+
+    Returns:
+        ModelResponse from the model
+
+    Example:
+        # Uses full token capacity (e.g., 4096 for Claude, 128k for GPT-5)
+        response = await shotgun_model_request(model_config, messages)
+
+        # Override for specific use case
+        response = await shotgun_model_request(model_config, messages, max_tokens=1000)
+    """
+    # Get properly configured ModelSettings with maximum or overridden token limit
+    model_settings = model_config.get_model_settings(max_tokens)
+
+    # Make the model request with full token utilization
+    return await model_request(
+        model=model_config.model_instance,
+        messages=messages,
+        model_settings=model_settings,
+        **kwargs,
+    )

shotgun/agents/config/provider.py

@@ -13,6 +13,11 @@ from pydantic_ai.providers.openai import OpenAIProvider
 
 from shotgun.logging_config import get_logger
 
+from .constants import (
+    ANTHROPIC_API_KEY_ENV,
+    GEMINI_API_KEY_ENV,
+    OPENAI_API_KEY_ENV,
+)
 from .manager import get_config_manager
 from .models import MODEL_SPECS, ModelConfig, ProviderType
 
@@ -86,10 +91,10 @@ def get_provider_model(provider: ProviderType | None = None) -> ModelConfig:
     )
 
     if provider_enum == ProviderType.OPENAI:
-        api_key = _get_api_key(config.openai.api_key, "OPENAI_API_KEY")
+        api_key = _get_api_key(config.openai.api_key, OPENAI_API_KEY_ENV)
         if not api_key:
             raise ValueError(
-                "OpenAI API key not configured. Set via environment variable OPENAI_API_KEY or config."
+                f"OpenAI API key not configured. Set via environment variable {OPENAI_API_KEY_ENV} or config."
             )
 
         # Get model spec
@@ -108,10 +113,10 @@ def get_provider_model(provider: ProviderType | None = None) -> ModelConfig:
         )
 
     elif provider_enum == ProviderType.ANTHROPIC:
-        api_key = _get_api_key(config.anthropic.api_key, "ANTHROPIC_API_KEY")
+        api_key = _get_api_key(config.anthropic.api_key, ANTHROPIC_API_KEY_ENV)
         if not api_key:
             raise ValueError(
-                "Anthropic API key not configured. Set via environment variable ANTHROPIC_API_KEY or config."
+                f"Anthropic API key not configured. Set via environment variable {ANTHROPIC_API_KEY_ENV} or config."
             )
 
         # Get model spec
@@ -130,10 +135,10 @@ def get_provider_model(provider: ProviderType | None = None) -> ModelConfig:
         )
 
     elif provider_enum == ProviderType.GOOGLE:
-        api_key = _get_api_key(config.google.api_key, "GEMINI_API_KEY")
+        api_key = _get_api_key(config.google.api_key, GEMINI_API_KEY_ENV)
         if not api_key:
             raise ValueError(
-                "Gemini API key not configured. Set via environment variable GEMINI_API_KEY or config."
+                f"Gemini API key not configured. Set via environment variable {GEMINI_API_KEY_ENV} or config."
             )
 
         # Get model spec

shotgun/agents/history/compaction.py

@@ -0,0 +1,85 @@
+"""Conversation compaction utilities."""
+
+from pydantic_ai.messages import ModelMessage
+from pydantic_ai.usage import RequestUsage
+
+from shotgun.agents.models import AgentDeps
+from shotgun.logging_config import get_logger
+
+from .token_estimation import estimate_tokens_from_messages
+
+logger = get_logger(__name__)
+
+
+async def apply_persistent_compaction(
+    messages: list[ModelMessage], deps: AgentDeps
+) -> list[ModelMessage]:
+    """Apply compaction to message history for persistent storage.
+
+    This ensures that compacted history is actually used as the conversation baseline,
+    preventing cascading compaction issues across both CLI and TUI usage patterns.
+
+    Args:
+        messages: Full message history from agent run
+        deps: Agent dependencies containing model config
+
+    Returns:
+        Compacted message history that should be stored as conversation state
+    """
+    from .history_processors import token_limit_compactor
+
+    try:
+        # Count actual token usage using shared utility
+        estimated_tokens = estimate_tokens_from_messages(messages, deps.llm_model)
+
+        # Create minimal usage info for compaction check
+        usage = RequestUsage(
+            input_tokens=estimated_tokens,
+            output_tokens=0,
+        )
+
+        # Create a minimal context object for compaction
+        class MockContext:
+            def __init__(self, deps: AgentDeps, usage: RequestUsage | None):
+                self.deps = deps
+                self.usage = usage
+
+        ctx = MockContext(deps, usage)
+        compacted_messages = await token_limit_compactor(ctx, messages)
+
+        # Log the result for monitoring
+        original_size = len(messages)
+        compacted_size = len(compacted_messages)
+
+        if compacted_size < original_size:
+            reduction_pct = ((original_size - compacted_size) / original_size) * 100
+            logger.debug(
+                f"Persistent compaction applied: {original_size} → {compacted_size} messages "
+                f"({reduction_pct:.1f}% reduction)"
+            )
+        else:
+            logger.debug(
+                f"No persistent compaction needed: {original_size} messages unchanged"
+            )
+
+        return compacted_messages
+
+    except Exception as e:
+        # If compaction fails, return original messages
+        # This ensures the system remains functional even if compaction has issues
+        logger.warning(f"Persistent compaction failed, using original history: {e}")
+        return messages
+
+
+def should_apply_persistent_compaction(deps: AgentDeps) -> bool:
+    """Check if persistent compaction should be applied.
+
+    Args:
+        deps: Agent dependencies
+
+    Returns:
+        True if persistent compaction should be applied
+    """
+    # For now, always apply persistent compaction
+    # Future: Add configuration option in deps or environment variable
+    return True

shotgun/agents/history/constants.py

@@ -0,0 +1,19 @@
+"""Constants for history processing and compaction."""
+
+from enum import Enum
+
+# Summary marker for compacted history
+SUMMARY_MARKER = "📌 COMPACTED_HISTORY:"
+
+# Token calculation constants
+INPUT_BUFFER_TOKENS = 500
+MIN_SUMMARY_TOKENS = 100
+TOKEN_LIMIT_RATIO = 0.8
+
+
+class SummaryType(Enum):
+    """Types of summarization requests for logging."""
+
+    INCREMENTAL = "INCREMENTAL"
+    FULL = "FULL"
+    CONTEXT_EXTRACTION = "CONTEXT_EXTRACTION"

shotgun/agents/history/context_extraction.py

@@ -0,0 +1,108 @@
+"""Context extraction utilities for history processing."""
+
+from pydantic_ai.messages import (
+    BuiltinToolCallPart,
+    BuiltinToolReturnPart,
+    ModelMessage,
+    ModelRequest,
+    ModelResponse,
+    ModelResponsePart,
+    RetryPromptPart,
+    SystemPromptPart,
+    TextPart,
+    ThinkingPart,
+    ToolCallPart,
+    ToolReturnPart,
+    UserPromptPart,
+)
+
+
+def extract_context_from_messages(messages: list[ModelMessage]) -> str:
+    """Extract context from a list of messages for summarization."""
+    context = ""
+    for msg in messages:
+        if isinstance(msg, ModelResponse | ModelRequest):
+            for part in msg.parts:
+                message_content = extract_context_from_part(part)
+                if message_content:
+                    context += message_content + "\n"
+    return context
+
+
+def extract_context_from_message_range(
+    messages: list[ModelMessage],
+    start_index: int,
+    end_index: int | None = None,
+) -> str:
+    """Extract context from a specific range of messages."""
+    if end_index is None:
+        end_index = len(messages)
+
+    message_slice = messages[start_index:end_index]
+    return extract_context_from_messages(message_slice)
+
+
+def has_meaningful_content(messages: list[ModelMessage]) -> bool:
+    """Check if messages contain meaningful content worth summarizing.
+
+    Only ModelResponse messages are considered meaningful for summarization.
+    User requests alone don't need summarization.
+    """
+    for msg in messages:
+        if isinstance(msg, ModelResponse):
+            for part in msg.parts:
+                if extract_context_from_part(part):
+                    return True
+    return False
+
+
+def extract_context_from_part(
+    message_part: (
+        SystemPromptPart
+        | UserPromptPart
+        | ToolReturnPart
+        | RetryPromptPart
+        | ModelResponsePart
+    ),
+) -> str:
+    """Extract context from a single message part."""
+    if isinstance(message_part, SystemPromptPart):
+        return ""  # Exclude system prompts from summary
+
+    elif isinstance(message_part, UserPromptPart):
+        if isinstance(message_part.content, str):
+            return f"<USER_PROMPT>\n{message_part.content}\n</USER_PROMPT>"
+        return ""
+
+    elif isinstance(message_part, ToolReturnPart):
+        return f"<TOOL_RETURN>\n{str(message_part.content)}\n</TOOL_RETURN>"
+
+    elif isinstance(message_part, RetryPromptPart):
+        if isinstance(message_part.content, str):
+            return f"<RETRY_PROMPT>\n{message_part.content}\n</RETRY_PROMPT>"
+        return ""
+
+    # Handle ModelResponsePart types
+    elif isinstance(message_part, TextPart):
+        return f"<ASSISTANT_TEXT>\n{message_part.content}\n</ASSISTANT_TEXT>"
+
+    elif isinstance(message_part, ToolCallPart):
+        if isinstance(message_part.args, dict):
+            args_str = ", ".join(f"{k}={repr(v)}" for k, v in message_part.args.items())
+            tool_call_str = f"{message_part.tool_name}({args_str})"
+        else:
+            tool_call_str = f"{message_part.tool_name}({message_part.args})"
+        return f"<TOOL_CALL>\n{tool_call_str}\n</TOOL_CALL>"
+
+    elif isinstance(message_part, BuiltinToolCallPart):
+        return f"<BUILTIN_TOOL_CALL>\n{message_part.tool_name}\n</BUILTIN_TOOL_CALL>"
+
+    elif isinstance(message_part, BuiltinToolReturnPart):
+        return (
+            f"<BUILTIN_TOOL_RETURN>\n{message_part.tool_name}\n</BUILTIN_TOOL_RETURN>"
+        )
+
+    elif isinstance(message_part, ThinkingPart):
+        return f"<THINKING>\n{message_part.content}\n</THINKING>"
+
+    return ""

shotgun/agents/history/history_building.py

@@ -0,0 +1,104 @@
+"""Functions for building compacted message history."""
+
+from pydantic_ai.messages import (
+    ModelMessage,
+    ModelRequest,
+    ModelRequestPart,
+    ModelResponse,
+    SystemPromptPart,
+    TextPart,
+    UserPromptPart,
+)
+
+from .message_utils import (
+    get_first_user_request,
+    get_last_user_request,
+    get_system_prompt,
+    get_user_content_from_request,
+)
+
+
+def build_clean_compacted_history(
+    summary_part: TextPart,
+    all_messages: list[ModelMessage],
+    last_summary_index: int | None = None,
+) -> list[ModelMessage]:
+    """Build a clean compacted history without preserving old verbose content.
+
+    Args:
+        summary_part: The marked summary part to include
+        all_messages: Original message history
+        last_summary_index: Index of the last summary (if any)
+
+    Returns:
+        Clean compacted message history
+    """
+    # Extract essential context from pre-summary messages (if any)
+    system_prompt = ""
+    first_user_prompt = ""
+
+    if last_summary_index is not None and last_summary_index > 0:
+        # Get system and first user from original conversation
+        pre_summary_messages = all_messages[:last_summary_index]
+        system_prompt = get_system_prompt(pre_summary_messages) or ""
+        first_user_prompt = get_first_user_request(pre_summary_messages) or ""
+
+    # Build the base structure
+    compacted_messages: list[ModelMessage] = []
+
+    # Add system/user context if it exists and is meaningful
+    if system_prompt or first_user_prompt:
+        compacted_messages.append(
+            _create_base_request(system_prompt, first_user_prompt)
+        )
+
+    # Add the summary
+    summary_message = ModelResponse(parts=[summary_part])
+    compacted_messages.append(summary_message)
+
+    # Ensure proper ending
+    return ensure_ends_with_model_request(compacted_messages, all_messages)
+
+
+def ensure_ends_with_model_request(
+    compacted_messages: list[ModelMessage],
+    original_messages: list[ModelMessage],
+) -> list[ModelMessage]:
+    """Ensure the message history ends with ModelRequest for PydanticAI compatibility."""
+    last_user_request = get_last_user_request(original_messages)
+
+    if not last_user_request:
+        return compacted_messages
+
+    # Check if we need to add the last request or restructure
+    if compacted_messages and isinstance(compacted_messages[0], ModelRequest):
+        first_request = compacted_messages[0]
+        last_user_content = get_user_content_from_request(last_user_request)
+        first_user_content = get_user_content_from_request(first_request)
+
+        if last_user_content != first_user_content:
+            # Different messages - append the last request
+            compacted_messages.append(last_user_request)
+        else:
+            # Same message - restructure to end with ModelRequest
+            if len(compacted_messages) >= 2:
+                summary_message = compacted_messages[1]  # The summary
+                compacted_messages = [summary_message, first_request]
+    else:
+        # No first request, just add the last one
+        compacted_messages.append(last_user_request)
+
+    return compacted_messages
+
+
+def _create_base_request(system_prompt: str, user_prompt: str) -> ModelRequest:
+    """Create the base ModelRequest with system and user prompts."""
+    parts: list[ModelRequestPart] = []
+
+    if system_prompt:
+        parts.append(SystemPromptPart(content=system_prompt))
+
+    if user_prompt:
+        parts.append(UserPromptPart(content=user_prompt))
+
+    return ModelRequest(parts=parts)