shotgun-sh 0.10.2.dev2__tar.gz → 0.10.3.dev2__tar.gz

{shotgun_sh-0.10.2.dev2 → shotgun_sh-0.10.3.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgun-sh
-Version: 0.10.2.dev2
+Version: 0.10.3.dev2
 Summary: AI-powered research, planning, and task management CLI tool
 Project-URL: Homepage, https://shotgun.sh/
 Project-URL: Repository, https://github.com/shotgun-sh/shotgun
@@ -34,7 +34,7 @@ Requires-Dist: packaging>=23.0
 Requires-Dist: pathspec>=0.12.0
 Requires-Dist: posthog>=3.0.0
 Requires-Dist: psutil>=5.9.0
-Requires-Dist: pydantic-ai==1.58.0
+Requires-Dist: pydantic-ai==1.59.0
 Requires-Dist: pydantic-settings>=2.0.0
 Requires-Dist: pyperclip>=1.10.0
 Requires-Dist: real-ladybug==0.14.1

{shotgun_sh-0.10.2.dev2 → shotgun_sh-0.10.3.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shotgun-sh"
-version = "0.10.2.dev2"
+version = "0.10.3.dev2"
 description = "AI-powered research, planning, and task management CLI tool"
 readme = "README.md"
 license = { text = "MIT" }
@@ -24,7 +24,7 @@ classifiers = [
 dependencies = [
     "typer>=0.12.0",
     "rich>=13.0.0",
-    "pydantic-ai==1.58.0",  # Pinned due to bug workaround in gemini3_patch.py
+    "pydantic-ai==1.59.0",  # Pinned due to bug workaround in gemini3_patch.py
     "pydantic-settings>=2.0.0",
     "httpx>=0.27.0",
     "jinja2>=3.1.0",

{shotgun_sh-0.10.2.dev2 → shotgun_sh-0.10.3.dev2}/src/shotgun/agents/agent_manager.py

@@ -86,12 +86,14 @@ from shotgun.agents.models import (
 )
 from shotgun.attachments import FileAttachment
 from shotgun.exceptions import IncompleteToolCallError
+from shotgun.posthog_telemetry import flush as flush_telemetry
 from shotgun.posthog_telemetry import track_event
 from shotgun.tui.screens.chat_screen.hint_message import HintMessage
 from shotgun.tui.screens.chat_screen.welcome_message import WelcomeMessage
 from shotgun.utils.source_detection import detect_source
 
 from .conversation.history.compaction import apply_persistent_compaction
+from .conversation.history.constants import MAX_UI_HISTORY_MESSAGES
 from .export import create_export_agent
 from .messages import AgentSystemPrompt, InternalPromptPart
 from .models import AgentDeps, AgentRuntimeOptions
@@ -422,6 +424,27 @@ class AgentManager(Widget):
         )
         self._agents_initialized = True
 
+    async def cleanup_agents(self) -> None:
+        """Release all agent instances and their held resources."""
+        if self._router_deps is not None:
+            self._router_deps.sub_agent_cache.clear()
+            self._router_deps.parent_stream_handler = None
+            self._router_deps.on_plan_changed = None
+
+        self._research_agent = None
+        self._research_deps = None
+        self._plan_agent = None
+        self._plan_deps = None
+        self._tasks_agent = None
+        self._tasks_deps = None
+        self._specify_agent = None
+        self._specify_deps = None
+        self._export_agent = None
+        self._export_deps = None
+        self._router_agent = None
+        self._router_deps = None
+        self._agents_initialized = False
+
     @property
     def research_agent(self) -> ShotgunAgent:
         """Get research agent (must call _ensure_agents_initialized first)."""
@@ -1103,6 +1126,9 @@ class AgentManager(Widget):
             raise
         finally:
             self._stream_state = None
+            # Flush PostHog events between agent runs to prevent
+            # unbounded queue growth during long-running sessions
+            flush_telemetry()
 
         # Agent ALWAYS returns AgentResponse with structured output
         agent_response = result.output
@@ -1403,6 +1429,9 @@ class AgentManager(Widget):
                 extra={"agent_mode": self._current_agent_type.value},
             )
 
+        # Prune old hint/welcome messages to prevent unbounded UI history growth
+        self._prune_ui_message_history()
+
         # Post final UI update after compaction completes
         # This ensures widgets that depend on message_history (like context indicator)
         # receive the updated history after compaction
@@ -1663,6 +1692,11 @@ class AgentManager(Widget):
                 # Mark as sub-agent response for rendering with ↳ prefix
                 final_message._shotgun_is_sub_agent = True  # type: ignore[attr-defined]
                 self._sub_agent_messages.append(final_message)
+                if len(self._sub_agent_messages) > 200:
+                    logger.warning(
+                        "_sub_agent_messages exceeded 200 entries, truncating to most recent 100"
+                    )
+                    self._sub_agent_messages = self._sub_agent_messages[-100:]
 
         state.current_response = None
 
@@ -1696,6 +1730,16 @@ class AgentManager(Widget):
             self.ui_message_history.insert(insert_idx + j, msg)
         self._sub_agent_messages = []
 
+    def _prune_ui_message_history(self) -> None:
+        """Keep only the last MAX_UI_HISTORY_MESSAGES items in ui_message_history.
+
+        Acts as a circular buffer — oldest messages of any type are dropped.
+        """
+        if len(self.ui_message_history) <= MAX_UI_HISTORY_MESSAGES:
+            return
+
+        self.ui_message_history = self.ui_message_history[-MAX_UI_HISTORY_MESSAGES:]
+
     def _build_partial_response(
         self, parts: list[ModelResponsePart | ToolCallPartDelta]
     ) -> ModelResponse | None:

{shotgun_sh-0.10.2.dev2 → shotgun_sh-0.10.3.dev2}/src/shotgun/agents/config/provider.py

@@ -1,6 +1,7 @@
 """Provider management for LLM configuration."""
 
 from copy import deepcopy
+from functools import lru_cache
 
 from pydantic import SecretStr
 from pydantic_ai._json_schema import JsonSchema, JsonSchemaTransformer
@@ -105,10 +106,9 @@ class OllamaCompatibleJsonSchemaTransformer(JsonSchemaTransformer):
         return schema
 
 
-# Global cache for Model instances (singleton pattern)
-_model_cache: dict[
-    tuple[ProviderType, KeyProvider, ModelName | str, str, str | None], Model
-] = {}
+# Max number of cached Model instances (LRU eviction)
+_MAX_MODEL_CACHE_SIZE = 8
+
 
 # Module-level model override for OpenAI-compatible mode (set via --model CLI flag)
 _openai_compat_model_override: str | None = None
@@ -226,6 +226,7 @@ def get_default_model_for_provider(config: ShotgunConfig) -> ModelName:
     return ModelName.CLAUDE_OPUS_4_5
 
 
+@lru_cache(maxsize=_MAX_MODEL_CACHE_SIZE)
 def get_or_create_model(
     provider: ProviderType,
     key_provider: "KeyProvider",
@@ -235,6 +236,8 @@ def get_or_create_model(
 ) -> Model:
     """Get or create a singleton Model instance.
 
+    Bounded by ``functools.lru_cache`` (maxsize=8) with automatic LRU eviction.
+
     Args:
         provider: Actual LLM provider (openai, anthropic, google)
         key_provider: Authentication method (byok or shotgun)
@@ -248,111 +251,90 @@ def get_or_create_model(
     Raises:
         ValueError: If provider is not supported
     """
-    cache_key = (provider, key_provider, model_name, api_key, base_url)
-
-    if cache_key not in _model_cache:
-        logger.debug(
-            "Creating new %s model instance via %s: %s",
-            provider.value,
-            key_provider.value,
-            model_name,
+    logger.debug(
+        "Creating new %s model instance via %s: %s",
+        provider.value,
+        key_provider.value,
+        model_name,
+    )
+
+    # Get max_tokens from MODEL_SPECS (only for known models)
+    if isinstance(model_name, ModelName) and model_name in MODEL_SPECS:
+        max_tokens = MODEL_SPECS[model_name].max_output_tokens
+    else:
+        max_tokens = {
+            ProviderType.OPENAI: 16_000,
+            ProviderType.ANTHROPIC: 32_000,
+            ProviderType.GOOGLE: 64_000,
+            ProviderType.OPENAI_COMPATIBLE: 16_000,
+        }.get(provider, 16_000)
+
+    # Handle OpenAI-compatible endpoints (uses provided base_url or settings)
+    if provider == ProviderType.OPENAI_COMPATIBLE:
+        return _create_openai_compat_model(
+            api_key, str(model_name), max_tokens, base_url
+        )
+
+    # At this point, model_name must be a ModelName (string handled above via OPENAI_COMPATIBLE)
+    if not isinstance(model_name, ModelName):
+        raise ValueError(
+            f"Unknown model name: {model_name}. "
+            "For custom models, set SHOTGUN_OPENAI_COMPAT_BASE_URL."
         )
 
-        # Get max_tokens from MODEL_SPECS (only for known models)
-        if isinstance(model_name, ModelName) and model_name in MODEL_SPECS:
-            max_tokens = MODEL_SPECS[model_name].max_output_tokens
+    if key_provider == KeyProvider.SHOTGUN:
+        # 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 defaults based on provider
-            max_tokens = {
-                ProviderType.OPENAI: 16_000,
-                ProviderType.ANTHROPIC: 32_000,
-                ProviderType.GOOGLE: 64_000,
-                ProviderType.OPENAI_COMPATIBLE: 16_000,
-            }.get(provider, 16_000)
-
-        # Handle OpenAI-compatible endpoints (uses provided base_url or settings)
-        if provider == ProviderType.OPENAI_COMPATIBLE:
-            _model_cache[cache_key] = _create_openai_compat_model(
-                api_key, str(model_name), max_tokens, base_url
+            litellm_model_name = f"openai/{model_name.value}"
+
+        if provider == ProviderType.ANTHROPIC:
+            anthropic_provider = create_anthropic_proxy_provider(api_key)
+            return AnthropicModel(
+                model_name.value,
+                provider=anthropic_provider,
+                settings=AnthropicModelSettings(
+                    max_tokens=max_tokens,
+                    timeout=600,
+                ),
             )
-            return _model_cache[cache_key]
-
-        # Use LiteLLM proxy for Shotgun Account, native providers for BYOK
-        # At this point, model_name must be a ModelName (string handled above via OPENAI_COMPATIBLE)
-        if not isinstance(model_name, ModelName):
-            raise ValueError(
-                f"Unknown model name: {model_name}. "
-                "For custom models, set SHOTGUN_OPENAI_COMPAT_BASE_URL."
+        else:
+            litellm_provider = create_litellm_provider(api_key)
+            return OpenAIChatModel(
+                litellm_model_name,
+                provider=litellm_provider,
+                settings=ModelSettings(max_tokens=max_tokens),
+            )
+    elif key_provider == KeyProvider.BYOK:
+        if provider == ProviderType.OPENAI:
+            openai_provider = OpenAIProvider(api_key=api_key)
+            return OpenAIResponsesModel(
+                model_name,
+                provider=openai_provider,
+                settings=ModelSettings(max_tokens=max_tokens),
+            )
+        elif provider == ProviderType.ANTHROPIC:
+            anthropic_provider = AnthropicProvider(api_key=api_key)
+            return AnthropicModel(
+                model_name,
+                provider=anthropic_provider,
+                settings=AnthropicModelSettings(
+                    max_tokens=max_tokens,
+                    timeout=600,
+                ),
+            )
+        elif provider == ProviderType.GOOGLE:
+            google_provider = GoogleProvider(api_key=api_key)
+            return GoogleModel(
+                model_name,
+                provider=google_provider,
+                settings=ModelSettings(max_tokens=max_tokens),
             )
-
-        if key_provider == KeyProvider.SHOTGUN:
-            # 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}"
-
-            # 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
-                # Note: Use OpenAIChatModel (not OpenAIResponsesModel) because LiteLLM's
-                # streaming Responses API doesn't return tool calls properly for Gemini 3
-                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:
-                openai_provider = OpenAIProvider(api_key=api_key)
-                _model_cache[cache_key] = OpenAIResponsesModel(
-                    model_name,
-                    provider=openai_provider,
-                    settings=ModelSettings(max_tokens=max_tokens),
-                )
-            elif provider == ProviderType.ANTHROPIC:
-                anthropic_provider = AnthropicProvider(api_key=api_key)
-                _model_cache[cache_key] = AnthropicModel(
-                    model_name,
-                    provider=anthropic_provider,
-                    settings=AnthropicModelSettings(
-                        max_tokens=max_tokens,
-                        timeout=600,  # 10 minutes timeout for large responses
-                    ),
-                )
-            elif provider == ProviderType.GOOGLE:
-                google_provider = GoogleProvider(api_key=api_key)
-                _model_cache[cache_key] = GoogleModel(
-                    model_name,
-                    provider=google_provider,
-                    settings=ModelSettings(max_tokens=max_tokens),
-                )
-            else:
-                raise ValueError(f"Unsupported provider: {provider}")
         else:
-            raise ValueError(f"Unsupported key provider: {key_provider}")
+            raise ValueError(f"Unsupported provider: {provider}")
     else:
-        logger.debug("Reusing cached %s model instance: %s", provider.value, model_name)
-
-    return _model_cache[cache_key]
+        raise ValueError(f"Unsupported key provider: {key_provider}")
 
 
 async def get_provider_model(

{shotgun_sh-0.10.2.dev2 → shotgun_sh-0.10.3.dev2}/src/shotgun/agents/context_analyzer/analyzer.py

@@ -20,6 +20,7 @@ from shotgun.agents.conversation.history.token_counting.utils import (
 )
 from shotgun.agents.conversation.history.token_estimation import (
     estimate_tokens_from_messages,
+    get_last_api_token_count,
 )
 from shotgun.agents.messages import AgentSystemPrompt, SystemStatusPrompt
 from shotgun.logging_config import get_logger
@@ -66,14 +67,9 @@ class ContextAnalyzer:
             TokenAllocation with token counts by message/tool type
         """
         # Step 1: Find the last response's usage data (ground truth for input tokens)
-        last_input_tokens = 0
+        last_input_tokens = get_last_api_token_count(message_history)
         total_output_tokens = 0
 
-        for msg in reversed(message_history):
-            if isinstance(msg, ModelResponse) and msg.usage:
-                last_input_tokens = msg.usage.input_tokens + msg.usage.cache_read_tokens
-                break
-
         if last_input_tokens == 0:
             # Fallback to token estimation (no logging to reduce verbosity)
             last_input_tokens = await estimate_tokens_from_messages(

{shotgun_sh-0.10.2.dev2 → shotgun_sh-0.10.3.dev2}/src/shotgun/agents/conversation/history/compaction.py

@@ -7,7 +7,7 @@ from shotgun.agents.models import AgentDeps
 from shotgun.logging_config import get_logger
 from shotgun.posthog_telemetry import track_event
 
-from .token_estimation import estimate_tokens_from_messages
+from .token_estimation import estimate_tokens_from_messages, get_last_api_token_count
 
 logger = get_logger(__name__)
 
@@ -36,7 +36,20 @@ async def apply_persistent_compaction(
 
     try:
         # Count tokens to decide if LLM-based compaction is needed
-        estimated_tokens = await estimate_tokens_from_messages(messages, deps.llm_model)
+        # Prefer API usage data (accurate) over text-based estimation (undercounts)
+        api_tokens = get_last_api_token_count(messages)
+        if api_tokens > 0:
+            estimated_tokens = api_tokens
+            logger.debug(
+                f"Using API usage data for compaction check: {estimated_tokens} tokens"
+            )
+        else:
+            estimated_tokens = await estimate_tokens_from_messages(
+                messages, deps.llm_model
+            )
+            logger.debug(
+                f"Using text estimation for compaction check: {estimated_tokens} tokens (no API usage data)"
+            )
 
         # Create minimal usage info for compaction check
         usage = RequestUsage(

{shotgun_sh-0.10.2.dev2 → shotgun_sh-0.10.3.dev2}/src/shotgun/agents/conversation/history/constants.py

@@ -15,6 +15,9 @@ CHUNK_TARGET_RATIO = 0.60  # Target chunk size as % of max_input_tokens
 CHUNK_SAFE_RATIO = 0.70  # Max safe ratio before triggering chunked compaction
 RETENTION_WINDOW_MESSAGES = 5  # Keep last N message groups outside compaction
 
+# UI history pruning — keep the last N messages (any type) as a circular buffer
+MAX_UI_HISTORY_MESSAGES = 50
+
 
 class SummaryType(Enum):
     """Types of summarization requests for logging."""

{shotgun_sh-0.10.2.dev2 → shotgun_sh-0.10.3.dev2}/src/shotgun/agents/conversation/history/history_processors.py

@@ -35,6 +35,7 @@ from .token_estimation import (
 from .token_estimation import (
     estimate_post_summary_tokens,
     estimate_tokens_from_messages,
+    estimate_tokens_hybrid,
 )
 
 if TYPE_CHECKING:
@@ -453,7 +454,7 @@ async def token_limit_compactor(
     else:
         # Check if total conversation exceeds threshold for full compaction
         total_tokens = await _safe_token_estimation(
-            estimate_tokens_from_messages,
+            estimate_tokens_hybrid,
             deps.llm_model.name,
             model_max_tokens,
             messages,

{shotgun_sh-0.10.2.dev2 → shotgun_sh-0.10.3.dev2}/src/shotgun/agents/conversation/history/token_estimation.py

@@ -6,7 +6,7 @@ and libraries, replacing the old character-based estimation approach.
 
 from typing import TYPE_CHECKING, Union
 
-from pydantic_ai.messages import ModelMessage
+from pydantic_ai.messages import ModelMessage, ModelResponse
 
 from shotgun.agents.config.models import ModelConfig
 
@@ -15,9 +15,28 @@ if TYPE_CHECKING:
 
     from shotgun.agents.models import AgentDeps
 
+from shotgun.logging_config import get_logger
+
 from .constants import INPUT_BUFFER_TOKENS, MIN_SUMMARY_TOKENS
 from .token_counting import count_tokens_from_messages as _count_tokens_from_messages
 
+logger = get_logger(__name__)
+
+
+def get_last_api_token_count(messages: list[ModelMessage]) -> int:
+    """Extract the total input token count from the last ModelResponse's usage data.
+
+    API usage data is the most accurate source for token counts because it includes
+    message framing, tool schemas, system prompts, and binary content that text-based
+    estimation misses.
+
+    Returns 0 if no ModelResponse with nonzero usage data is found.
+    """
+    for msg in reversed(messages):
+        if isinstance(msg, ModelResponse) and msg.usage:
+            return msg.usage.input_tokens + msg.usage.cache_read_tokens
+    return 0
+
 
 async def estimate_tokens_from_messages(
     messages: list[ModelMessage], model_config: ModelConfig
@@ -41,6 +60,54 @@ async def estimate_tokens_from_messages(
     return await _count_tokens_from_messages(messages, model_config)
 
 
+async def estimate_tokens_hybrid(
+    messages: list[ModelMessage], model_config: ModelConfig
+) -> int:
+    """Estimate total tokens using API usage data plus delta counting.
+
+    This is more efficient than counting all messages from scratch. It uses the
+    last ModelResponse's usage data (which includes framing, schemas, etc.) as
+    the base count, then only counts the new messages added since that response.
+
+    Falls back to full counting when no API usage data is available (e.g. first turn).
+
+    Args:
+        messages: List of messages to count tokens for
+        model_config: Model configuration with provider info
+
+    Returns:
+        Estimated token count
+    """
+    # Single backward pass to find the last ModelResponse with usage data
+    api_count = 0
+    last_response_idx = -1
+    for i in range(len(messages) - 1, -1, -1):
+        msg = messages[i]
+        if isinstance(msg, ModelResponse) and msg.usage:
+            api_count = msg.usage.input_tokens + msg.usage.cache_read_tokens
+            if api_count > 0:
+                last_response_idx = i
+                break
+
+    if api_count == 0:
+        # First turn or no usage data — fall back to full counting
+        return await estimate_tokens_from_messages(messages, model_config)
+
+    delta_messages = messages[last_response_idx + 1 :]
+
+    if not delta_messages:
+        return api_count
+
+    delta_count = await estimate_tokens_from_messages(delta_messages, model_config)
+
+    logger.debug(
+        f"Hybrid token estimate: api_count={api_count}, delta_count={delta_count}, "
+        f"delta_messages={len(delta_messages)}, total={api_count + delta_count}"
+    )
+
+    return api_count + delta_count
+
+
 async def estimate_post_summary_tokens(
     messages: list[ModelMessage], summary_index: int, model_config: ModelConfig
 ) -> int:

{shotgun_sh-0.10.2.dev2 → shotgun_sh-0.10.3.dev2}/src/shotgun/agents/conversation/models.py

@@ -24,6 +24,38 @@ from .filters import (
 
 SerializedMessage = dict[str, Any]
 
+# Mapping of custom part_kind values to their pydantic-ai base part_kind.
+# Custom subclasses (e.g. SystemStatusPrompt, InternalPromptPart) override
+# part_kind with values that ModelMessagesTypeAdapter doesn't recognise,
+# causing deserialization to fail. Remapping before validation fixes this.
+_CUSTOM_PART_KIND_MAP: dict[str, str] = {
+    "system-status": "user-prompt",  # SystemStatusPrompt -> UserPromptPart
+    "internal-prompt": "user-prompt",  # InternalPromptPart -> UserPromptPart
+}
+
+
+def _sanitize_parts(messages: list[SerializedMessage]) -> list[SerializedMessage]:
+    """Remap custom part_kind values so ModelMessagesTypeAdapter can deserialize them."""
+    sanitized: list[SerializedMessage] = []
+    for msg in messages:
+        parts = msg.get("parts")
+        if not parts:
+            sanitized.append(msg)
+            continue
+        new_parts = []
+        changed = False
+        for part in parts:
+            pk = part.get("part_kind")
+            if pk in _CUSTOM_PART_KIND_MAP:
+                part = {**part, "part_kind": _CUSTOM_PART_KIND_MAP[pk]}
+                changed = True
+            new_parts.append(part)
+        if changed:
+            sanitized.append({**msg, "parts": new_parts})
+        else:
+            sanitized.append(msg)
+    return sanitized
+
 
 class FileReference(BaseModel):
     """Placeholder for binary content that was loaded from a file.
@@ -162,8 +194,9 @@ class ConversationHistory(BaseModel):
         if not self.agent_history:
             return []
 
-        # Deserialize from JSON format back to ModelMessage objects
-        return ModelMessagesTypeAdapter.validate_python(self.agent_history)
+        # Sanitize custom part_kind values before deserialization
+        sanitized = _sanitize_parts(self.agent_history)
+        return ModelMessagesTypeAdapter.validate_python(sanitized)
 
     def get_ui_messages(self) -> list[ModelMessage | HintMessage | WelcomeMessage]:
         """Get ui_history as a list of Model, hint, or welcome messages."""
@@ -189,7 +222,9 @@ class ConversationHistory(BaseModel):
             payload = item
             if isinstance(payload, dict):
                 payload = {k: v for k, v in payload.items() if k != "message_type"}
-            deserialized = ModelMessagesTypeAdapter.validate_python([payload])
+            deserialized = ModelMessagesTypeAdapter.validate_python(
+                _sanitize_parts([payload])
+            )
             messages.append(deserialized[0])
 
         return messages