code-puppy 0.0.171__py3-none-any.whl → 0.0.173__py3-none-any.whl

code_puppy/agent.py

@@ -7,10 +7,7 @@ from pydantic_ai import Agent
 from pydantic_ai.settings import ModelSettings
 from pydantic_ai.usage import UsageLimits
 
-from code_puppy.message_history_processor import (
-    get_model_context_length,
-    message_history_accumulator,
-)
+from code_puppy.message_history_processor import message_history_accumulator
 from code_puppy.messaging.message_queue import (
     emit_error,
     emit_info,
@@ -48,7 +45,7 @@ _code_generation_agent = None
 def _load_mcp_servers(extra_headers: Optional[Dict[str, str]] = None):
     """Load MCP servers using the new manager while maintaining backward compatibility."""
     from code_puppy.config import get_value, load_mcp_server_configs
-    from code_puppy.mcp import ServerConfig, get_mcp_manager
+    from code_puppy.mcp_ import ServerConfig, get_mcp_manager
 
     # Check if MCP servers are disabled
     mcp_disabled = get_value("disable_mcp_servers")
@@ -113,7 +110,7 @@ def _load_mcp_servers(extra_headers: Optional[Dict[str, str]] = None):
 
 def reload_mcp_servers():
     """Reload MCP servers without restarting the agent."""
-    from code_puppy.mcp import get_mcp_manager
+    from code_puppy.mcp_ import get_mcp_manager
 
     manager = get_mcp_manager()
     # Reload configurations
@@ -167,14 +164,17 @@ def reload_code_generation_agent(message_group: str | None):
 
     # Configure model settings with max_tokens if set
     model_settings_dict = {"seed": 42}
-    output_tokens = max(2048, min(int(0.05 * get_model_context_length()) - 1024, 16384))
+    # Get current agent to use its method
+    from code_puppy.agents import get_current_agent_config
+    current_agent = get_current_agent_config()
+    output_tokens = max(2048, min(int(0.05 * current_agent.get_model_context_length()) - 1024, 16384))
     console.print(f"Max output tokens per message: {output_tokens}")
     model_settings_dict["max_tokens"] = output_tokens
 
 
     model_settings = ModelSettings(**model_settings_dict)
     if "gpt-5" in model_name:
-        model_settings_dict["openai_reasoning_effort"] = "high"
+        model_settings_dict["openai_reasoning_effort"] = "off"
         model_settings_dict["extra_body"] = {
             "verbosity": "low"
         }

code_puppy/agents/agent_creator_agent.py

@@ -245,9 +245,6 @@ Best-practice guidelines for `invoke_agent`:
 Your solutions should be production-ready, maintainable, and follow best practices for the chosen language.
 
 Return your final response as a string output
-Walmart specific rules:
- - You are operating inside Walmart Global Tech! Yay!
- - Always use uv when working with python, and always use --index-url https://pypi.ci.artifacts.walmart.com/artifactory/api/pypi/external-pypi/simple
 
 ## Tool Templates:
 

code_puppy/agents/agent_qa_kitten.py

@@ -0,0 +1,203 @@
+"""Quality Assurance Kitten - Playwright-powered browser automation agent."""
+
+from .base_agent import BaseAgent
+
+
+class QualityAssuranceKittenAgent(BaseAgent):
+    """Quality Assurance Kitten - Advanced browser automation with Playwright."""
+
+    @property
+    def name(self) -> str:
+        return "qa-kitten"
+
+    @property
+    def display_name(self) -> str:
+        return "Quality Assurance Kitten 🐱"
+
+    @property
+    def description(self) -> str:
+        return "Advanced web browser automation and quality assurance testing using Playwright with VQA capabilities"
+
+    def get_available_tools(self) -> list[str]:
+        """Get the list of tools available to Web Browser Puppy."""
+        return [
+            # Core agent tools
+            "agent_share_your_reasoning",
+            # Browser control and initialization
+            "browser_initialize",
+            "browser_close",
+            "browser_status",
+            "browser_new_page",
+            "browser_list_pages",
+            # Browser navigation
+            "browser_navigate",
+            "browser_get_page_info",
+            "browser_go_back",
+            "browser_go_forward",
+            "browser_reload",
+            "browser_wait_for_load",
+            # Element discovery (semantic locators preferred)
+            "browser_find_by_role",
+            "browser_find_by_text",
+            "browser_find_by_label",
+            "browser_find_by_placeholder",
+            "browser_find_by_test_id",
+            "browser_find_buttons",
+            "browser_find_links",
+            "browser_xpath_query",  # Fallback when semantic locators fail
+            # Element interactions
+            "browser_click",
+            "browser_double_click",
+            "browser_hover",
+            "browser_set_text",
+            "browser_get_text",
+            "browser_get_value",
+            "browser_select_option",
+            "browser_check",
+            "browser_uncheck",
+            # Advanced features
+            "browser_execute_js",
+            "browser_scroll",
+            "browser_scroll_to_element",
+            "browser_set_viewport",
+            "browser_wait_for_element",
+            "browser_highlight_element",
+            "browser_clear_highlights",
+            # Screenshots and VQA
+            "browser_screenshot_analyze",
+            # Workflow management
+            "browser_save_workflow",
+            "browser_list_workflows",
+            "browser_read_workflow",
+        ]
+
+    def get_system_prompt(self) -> str:
+        """Get Web Browser Puppy's specialized system prompt."""
+        return """
+You are Quality Assurance Kitten 🐱, an advanced autonomous browser automation and QA testing agent powered by Playwright!
+
+You specialize in:
+🎯 **Quality Assurance Testing** - automated testing of web applications and user workflows
+👁️ **Visual verification** - taking screenshots and analyzing page content for bugs
+🔍 **Element discovery** - finding elements using semantic locators and accessibility best practices
+📝 **Data extraction** - scraping content and gathering information from web pages
+🧪 **Web automation** - filling forms, clicking buttons, navigating sites with precision
+🐛 **Bug detection** - identifying UI issues, broken functionality, and accessibility problems
+
+## Core Workflow Philosophy
+
+For any browser task, follow this approach:
+1. **Check Existing Workflows**: Use browser_list_workflows to see if similar tasks have been solved before
+2. **Learn from History**: If relevant workflows exist, use browser_read_workflow to review proven strategies
+3. **Plan & Reason**: Use share_your_reasoning to break down complex tasks and explain your approach
+4. **Initialize**: Always start with browser_initialize if browser isn't running
+5. **Navigate**: Use browser_navigate to reach the target page
+6. **Discover**: Use semantic locators (PREFERRED) for element discovery
+7. **Verify**: Use highlighting and screenshots to confirm elements
+8. **Act**: Interact with elements through clicks, typing, etc.
+9. **Validate**: Take screenshots or query DOM to verify actions worked
+10. **Document Success**: Use browser_save_workflow to save successful patterns for future reuse
+
+## Tool Usage Guidelines
+
+### Browser Initialization
+- **ALWAYS call browser_initialize first** before any other browser operations
+- Choose appropriate settings: headless=False for debugging, headless=True for production
+- Use browser_status to check current state
+
+### Element Discovery Best Practices (ACCESSIBILITY FIRST! 🌟)
+- **PREFER semantic locators** - they're more reliable and follow accessibility standards
+- Priority order:
+  1. browser_find_by_role (button, link, textbox, heading, etc.)
+  2. browser_find_by_label (for form inputs)
+  3. browser_find_by_text (for visible text)
+  4. browser_find_by_placeholder (for input hints)
+  5. browser_find_by_test_id (for test-friendly elements)
+  6. browser_xpath_query (ONLY as last resort)
+
+### Visual Verification Workflow
+- **Before critical actions**: Use browser_highlight_element to visually confirm
+- **After interactions**: Use browser_screenshot_analyze to verify results
+- **VQA questions**: Ask specific, actionable questions like "Is the login button highlighted?"
+
+### Form Input Best Practices
+- **ALWAYS check current values** with browser_get_value before typing
+- Use browser_get_value after typing to verify success
+- This prevents typing loops and gives clear visibility into form state
+- Clear fields when appropriate before entering new text
+
+### Error Handling & Troubleshooting
+
+**When Element Discovery Fails:**
+1. Try different semantic locators first
+2. Use browser_find_buttons or browser_find_links to see available elements
+3. Take a screenshot with browser_screenshot_analyze to understand the page layout
+4. Only use XPath as absolute last resort
+
+**When Page Interactions Fail:**
+1. Check if element is visible with browser_wait_for_element
+2. Scroll element into view with browser_scroll_to_element
+3. Use browser_highlight_element to confirm element location
+4. Try browser_execute_js for complex interactions
+
+### JavaScript Execution
+- Use browser_execute_js for:
+  - Complex page state checks
+  - Custom scrolling behavior
+  - Triggering events that standard tools can't handle
+  - Accessing browser APIs
+
+### Workflow Management 📋
+
+**ALWAYS start new tasks by checking for existing workflows!**
+
+**At the beginning of any automation task:**
+1. **browser_list_workflows** - Check what workflows are already available
+2. **browser_read_workflow** - If you find a relevant workflow, read it to understand the proven approach
+3. Adapt and apply the successful patterns from existing workflows
+
+**When to save workflows:**
+- After successfully completing a complex multi-step task
+- When you discover a reliable pattern for a common website interaction
+- After troubleshooting and finding working solutions for tricky elements
+- Include both the successful steps AND the challenges/solutions you encountered
+
+**Workflow naming conventions:**
+- Use descriptive names like "search_and_atc_walmart", "login_to_github", "fill_contact_form"
+- Include the website domain for clarity
+- Focus on the main goal/outcome
+
+**What to include in saved workflows:**
+- Step-by-step tool usage with specific parameters
+- Element discovery strategies that worked
+- Common pitfalls and how to avoid them
+- Alternative approaches for edge cases
+- Tips for handling dynamic content
+
+### Performance & Best Practices
+- Use appropriate timeouts for element discovery (default 10s is usually fine)
+- Take screenshots strategically - not after every single action
+- Use browser_wait_for_load when navigating to ensure pages are ready
+- Clear highlights when done for clean visual state
+
+## Specialized Capabilities
+
+🌐 **WCAG 2.2 Level AA Compliance**: Always prioritize accessibility in element discovery
+📸 **Visual Question Answering**: Use browser_screenshot_analyze for intelligent page analysis
+🚀 **Semantic Web Navigation**: Prefer role-based and label-based element discovery
+⚡ **Playwright Power**: Full access to modern browser automation capabilities
+📋 **Workflow Management**: Save, load, and reuse automation patterns for consistency
+
+## Important Rules
+
+- **ALWAYS check for existing workflows first** - Use browser_list_workflows at the start of new tasks
+- **ALWAYS use browser_initialize before any browser operations**
+- **PREFER semantic locators over XPath** - they're more maintainable and accessible
+- **Use visual verification for critical actions** - highlight elements and take screenshots
+- **Be explicit about your reasoning** - use share_your_reasoning for complex workflows
+- **Handle errors gracefully** - provide helpful debugging information
+- **Follow accessibility best practices** - your automation should work for everyone
+- **Document your successes** - Save working patterns with browser_save_workflow for future reuse
+
+Your browser automation should be reliable, maintainable, and accessible. You are a meticulous QA engineer who catches bugs before users do! 🐱✨
+"""

code_puppy/agents/base_agent.py

@@ -1,13 +1,26 @@
 """Base agent configuration class for defining agent properties."""
 
+import json
+import queue
 import uuid
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, Set
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+import pydantic
+from pydantic_ai.messages import (
+    ModelMessage,
+    ModelRequest,
+    TextPart,
+    ToolCallPart,
+    ToolCallPartDelta,
+    ToolReturn,
+    ToolReturnPart,
+)
 
 
 class BaseAgent(ABC):
     """Base class for all agent configurations."""
-
+    
     def __init__(self):
         self.id = str(uuid.uuid4())
         self._message_history: List[Any] = []
@@ -114,3 +127,386 @@ class BaseAgent(ABC):
             message_hash: Hash of a message that has been compacted/summarized.
         """
         self._compacted_message_hashes.add(message_hash)
+
+    def get_model_name(self) -> Optional[str]:
+        """Get pinned model name for this agent, if specified.
+
+        Returns:
+            Model name to use for this agent, or None to use global default.
+        """
+        from ..config import get_agent_pinned_model
+        return get_agent_pinned_model(self.name)
+
+    # Message history processing methods (moved from state_management.py and message_history_processor.py)
+    def _stringify_part(self, part: Any) -> str:
+        """Create a stable string representation for a message part.
+
+        We deliberately ignore timestamps so identical content hashes the same even when
+        emitted at different times. This prevents status updates from blowing up the
+        history when they are repeated with new timestamps."""
+
+        attributes: List[str] = [part.__class__.__name__]
+
+        # Role/instructions help disambiguate parts that otherwise share content
+        if hasattr(part, "role") and part.role:
+            attributes.append(f"role={part.role}")
+        if hasattr(part, "instructions") and part.instructions:
+            attributes.append(f"instructions={part.instructions}")
+
+        if hasattr(part, "tool_call_id") and part.tool_call_id:
+            attributes.append(f"tool_call_id={part.tool_call_id}")
+
+        if hasattr(part, "tool_name") and part.tool_name:
+            attributes.append(f"tool_name={part.tool_name}")
+
+        content = getattr(part, "content", None)
+        if content is None:
+            attributes.append("content=None")
+        elif isinstance(content, str):
+            attributes.append(f"content={content}")
+        elif isinstance(content, pydantic.BaseModel):
+            attributes.append(f"content={json.dumps(content.model_dump(), sort_keys=True)}")
+        elif isinstance(content, dict):
+            attributes.append(f"content={json.dumps(content, sort_keys=True)}")
+        else:
+            attributes.append(f"content={repr(content)}")
+        result = "|".join(attributes)
+        return result
+
+    def hash_message(self, message: Any) -> int:
+        """Create a stable hash for a model message that ignores timestamps."""
+        role = getattr(message, "role", None)
+        instructions = getattr(message, "instructions", None)
+        header_bits: List[str] = []
+        if role:
+            header_bits.append(f"role={role}")
+        if instructions:
+            header_bits.append(f"instructions={instructions}")
+
+        part_strings = [self._stringify_part(part) for part in getattr(message, "parts", [])]
+        canonical = "||".join(header_bits + part_strings)
+        return hash(canonical)
+
+    def stringify_message_part(self, part) -> str:
+        """
+        Convert a message part to a string representation for token estimation or other uses.
+
+        Args:
+            part: A message part that may contain content or be a tool call
+
+        Returns:
+            String representation of the message part
+        """
+        result = ""
+        if hasattr(part, "part_kind"):
+            result += part.part_kind + ": "
+        else:
+            result += str(type(part)) + ": "
+
+        # Handle content
+        if hasattr(part, "content") and part.content:
+            # Handle different content types
+            if isinstance(part.content, str):
+                result = part.content
+            elif isinstance(part.content, pydantic.BaseModel):
+                result = json.dumps(part.content.model_dump())
+            elif isinstance(part.content, dict):
+                result = json.dumps(part.content)
+            else:
+                result = str(part.content)
+
+        # Handle tool calls which may have additional token costs
+        # If part also has content, we'll process tool calls separately
+        if hasattr(part, "tool_name") and part.tool_name:
+            # Estimate tokens for tool name and parameters
+            tool_text = part.tool_name
+            if hasattr(part, "args"):
+                tool_text += f" {str(part.args)}"
+            result += tool_text
+
+        return result
+
+    def estimate_tokens_for_message(self, message: ModelMessage) -> int:
+        """
+        Estimate the number of tokens in a message using len(message) - 4.
+        Simple and fast replacement for tiktoken.
+        """
+        total_tokens = 0
+
+        for part in message.parts:
+            part_str = self.stringify_message_part(part)
+            if part_str:
+                total_tokens += len(part_str)
+
+        return int(max(1, total_tokens) / 4)
+
+    def _is_tool_call_part(self, part: Any) -> bool:
+        if isinstance(part, (ToolCallPart, ToolCallPartDelta)):
+            return True
+
+        part_kind = (getattr(part, "part_kind", "") or "").replace("_", "-")
+        if part_kind == "tool-call":
+            return True
+
+        has_tool_name = getattr(part, "tool_name", None) is not None
+        has_args = getattr(part, "args", None) is not None
+        has_args_delta = getattr(part, "args_delta", None) is not None
+
+        return bool(has_tool_name and (has_args or has_args_delta))
+
+    def _is_tool_return_part(self, part: Any) -> bool:
+        if isinstance(part, (ToolReturnPart, ToolReturn)):
+            return True
+
+        part_kind = (getattr(part, "part_kind", "") or "").replace("_", "-")
+        if part_kind in {"tool-return", "tool-result"}:
+            return True
+
+        if getattr(part, "tool_call_id", None) is None:
+            return False
+
+        has_content = getattr(part, "content", None) is not None
+        has_content_delta = getattr(part, "content_delta", None) is not None
+        return bool(has_content or has_content_delta)
+
+    def filter_huge_messages(self, messages: List[ModelMessage]) -> List[ModelMessage]:
+        if not messages:
+            return []
+
+        # Never drop the system prompt, even if it is extremely large.
+        system_message, *rest = messages
+        filtered_rest = [
+            m for m in rest if self.estimate_tokens_for_message(m) < 50000
+        ]
+        return [system_message] + filtered_rest
+
+    def split_messages_for_protected_summarization(
+        self,
+        messages: List[ModelMessage],
+    ) -> Tuple[List[ModelMessage], List[ModelMessage]]:
+        """
+        Split messages into two groups: messages to summarize and protected recent messages.
+
+        Returns:
+            Tuple of (messages_to_summarize, protected_messages)
+
+        The protected_messages are the most recent messages that total up to the configured protected token count.
+        The system message (first message) is always protected.
+        All other messages that don't fit in the protected zone will be summarized.
+        """
+        if len(messages) <= 1:  # Just system message or empty
+            return [], messages
+
+        # Always protect the system message (first message)
+        system_message = messages[0]
+        system_tokens = self.estimate_tokens_for_message(system_message)
+
+        if len(messages) == 1:
+            return [], messages
+
+        # Get the configured protected token count
+        from ..config import get_protected_token_count
+        protected_tokens_limit = get_protected_token_count()
+
+        # Calculate tokens for messages from most recent backwards (excluding system message)
+        protected_messages = []
+        protected_token_count = system_tokens  # Start with system message tokens
+
+        # Go backwards through non-system messages to find protected zone
+        for i in range(len(messages) - 1, 0, -1):  # Stop at 1, not 0 (skip system message)
+            message = messages[i]
+            message_tokens = self.estimate_tokens_for_message(message)
+
+            # If adding this message would exceed protected tokens, stop here
+            if protected_token_count + message_tokens > protected_tokens_limit:
+                break
+
+            protected_messages.append(message)
+            protected_token_count += message_tokens
+
+        # Messages that were added while scanning backwards are currently in reverse order.
+        # Reverse them to restore chronological ordering, then prepend the system prompt.
+        protected_messages.reverse()
+        protected_messages.insert(0, system_message)
+
+        # Messages to summarize are everything between the system message and the
+        # protected tail zone we just constructed.
+        protected_start_idx = max(1, len(messages) - (len(protected_messages) - 1))
+        messages_to_summarize = messages[1:protected_start_idx]
+
+        # Emit info messages
+        from ..messaging import emit_info
+        emit_info(
+            f"🔒 Protecting {len(protected_messages)} recent messages ({protected_token_count} tokens, limit: {protected_tokens_limit})"
+        )
+        emit_info(f"📝 Summarizing {len(messages_to_summarize)} older messages")
+
+        return messages_to_summarize, protected_messages
+
+    def summarize_messages(
+        self,
+        messages: List[ModelMessage],
+        with_protection: bool = True
+    ) -> Tuple[List[ModelMessage], List[ModelMessage]]:
+        """
+        Summarize messages while protecting recent messages up to PROTECTED_TOKENS.
+
+        Returns:
+            Tuple of (compacted_messages, summarized_source_messages)
+            where compacted_messages always preserves the original system message
+            as the first entry.
+        """
+        messages_to_summarize: List[ModelMessage]
+        protected_messages: List[ModelMessage]
+
+        if with_protection:
+            messages_to_summarize, protected_messages = (
+                self.split_messages_for_protected_summarization(messages)
+            )
+        else:
+            messages_to_summarize = messages[1:] if messages else []
+            protected_messages = messages[:1]
+
+        if not messages:
+            return [], []
+
+        system_message = messages[0]
+
+        if not messages_to_summarize:
+            # Nothing to summarize, so just return the original sequence
+            return self.prune_interrupted_tool_calls(messages), []
+
+        instructions = (
+            "The input will be a log of Agentic AI steps that have been taken"
+            " as well as user queries, etc. Summarize the contents of these steps."
+            " The high level details should remain but the bulk of the content from tool-call"
+            " responses should be compacted and summarized. For example if you see a tool-call"
+            " reading a file, and the file contents are large, then in your summary you might just"
+            " write: * used read_file on space_invaders.cpp - contents removed."
+            "\n Make sure your result is a bulleted list of all steps and interactions."
+            "\n\nNOTE: This summary represents older conversation history. Recent messages are preserved separately."
+        )
+
+        try:
+            from ..summarization_agent import run_summarization_sync
+            new_messages = run_summarization_sync(
+                instructions, message_history=messages_to_summarize
+            )
+
+            if not isinstance(new_messages, list):
+                from ..messaging import emit_warning
+                emit_warning(
+                    "Summarization agent returned non-list output; wrapping into message request"
+                )
+                new_messages = [ModelRequest([TextPart(str(new_messages))])]
+
+            compacted: List[ModelMessage] = [system_message] + list(new_messages)
+
+            # Drop the system message from protected_messages because we already included it
+            protected_tail = [msg for msg in protected_messages if msg is not system_message]
+
+            compacted.extend(protected_tail)
+
+            return self.prune_interrupted_tool_calls(compacted), messages_to_summarize
+        except Exception as e:
+            from ..messaging import emit_error
+            emit_error(f"Summarization failed during compaction: {e}")
+            return messages, []  # Return original messages on failure
+
+    def summarize_message(self, message: ModelMessage) -> ModelMessage:
+        try:
+            # If the message looks like a system/instructions message, skip summarization
+            instructions = getattr(message, "instructions", None)
+            if instructions:
+                return message
+            # If any part is a tool call, skip summarization
+            for part in message.parts:
+                if isinstance(part, ToolCallPart) or getattr(part, "tool_name", None):
+                    return message
+            # Build prompt from textual content parts
+            content_bits: List[str] = []
+            for part in message.parts:
+                s = self.stringify_message_part(part)
+                if s:
+                    content_bits.append(s)
+            if not content_bits:
+                return message
+            prompt = "Please summarize the following user message:\n" + "\n".join(
+                content_bits
+            )
+            
+            from ..summarization_agent import run_summarization_sync
+            output_text = run_summarization_sync(prompt)
+            summarized = ModelRequest([TextPart(output_text)])
+            return summarized
+        except Exception as e:
+            from ..messaging import emit_error
+            emit_error(f"Summarization failed: {e}")
+            return message
+
+    def get_model_context_length(self) -> int:
+        """
+        Get the context length for the currently configured model from models.json
+        """
+        from ..config import get_model_name
+        from ..model_factory import ModelFactory
+
+        model_configs = ModelFactory.load_config()
+        model_name = get_model_name()
+
+        # Get context length from model config
+        model_config = model_configs.get(model_name, {})
+        context_length = model_config.get("context_length", 128000)  # Default value
+
+        return int(context_length)
+
+    def prune_interrupted_tool_calls(self, messages: List[ModelMessage]) -> List[ModelMessage]:
+        """
+        Remove any messages that participate in mismatched tool call sequences.
+
+        A mismatched tool call id is one that appears in a ToolCall (model/tool request)
+        without a corresponding tool return, or vice versa. We preserve original order
+        and only drop messages that contain parts referencing mismatched tool_call_ids.
+        """
+        if not messages:
+            return messages
+
+        tool_call_ids: Set[str] = set()
+        tool_return_ids: Set[str] = set()
+
+        # First pass: collect ids for calls vs returns
+        for msg in messages:
+            for part in getattr(msg, "parts", []) or []:
+                tool_call_id = getattr(part, "tool_call_id", None)
+                if not tool_call_id:
+                    continue
+
+                if self._is_tool_call_part(part) and not self._is_tool_return_part(part):
+                    tool_call_ids.add(tool_call_id)
+                elif self._is_tool_return_part(part):
+                    tool_return_ids.add(tool_call_id)
+
+        mismatched: Set[str] = tool_call_ids.symmetric_difference(tool_return_ids)
+        if not mismatched:
+            return messages
+
+        pruned: List[ModelMessage] = []
+        dropped_count = 0
+        for msg in messages:
+            has_mismatched = False
+            for part in getattr(msg, "parts", []) or []:
+                tcid = getattr(part, "tool_call_id", None)
+                if tcid and tcid in mismatched:
+                    has_mismatched = True
+                    break
+            if has_mismatched:
+                dropped_count += 1
+                continue
+            pruned.append(msg)
+
+        if dropped_count:
+            from ..messaging import emit_warning
+            emit_warning(
+                f"Pruned {dropped_count} message(s) with mismatched tool_call_id pairs"
+            )
+        return pruned