polyrob 0.5.0__py3-none-any.whl

agents/task/agent/core/logging_io.py

@@ -0,0 +1,276 @@
+"""Logging / conversation-file output mixin (roadmap P9 decomposition; code-motion from service.py).
+
+The response/context/conversation/tool-output logging concern, moved verbatim off
+the ``Agent`` god-file. ``Agent`` composes ``LoggingIOMixin`` so call sites
+(``self._log_response``, ``self._log_context_breakdown``, ``self._save_conversation``,
+``self._log_tool_outputs`` — invoked from step.py/llm_runner.py) are unchanged.
+"""
+from __future__ import annotations
+
+import os
+from datetime import datetime
+from pathlib import Path
+from typing import Any, List
+
+from modules.llm.messages import BaseMessage, ToolMessage
+from agents.task.agent.views import AgentOutput, ActionResult
+from agents.task.telemetry.views import AgentRunTelemetryEvent
+
+
+class LoggingIOMixin:
+    """Response/context/conversation/tool-output logging for Agent."""
+
+    def _log_response(self, response: AgentOutput) -> None:
+        """Log the model's response"""
+        if 'Success' in response.current_state.evaluation_previous_goal:
+            status_indicator = "SUCCESS"
+        elif 'Failed' in response.current_state.evaluation_previous_goal:
+            status_indicator = "FAILED"
+        else:
+            status_indicator = "UNKNOWN"
+
+        # Log concise brain state summary (memory is most important for continuity)
+        self.logger.info(f"Evaluation: [{status_indicator}] {response.current_state.evaluation_previous_goal}")
+        self.logger.info(f"Memory: {response.current_state.memory}")
+
+        # Log other fields at debug level to reduce noise
+        self.logger.debug(f"Next goal: {response.current_state.next_goal}")
+        self.logger.debug(f"Reasoning: {response.current_state.reasoning}")
+        if response.current_state.phase:
+            self.logger.debug(f"Phase: {response.current_state.phase}")
+
+        if response.action:
+            self.logger.info(f"Actions: {len(response.action)} action(s)")
+            for i, action in enumerate(response.action):
+                try:
+                    action_dump = action.model_dump(exclude_unset=True)
+                    if not action_dump:
+                        # Handle empty action data
+                        self.logger.debug(f"  Action {i+1}/{len(response.action)}: Empty action data")
+                        continue
+
+                    # Safely get first key
+                    action_keys = list(action_dump.keys())
+                    if not action_keys:
+                        self.logger.debug(f"  Action {i+1}/{len(response.action)}: No keys in action data")
+                        continue
+
+                    action_type = action_keys[0]
+                    action_params = action_dump[action_type]
+
+                    # Log both the action type and its parameters at INFO level
+                    self.logger.info(f"  Action {i+1}/{len(response.action)}: {action_type} - Parameters: {action_params}")
+                    # Still keep the detailed JSON in debug for complete data
+                    self.logger.debug(f"  Details: {action.model_dump_json(exclude_unset=True)}")
+                except Exception as e:
+                    # Log error but continue processing other actions
+                    self.logger.error(f"Error logging action {i+1}: {str(e)}", exc_info=True)
+                    continue
+
+    def _log_context_breakdown(self):
+        """Log detailed context usage breakdown.
+
+        FIX (Context Optimization Phase 2): Real-time visibility into context consumption.
+        Logs breakdown by category: Foundation, H-MEM, Conversation, Tools
+        """
+        try:
+            # Diagnostic/logging-only call — must peek, not drain, one-shot
+            # ephemeral messages (CX-H3). The real provider call in
+            # next_action_internal.py keeps the draining default.
+            messages = self.message_manager.get_messages_for_llm(consume_ephemeral=False)
+
+            # Count by type
+            foundation_tokens = 0
+            hmem_tokens = 0
+            conversation_tokens = 0
+            tool_tokens = 0
+
+            for msg in messages:
+                tokens = self.message_manager._count_message_tokens(msg)
+
+                if msg == self.message_manager._system_message:
+                    foundation_tokens += tokens
+                elif msg == self.message_manager._initial_task_message:
+                    foundation_tokens += tokens
+                elif hasattr(msg, 'content') and '[Session Memory]' in str(msg.content):
+                    hmem_tokens += tokens
+                elif isinstance(msg, ToolMessage):
+                    tool_tokens += tokens
+                else:
+                    conversation_tokens += tokens
+
+            total_tokens = sum([foundation_tokens, hmem_tokens, conversation_tokens, tool_tokens])
+            usage_pct = (total_tokens / self.message_manager.max_input_tokens) * 100 if self.message_manager.max_input_tokens > 0 else 0
+
+            # Determine emoji
+            if usage_pct >= 65:
+                emoji = "🔴"
+            elif usage_pct >= 55:
+                emoji = "🟡"
+            else:
+                emoji = "🟢"
+
+            self.logger.info(
+                f"{emoji} Step {self.state.n_steps} Context: {total_tokens:,}/{self.message_manager.max_input_tokens:,} "
+                f"({usage_pct:.1f}%) | "
+                f"Foundation: {foundation_tokens:,} | "
+                f"H-MEM: {hmem_tokens:,} | "
+                f"Conv: {conversation_tokens:,} | "
+                f"Tools: {tool_tokens:,}"
+            )
+
+            # Warning if approaching compaction
+            if usage_pct >= 55:
+                self.logger.warning(
+                    f"⚠️  Context at {usage_pct:.0f}% - will compact at 65%"
+                )
+
+        except Exception as e:
+            self.logger.debug(f"Context breakdown failed: {e}")
+
+    def _save_conversation(self, input_messages: list[BaseMessage], response: Any) -> None:
+        """Save conversation to disk or telemetry for later retrieval"""
+        from agents.task.utils import safe_operation
+
+        # If no save path specified, just return
+        if not self.save_conversation_path:
+            return
+
+        def save_messages():
+            # Ensure path exists
+            path = Path(self.save_conversation_path)
+            os.makedirs(path.parent, exist_ok=True)
+
+            # Get encoding to use
+            encoding = self.save_conversation_path_encoding or 'utf-8'
+
+            with open(path, 'a', encoding=encoding) as f:
+                # If file is empty, add headers
+                if os.path.getsize(path) == 0:
+                    f.write(f'# Task: {self.task}\n')
+                    f.write(f'# Created at: {datetime.now().isoformat()}\n')
+                    f.write(f'# Model: {self.model_name}\n')
+                    f.write(f'# Agent ID: {self.agent_id}\n')
+                    f.write(f'# Session ID: {self.session_id}\n\n')
+
+                # Write timestamped step header
+                f.write(f'\n## Step {self.state.n_steps} ({datetime.now().isoformat()})\n\n')
+
+                # Write messages
+                f.write('### Input Messages\n')
+                self._write_messages_to_file(f, input_messages)
+
+                # Write response
+                f.write('\n### Response\n')
+                self._write_response_to_file(f, response)
+
+                # Write horizontal rule
+                f.write('\n---\n')
+
+        safe_operation(
+            save_messages,
+            self.logger,
+            f"Failed to save conversation to {self.save_conversation_path}",
+            default_value=None
+        )
+
+    def _write_messages_to_file(self, f: Any, messages: list[BaseMessage]) -> None:
+        """Write messages to conversation file (sanitised)."""
+        import json
+        for message in messages:
+            f.write(f' {message.__class__.__name__} \n')
+
+            if isinstance(message.content, list):
+                for item in message.content:
+                    if isinstance(item, dict) and item.get('type') == 'text':
+                        clean_txt = self._sanitize_text_for_log(item.get('text', ''))
+                        f.write(clean_txt.strip() + '\n')
+            elif isinstance(message.content, str):
+                try:
+                    content = json.loads(message.content)
+                    content = self._sanitize_structure_for_log(content)
+                    f.write(json.dumps(content, indent=2) + '\n')
+                except json.JSONDecodeError:
+                    f.write(self._sanitize_text_for_log(message.content.strip()) + '\n')
+
+            f.write('\n')
+
+    def _write_response_to_file(self, f: Any, response: Any) -> None:
+        """Write model response to conversation file (sanitised)."""
+        import json
+        f.write(' RESPONSE\n')
+        try:
+            resp_dict = json.loads(response.model_dump_json(exclude_unset=True))
+            resp_dict = self._sanitize_structure_for_log(resp_dict)
+            f.write(json.dumps(resp_dict, indent=2))
+        except Exception:
+            # Fallback – write raw if sanitisation fails
+            f.write(json.dumps(json.loads(response.model_dump_json(exclude_unset=True)), indent=2))
+
+    def _log_agent_run(self) -> None:
+        """Log the agent run"""
+
+        self.logger.debug(f'Version: {self.version}, Source: {self.source}')
+        self.telemetry_manager.capture_event(
+            AgentRunTelemetryEvent(
+                agent_id=self.agent_id,
+                use_vision=self.use_vision,
+                task=self.task,
+                model_name=self.model_name,
+                chat_model_library=self.chat_model_library,
+                version=self.version,
+                source=self.source,
+            )
+        )
+
+    def _log_tool_outputs(self, actions: List[Any], results: List[ActionResult], step_number: int):
+        """Log exact tool outputs with item counts (OPTIMIZATION: Task 1 - Nov 14, 2025)"""
+        if not self.tool_output_log_path:
+            return
+
+        try:
+            import json
+            from datetime import datetime as _dt
+
+            for idx, (action, result) in enumerate(zip(actions, results)):
+                tool_name = action.get('name') if isinstance(action, dict) else getattr(action, 'name', 'unknown')
+                arguments = action.get('arguments', {}) if isinstance(action, dict) else {}
+
+                log_entry = {
+                    "timestamp": _dt.now().isoformat(),
+                    "step": step_number,
+                    "tool": tool_name,
+                    "arguments": arguments,
+                    "result": {
+                        "content": result.extracted_content,
+                        "error": result.error,
+                        "bytes": len(result.extracted_content or "")
+                    }
+                }
+
+                # Add item count for lists
+                if result.extracted_content:
+                    try:
+                        parsed = json.loads(result.extracted_content)
+                        if isinstance(parsed, list):
+                            log_entry["result"]["item_count"] = len(parsed)
+                            log_entry["result"]["first_item"] = parsed[0] if parsed else None
+                    except (json.JSONDecodeError, TypeError, AttributeError):
+                        pass  # Content may not be JSON - skip enhanced logging
+
+                # Write to JSONL
+                with open(self.tool_output_log_path, 'a') as f:
+                    f.write(json.dumps(log_entry) + '\n')
+
+                # Console log with count
+                if "item_count" in log_entry["result"]:
+                    count = log_entry["result"]["item_count"]
+                    requested = arguments.get('count') or arguments.get('limit')
+
+                    if requested:
+                        self.logger.info(f"📊 {tool_name}: {count} items (requested: {requested})")
+                    else:
+                        self.logger.info(f"📊 {tool_name}: {count} items")
+
+        except Exception as e:
+            self.logger.error(f"Failed to log tool outputs: {e}")

agents/task/agent/core/loop_detection.py

@@ -0,0 +1,262 @@
+"""Loop-detection + intervention mixin (roadmap P9 decomposition; code-motion from service.py).
+
+Stop-flag checks, multi-signal action-loop detection (action repetition + memory
+similarity + goal stagnation), and the guidance-injection intervention. Moved
+verbatim off the ``Agent`` god-file; ``Agent`` composes ``LoopDetectionMixin``
+(call sites in the step loop and flow-efficiency tests unchanged via MRO).
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from modules.llm.messages import make_control_message, MessageOrigin
+from agents.task.agent.views import ActionResult
+
+
+class LoopDetectionMixin:
+    """Stop-flag handling + action-loop detection/intervention for Agent."""
+
+    def _check_if_stopped(self) -> bool:
+        """Handle stop flag. Returns True if execution should stop.
+
+        NOTE: Pause functionality removed. This method now only checks for stop.
+        When stopped, it raises InterruptedError to break out of the current step.
+        Users can send a new message to continue with a different task.
+        """
+        if self.state.stopped:
+            self.logger.info('⏹️ Agent execution stopped by control flag')
+            raise InterruptedError("Agent stopped")
+        # Legacy: treat paused as stopped for backwards compatibility
+        if self.state.paused:
+            self.logger.info('⏹️ Agent paused flag set - treating as stop (pause deprecated)')
+            self.state.stopped = True  # Normalize to stopped
+            raise InterruptedError("Agent stopped (paused flag deprecated)")
+        return False
+
+    def _trigger_loop_intervention(self, reason: str, clear_history: bool = False) -> None:
+        """Trigger loop intervention guidance without clearing history.
+
+        Args:
+            reason: Human-readable reason for intervention
+            clear_history: Deprecated, always False. History is preserved.
+        """
+        clear_history = False  # History clearing disabled - causes amnesia loops
+        self.logger.warning(f"🔄 LOOP DETECTED: {reason}")
+
+        # Check if this looks like a validation/parameter error loop
+        is_validation_error = any(x in reason.lower() for x in [
+            'validation', 'parameter', 'missing required', 'invalid argument',
+            'schema', 'type error', 'arguments'
+        ])
+
+        # Also check if recent results have validation errors
+        if hasattr(self, '_last_result') and self._last_result:
+            for result in self._last_result[-3:]:
+                if hasattr(result, 'error') and result.error:
+                    error_lower = str(result.error).lower()
+                    if any(x in error_lower for x in ['missing required parameter', 'validation failed', 'invalid']):
+                        is_validation_error = True
+                        break
+
+        # History clearing disabled - preserves context
+        # if clear_history and hasattr(self, 'message_manager'):
+        #     self.message_manager.clear_history_keep_system(keep_last_n=2)
+
+        # Build intervention message based on error type.
+        # Chat-schema: tag as INTERVENTION control content (origin + <system-directive>
+        # envelope) so it is not indistinguishable from a genuine user turn.
+        if is_validation_error:
+            intervention_msg = make_control_message(f"""🚨 TOOL CALL ERROR LOOP DETECTED: {reason}
+
+⚠️ Your tool calls are failing repeatedly with the SAME validation error.
+The error message above tells you exactly what's wrong - READ IT CAREFULLY.
+
+🔍 DIAGNOSIS FOR MCP TOOLS:
+If calling mcp_execute_tool, the 'arguments' field must be a proper JSON object with the required parameters.
+For example, a search tool requires: {{"count": 100, "query": "your search query"}}
+
+🛑 TO FIX THIS:
+1. READ the error message - it tells you which parameter is missing
+2. INCLUDE all required parameters in your tool call
+3. For mcp_execute_tool, ensure 'arguments' contains the nested tool's parameters as a JSON object
+
+Example correct mcp_execute_tool call:
+{{
+  "server_name": "example_server",
+  "tool_name": "search",
+  "arguments": {{"count": 100, "query": "crypto tweets"}}
+}}
+
+DO NOT just repeat the same broken call. FIX the parameters first.""", MessageOrigin.INTERVENTION)
+        else:
+            intervention_msg = make_control_message(f"""🚨 CRITICAL LOOP DETECTED: {reason}
+
+⚠️ You have been repeating the same actions without making progress. This is wasting resources.
+
+🛑 YOU MUST DO SOMETHING DIFFERENT NOW:
+1. DO NOT read the same files again - you already have their content
+2. DO NOT repeat the same action sequence
+3. If you need to CREATE something, use filesystem_write_file NOW
+4. If you're truly stuck, call the 'done' action with your current progress
+
+📋 Your available actions include:
+- filesystem_write_file: CREATE new files (HTML, text, etc.)
+- done: Mark task complete with summary
+
+TAKE A DIFFERENT ACTION IMMEDIATELY. Reading the same files again will result in task termination.""", MessageOrigin.INTERVENTION)
+
+        self.message_manager.add_message(intervention_msg)
+
+        # Add error to force reconsideration
+        if not hasattr(self, '_last_result') or not self._last_result:
+            self._last_result = []
+
+        error_msg = f"LOOP DETECTED: {reason}."
+        if clear_history:
+            error_msg += " Context cleared."
+        error_msg += " You MUST fix the issue - DO NOT repeat the same broken call."
+
+        self._last_result.append(ActionResult(
+            error=error_msg,
+            include_in_memory=True
+        ))
+
+        # Reset counter and clear action history after intervention
+        self._action_repetition_counter = 0
+        self._previous_actions.clear()
+
+        # FIX #4: Signal to AgentState for tracking
+        if hasattr(self, 'state'):
+            self.state.loop_warning_count += 1
+            self.state.reset_loop_detection()
+
+        # CRITICAL: History is NEVER cleared - agent retains full context
+        self.logger.info(f"✅ Loop intervention complete. Full context preserved, guidance injected.")
+
+    def detect_action_loop(
+        self,
+        current_brain: Any,
+        current_actions: List[Dict],
+        lookback_steps: int = 5
+    ) -> tuple[bool, Optional[str]]:
+        """Detect if agent is repeating the same action pattern.
+
+        PHASE 2 FIX (Nov 4, 2025): Multi-signal loop detection prevents infinite loops
+        where agent repeats same actions without progress.
+
+        Detection Signals:
+        - Action repetition (same tool called N+ times in recent steps)
+        - Memory similarity (semantic overlap >70% in brain state)
+        - Goal stagnation (same next_goal for N+ consecutive steps)
+
+        Args:
+            current_brain: Current step's brain state
+            current_actions: Actions agent wants to take
+            lookback_steps: How many recent steps to check (default: 5)
+
+        Returns:
+            (is_loop, warning_message) tuple
+        """
+        if not self.task_context_manager or not self.session_id:
+            return False, None
+
+        # Get session data using correct API
+        session_data = self.task_context_manager.get_session(self.session_id)
+        if not session_data or not session_data.memory:
+            return False, None
+
+        memory = session_data.memory
+        recent_steps = memory.recent_steps[-lookback_steps:] if hasattr(memory, 'recent_steps') else []
+
+        if len(recent_steps) < 3:
+            return False, None  # Need at least 3 steps to detect pattern
+
+        # SIGNAL 1: Action Repetition
+        current_action_names = set()
+        for action_dict in current_actions:
+            if isinstance(action_dict, dict):
+                current_action_names.update(action_dict.keys())
+
+        if not current_action_names:
+            return False, None
+
+        repeated_action_count = 0
+        repeated_step_nums = []
+        for step in recent_steps:
+            step_summary_lower = step.action_summary.lower()
+            if any(action.lower() in step_summary_lower for action in current_action_names):
+                repeated_action_count += 1
+                repeated_step_nums.append(step.step_number)
+
+        action_repeat_ratio = repeated_action_count / len(recent_steps)
+
+        # SIGNAL 2: Memory Similarity
+        similar_memory_count = 0
+        similar_memories = []
+
+        if hasattr(current_brain, 'memory') and current_brain.memory:
+            import re
+            current_keywords = set(re.findall(r'\b\w{4,}\b', current_brain.memory.lower()))
+
+            for step in recent_steps:
+                if step.finding:
+                    step_keywords = set(re.findall(r'\b\w{4,}\b', step.finding.lower()))
+                    if current_keywords and step_keywords:
+                        overlap = len(current_keywords & step_keywords)
+                        total = len(current_keywords | step_keywords)
+                        if total > 0:
+                            similarity = overlap / total
+                            if similarity > 0.70:  # 70% keyword overlap
+                                similar_memory_count += 1
+                                similar_memories.append((step.step_number, similarity, step.finding[:60]))
+
+        memory_similarity_ratio = similar_memory_count / len(recent_steps) if recent_steps else 0
+
+        # SIGNAL 3: Goal Stagnation (if available)
+        goal_stagnation = False
+        if hasattr(current_brain, 'next_goal') and current_brain.next_goal:
+            stagnant_goals = 0
+            for step in recent_steps:
+                if hasattr(step, 'brain_state') and step.brain_state:
+                    if hasattr(step.brain_state, 'next_goal'):
+                        if step.brain_state.next_goal == current_brain.next_goal:
+                            stagnant_goals += 1
+            if stagnant_goals >= len(recent_steps) * 0.6:
+                goal_stagnation = True
+
+        # DETECTION LOGIC: Multiple signals = higher confidence
+        is_loop = False
+        warning_message = None
+
+        if action_repeat_ratio >= 0.60:  # Action repeated in 60%+ of steps
+            severity = "🔄 LOOP DETECTED"
+            if memory_similarity_ratio >= 0.60:  # AND memory is similar
+                severity = "🚨 SEVERE LOOP"
+                is_loop = True
+            elif goal_stagnation:  # AND goal hasn't changed
+                severity = "⚠️  POSSIBLE LOOP"
+                is_loop = True
+            else:
+                severity = "⚠️  ACTION REPETITION"
+                is_loop = True
+
+            warning_message = (
+                f"{severity} at step {self.state.n_steps}:\n\n"
+                f"📊 Detection Signals:\n"
+                f"  • Action repetition: {action_repeat_ratio:.0%} ({repeated_action_count}/{len(recent_steps)} steps)\n"
+                f"  • Memory similarity: {memory_similarity_ratio:.0%} ({similar_memory_count}/{len(recent_steps)} steps)\n"
+                f"  • Goal stagnation: {'YES' if goal_stagnation else 'NO'}\n\n"
+                f"🔍 Pattern Analysis:\n"
+                f"  • Repeated action: {', '.join(current_action_names)}\n"
+                f"  • Steps with this action: {repeated_step_nums}\n"
+                f"  • Current memory: {current_brain.memory[:100] if hasattr(current_brain, 'memory') else 'N/A'}...\n\n"
+                f"💡 Recommended Actions:\n"
+                f"  1. Review recent steps to avoid repeating work\n"
+                f"  2. Check if data/result already available from previous steps\n"
+                f"  3. Try a DIFFERENT approach or tool\n"
+                f"  4. Verify your goal hasn't already been achieved\n"
+            )
+
+            self.logger.warning(warning_message)
+
+        return is_loop, warning_message