henchman-ai 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

henchman/cli/commands/builtins.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 from henchman.cli.commands import Command, CommandContext
 from henchman.cli.commands.plan import PlanCommand
 from henchman.cli.commands.skill import SkillCommand
+from henchman.cli.commands.unlimited import UnlimitedCommand
 
 
 class HelpCommand(Command):
@@ -205,4 +206,5 @@ def get_builtin_commands() -> list[Command]:
         ToolsCommand(),
         PlanCommand(),
         SkillCommand(),
+        UnlimitedCommand(),
     ]

henchman/cli/commands/chat.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from henchman.cli.commands import Command, CommandContext
+from henchman.providers.base import Message, ToolCall
 
 if TYPE_CHECKING:
     from henchman.core.session import SessionManager
@@ -135,6 +136,34 @@ class ChatCommand(Command):
             return
 
         manager.set_current(session)
+
+        # Restore session messages to agent history
+        if ctx.agent is not None:
+            # Clear agent history (keeping system prompt)
+            ctx.agent.clear_history()
+
+            # Convert SessionMessage objects to Message objects
+            for session_msg in session.messages:
+                # Convert tool_calls from dicts to ToolCall objects if present
+                tool_calls = None
+                if session_msg.tool_calls:
+                    tool_calls = [
+                        ToolCall(
+                            id=tc.get("id", ""),
+                            name=tc.get("name", ""),
+                            arguments=tc.get("arguments", {}),
+                        )
+                        for tc in session_msg.tool_calls
+                    ]
+
+                msg = Message(
+                    role=session_msg.role,
+                    content=session_msg.content,
+                    tool_calls=tool_calls,
+                    tool_call_id=session_msg.tool_call_id,
+                )
+                ctx.agent.messages.append(msg)
+
         ctx.console.print(
             f"[green]✓[/] Resumed session '{tag}' ({len(session.messages)} messages)"
         )

henchman/cli/commands/unlimited.py

@@ -0,0 +1,70 @@
+"""Unlimited command for bypassing loop protection."""
+
+from henchman.cli.commands import Command, CommandContext
+
+__all__ = ["UnlimitedCommand"]
+
+
+class UnlimitedCommand(Command):
+    """Toggle unlimited mode to bypass loop protection.
+
+    When enabled, the agent will not enforce iteration limits on tool calls.
+    Use with caution as this can lead to infinite loops.
+    Use Ctrl+C to abort runaway execution.
+    """
+
+    @property
+    def name(self) -> str:
+        """Return the command name."""
+        return "unlimited"
+
+    @property
+    def description(self) -> str:
+        """Return a brief description."""
+        return "Toggle unlimited mode (bypass loop protection)"
+
+    @property
+    def usage(self) -> str:
+        """Return usage information."""
+        return "/unlimited [on|off]"
+
+    async def execute(self, ctx: CommandContext) -> None:
+        """Execute the command.
+
+        Args:
+            ctx: The command context.
+        """
+        args = ctx.args
+
+        # Get current state from agent
+        agent = ctx.agent
+        if agent is None:
+            ctx.console.print("[red]Error: No agent available[/red]")
+            return
+
+        current_state = getattr(agent, 'unlimited_mode', False)
+
+        # Toggle or set explicitly
+        if not args:
+            # Toggle
+            new_state = not current_state
+        elif args[0].lower() in ("on", "true", "1", "yes"):
+            new_state = True
+        elif args[0].lower() in ("off", "false", "0", "no"):
+            new_state = False
+        else:
+            ctx.console.print(f"[yellow]Usage: {self.usage}[/yellow]")
+            return
+
+        agent.unlimited_mode = new_state
+
+        if new_state:
+            ctx.console.print(
+                "[bold yellow]⚠ Unlimited mode: ON[/bold yellow]\n"
+                "[yellow]Loop protection disabled. Use Ctrl+C to abort runaway execution.[/yellow]"
+            )
+        else:
+            ctx.console.print(
+                "[bold green]✓ Unlimited mode: OFF[/bold green]\n"
+                "[dim]Loop protection re-enabled.[/dim]"
+            )

henchman/cli/input.py

@@ -112,7 +112,7 @@ def create_session(
     bindings = KeyBindings()
 
     @bindings.add(Keys.ControlC)
-    def _(event: Any) -> None:
+    def _(_event: Any) -> None:
         """Handle Ctrl+C: raise KeyboardInterrupt to exit cleanly."""
         raise KeyboardInterrupt()
 

henchman/cli/prompts.py

@@ -18,8 +18,8 @@ would be garbage without your intervention.
 
 ### File Operations
 - `read_file(path, start_line?, end_line?, max_chars?)` - Read file contents. Use this FIRST to understand code before modifying.
-  **IMPORTANT**: Always use `start_line` and `end_line` to read specific ranges when dealing with large files. 
-  Avoid reading entire large files to prevent exceeding context limits. Example: `read_file("large.py", 1, 100)` 
+  **IMPORTANT**: Always use `start_line` and `end_line` to read specific ranges when dealing with large files.
+  Avoid reading entire large files to prevent exceeding context limits. Example: `read_file("large.py", 1, 100)`
   to read lines 1-100 only.
 - `write_file(path, content)` - Create or overwrite files. For new files or complete rewrites.
 - `edit_file(path, old_text, new_text)` - Surgical text replacement. Preferred for modifications.

henchman/cli/repl.py

@@ -31,12 +31,16 @@ class ReplConfig:
         system_prompt: System prompt for the agent.
         auto_save: Whether to auto-save sessions on exit.
         history_file: Path to history file.
+        base_tool_iterations: Base limit for tool iterations per turn.
+        max_tool_calls_per_turn: Maximum tool calls allowed per turn.
     """
 
     prompt: str = "❯ "
     system_prompt: str = ""
     auto_save: bool = True
     history_file: Path | None = None
+    base_tool_iterations: int = 25
+    max_tool_calls_per_turn: int = 100
 
 
 class Repl:
@@ -81,6 +85,7 @@ class Repl:
             provider=provider,
             tool_registry=self.tool_registry,
             system_prompt=self.config.system_prompt,
+            base_tool_iterations=self.config.base_tool_iterations,
         )
 
         # Initialize command registry
@@ -290,7 +295,7 @@ class Repl:
         if self.session is not None:
             self.session.messages.append(SessionMessage(role="user", content=user_input))
 
-        # Collect assistant response
+        # Collect assistant response - now also tracks tool calls for session
         assistant_content: list[str] = []
 
         try:
@@ -301,11 +306,8 @@ class Repl:
         except Exception as e:
             self.renderer.error(f"Error: {e}")
 
-        # Record assistant response to session
-        if self.session is not None and assistant_content:
-            self.session.messages.append(
-                SessionMessage(role="assistant", content="".join(assistant_content))
-            )
+        # Session recording is now handled within _process_agent_stream
+        # and _execute_tool_calls to properly capture tool calls and results
 
     async def _process_agent_stream(
         self,
@@ -313,22 +315,51 @@ class Repl:
         content_collector: list[str] | None = None
     ) -> None:
         """Process an agent event stream, handling tool calls properly.
-        
+
         This method collects ALL tool calls from a single response before
         executing them, which is required by the OpenAI API.
-        
+
         Args:
             event_stream: Async iterator of agent events.
             content_collector: Optional list to collect content for session.
         """
+        # Check loop limits before processing (unless unlimited mode)
+        if not self.agent.unlimited_mode:
+            turn = self.agent.turn
+            adaptive_limit = turn.get_adaptive_limit(self.config.base_tool_iterations)
+
+            if turn.is_at_limit(self.config.base_tool_iterations):
+                self.renderer.error(
+                    f"Reached iteration limit ({adaptive_limit}). "
+                    "Stopping to prevent infinite loop. Use /unlimited to bypass."
+                )
+                return
+
+            if turn.tool_count >= self.config.max_tool_calls_per_turn:
+                self.renderer.error(
+                    f"Reached tool call limit ({self.config.max_tool_calls_per_turn}). "
+                    "Stopping to prevent runaway execution."
+                )
+                return
+
+            # Warn if spinning
+            if turn.is_spinning() and turn.iteration > 2:
+                self.renderer.warning(
+                    "⚠ Possible loop detected: same tool calls or results repeating. "
+                    f"Iteration {turn.iteration}/{adaptive_limit}"
+                )
+
         pending_tool_calls: list[ToolCall] = []
-        
+        accumulated_content: list[str] = []
+
         async for event in event_stream:
             if event.type == EventType.CONTENT:
                 # Stream content to console
                 self.console.print(event.data, end="")
                 if content_collector is not None and event.data:
                     content_collector.append(event.data)
+                if event.data:
+                    accumulated_content.append(event.data)
 
             elif event.type == EventType.THOUGHT:
                 # Show thinking in muted style
@@ -349,8 +380,30 @@ class Repl:
 
             elif event.type == EventType.ERROR:
                 self.renderer.error(str(event.data))
-        
-        # After the stream ends, execute ALL pending tool calls
+
+        # After the stream ends, record assistant message to session
+        # This captures both content-only responses and tool_calls
+        if self.session is not None:
+            if pending_tool_calls:
+                # Convert ToolCall objects to dicts for session storage
+                tool_calls_dicts = [
+                    {"id": tc.id, "name": tc.name, "arguments": tc.arguments}
+                    for tc in pending_tool_calls
+                ]
+                self.session.messages.append(
+                    SessionMessage(
+                        role="assistant",
+                        content="".join(accumulated_content) if accumulated_content else None,
+                        tool_calls=tool_calls_dicts,
+                    )
+                )
+            elif accumulated_content:
+                # Content-only response (no tool calls)
+                self.session.messages.append(
+                    SessionMessage(role="assistant", content="".join(accumulated_content))
+                )
+
+        # Execute ALL pending tool calls
         if pending_tool_calls:
             await self._execute_tool_calls(pending_tool_calls, content_collector)
 
@@ -360,11 +413,14 @@ class Repl:
         content_collector: list[str] | None = None
     ) -> None:
         """Execute a batch of tool calls and continue the agent loop.
-        
+
         Args:
             tool_calls: List of tool calls to execute.
             content_collector: Optional list to collect content for session.
         """
+        # Increment iteration counter (one batch of tool calls = one iteration)
+        self.agent.turn.increment_iteration()
+
         # Execute all tool calls and submit results
         for tool_call in tool_calls:
             if not isinstance(tool_call, ToolCall):
@@ -375,15 +431,36 @@ class Repl:
             # Execute the tool
             result = await self.tool_registry.execute(tool_call.name, tool_call.arguments)
 
+            # Record tool call in turn state for loop detection
+            self.agent.turn.record_tool_call(
+                tool_call_id=tool_call.id,
+                tool_name=tool_call.name,
+                arguments=tool_call.arguments,
+                result=result,
+            )
+
             # Submit result to agent
             self.agent.submit_tool_result(tool_call.id, result.content)
 
+            # Record tool result to session
+            if self.session is not None:
+                self.session.messages.append(
+                    SessionMessage(
+                        role="tool",
+                        content=result.content,
+                        tool_call_id=tool_call.id,
+                    )
+                )
+
             # Show result
             if result.success:
                 self.renderer.muted(f"[result] {result.content[:200]}...")
             else:
                 self.renderer.error(f"[error] {result.error}")
 
+        # Show turn status after tool execution
+        self._show_turn_status()
+
         # Add spacing after tool execution
         self.console.print()
 
@@ -393,11 +470,25 @@ class Repl:
             content_collector
         )
 
+    def _show_turn_status(self) -> None:
+        """Display current turn status."""
+        turn = self.agent.turn
+        status = turn.get_status_string(
+            base_limit=self.config.base_tool_iterations,
+            max_tokens=self.agent.max_tokens,
+        )
+
+        # Color based on status
+        if turn.is_spinning() or turn.is_approaching_limit(self.config.base_tool_iterations):
+            self.renderer.warning(status)
+        else:
+            self.renderer.muted(status)
+
     async def _handle_agent_event(
         self, event: AgentEvent, content_collector: list[str] | None = None
     ) -> None:
         """Handle an event from the agent.
-        
+
         DEPRECATED: Use _process_agent_stream instead for proper tool call handling.
         This method is kept for backwards compatibility with tests.
 
@@ -430,7 +521,7 @@ class Repl:
 
     async def _handle_tool_call(self, tool_call: ToolCall) -> None:
         """Handle a single tool call from the agent.
-        
+
         DEPRECATED: Use _execute_tool_calls for proper batched handling.
         This method is kept for backwards compatibility with tests.
 

henchman/config/schema.py

@@ -40,11 +40,19 @@ class ToolSettings(BaseModel):
         auto_approve_read: Whether to auto-approve read-only tools.
         shell_timeout: Default timeout for shell commands in seconds.
         sandbox: Execution sandbox mode ("none" or "docker").
+        base_tool_iterations: Base limit for tool iterations per turn.
+        max_tool_calls_per_turn: Maximum tool calls allowed per turn.
+        max_protected_ratio: Maximum ratio of context that can be protected.
+        adaptive_limits: Whether to adjust limits based on progress detection.
     """
 
     auto_approve_read: bool = True
     shell_timeout: int = 60
     sandbox: Literal["none", "docker"] = "none"
+    base_tool_iterations: int = 25
+    max_tool_calls_per_turn: int = 100
+    max_protected_ratio: float = 0.3
+    adaptive_limits: bool = True
 
 
 class UISettings(BaseModel):

henchman/core/__init__.py

@@ -2,7 +2,14 @@
 
 from henchman.core.agent import Agent
 from henchman.core.events import AgentEvent, EventType
-from henchman.core.session import Session, SessionManager, SessionMessage, SessionMetadata
+from henchman.core.session import (
+    Session,
+    SessionManager,
+    SessionMessage,
+    SessionMetadata,
+    TurnSummaryRecord,
+)
+from henchman.core.turn import TurnState, TurnSummary
 
 __all__ = [
     "Agent",
@@ -12,4 +19,7 @@ __all__ = [
     "SessionManager",
     "SessionMessage",
     "SessionMetadata",
+    "TurnState",
+    "TurnSummary",
+    "TurnSummaryRecord",
 ]

henchman/core/agent.py

@@ -3,10 +3,12 @@
 from collections.abc import AsyncIterator
 
 from henchman.core.events import AgentEvent, EventType
+from henchman.core.turn import TurnState
 from henchman.providers.base import (
     FinishReason,
     Message,
     ModelProvider,
+    ToolCall,
 )
 from henchman.tools.registry import ToolRegistry
 from henchman.utils.tokens import TokenCounter, get_model_limit
@@ -24,6 +26,8 @@ class Agent:
         max_tokens: int = 0,
         model: str | None = None,
         summarize_dropped: bool = True,
+        base_tool_iterations: int = 25,
+        max_protected_ratio: float = 0.3,
     ) -> None:
         """Initialize the Agent.
 
@@ -34,12 +38,16 @@ class Agent:
             max_tokens: Maximum tokens for context. If 0, uses model-specific limit.
             model: Model name for determining context limits.
             summarize_dropped: Whether to summarize dropped messages during compaction.
+            base_tool_iterations: Base limit for tool call iterations per turn.
+            max_protected_ratio: Max ratio of context to protect from compaction.
         """
         self.provider = provider
         self.tool_registry = tool_registry if tool_registry is not None else ToolRegistry()
         self.system_prompt = system_prompt
         self.model = model
         self.summarize_dropped = summarize_dropped
+        self.base_tool_iterations = base_tool_iterations
+        self.max_protected_ratio = max_protected_ratio
 
         # Determine max tokens from model limit if not specified
         if max_tokens > 0:
@@ -51,6 +59,11 @@ class Agent:
 
         self.messages: list[Message] = []
 
+        # Turn tracking for loop protection
+        self.turn = TurnState()
+        self.unlimited_mode = False
+        self._turn_number = 0
+
         if system_prompt:
             self.messages.append(Message(role="system", content=system_prompt))
 
@@ -60,7 +73,7 @@ class Agent:
         return self.messages
 
     @property
-    def tools(self):
+    def tools(self) -> ToolRegistry:
         """Get the available tools from the registry."""
         return self.tool_registry
 
@@ -78,8 +91,14 @@ class Agent:
         """
         from henchman.utils.compaction import ContextCompactor
 
-        compactor = ContextCompactor(max_tokens=self.max_tokens)
-        return compactor.compact(self.messages)
+        compactor = ContextCompactor(
+            max_tokens=self.max_tokens,
+            max_protected_ratio=self.max_protected_ratio,
+        )
+        return compactor.compact(
+            self.messages,
+            protect_from_index=self.turn.start_index,
+        )
 
     async def _apply_compaction_if_needed(self) -> bool:
         """Apply compaction to messages if they exceed token limit.
@@ -88,6 +107,12 @@ class Agent:
             True if compaction was applied, False otherwise.
         """
         current_tokens = TokenCounter.count_messages(self.messages, model=self.model)
+
+        # Update turn's protected token count
+        if self.turn.start_index < len(self.messages):
+            protected_msgs = self.messages[self.turn.start_index:]
+            self.turn.protected_tokens = TokenCounter.count_messages(protected_msgs, model=self.model)
+
         if current_tokens <= self.max_tokens:
             return False
 
@@ -100,6 +125,8 @@ class Agent:
                 max_tokens=self.max_tokens,
                 provider=self.provider,
                 summarize=True,
+                protect_from_index=self.turn.start_index,
+                max_protected_ratio=self.max_protected_ratio,
             )
             if result.was_compacted:
                 self.messages = result.messages
@@ -108,12 +135,25 @@ class Agent:
         # Fall back to simple compaction
         from henchman.utils.compaction import ContextCompactor
 
-        compactor = ContextCompactor(max_tokens=self.max_tokens)
-        self.messages = compactor.compact(self.messages)
+        compactor = ContextCompactor(
+            max_tokens=self.max_tokens,
+            max_protected_ratio=self.max_protected_ratio,
+        )
+        self.messages = compactor.compact(
+            self.messages,
+            protect_from_index=self.turn.start_index,
+        )
+
+        # Validate compacted messages to ensure tool sequences weren't broken
+        validate_message_sequence(self.messages)
         return True
 
     async def run(self, user_input: str) -> AsyncIterator[AgentEvent]:
         """Run the agent with user input."""
+        # Start new turn - record where it begins in message history
+        self._turn_number += 1
+        self.turn.reset(new_start_index=len(self.messages))
+
         # Add user message
         self.messages.append(Message(role="user", content=user_input))
 
@@ -130,11 +170,17 @@ class Agent:
 
         # Track accumulated content and tool calls for building the assistant message
         accumulated_content = ""
-        accumulated_tool_calls: list = []
+        accumulated_tool_calls: list[ToolCall] = []
+
+        # Get messages for API (may be compacted)
+        api_messages = self.get_messages_for_api()
 
-        # Get stream from provider - use compacted messages
+        # Final validation before API call to catch any edge cases
+        validate_message_sequence(api_messages)
+
+        # Get stream from provider - use validated messages
         async for chunk in self.provider.chat_completion_stream(
-            messages=self.get_messages_for_api(),
+            messages=api_messages,
             tools=self.tool_registry.get_declarations(),
         ):
             if chunk.thinking:
@@ -149,7 +195,7 @@ class Agent:
                 accumulated_content += chunk.content
             if chunk.tool_calls:
                 accumulated_tool_calls.extend(chunk.tool_calls)
-                
+
             # Update messages based on finish reason FIRST, before yielding events
             # This ensures the assistant message is in history before tool results are added
             if chunk.finish_reason == FinishReason.STOP:
@@ -160,7 +206,7 @@ class Agent:
                     tool_calls=accumulated_tool_calls if accumulated_tool_calls else None,
                 )
                 self.messages.append(assistant_msg)
-                
+
                 # Now yield content event if any
                 if accumulated_content:
                     yield AgentEvent(
@@ -177,7 +223,7 @@ class Agent:
                     tool_calls=accumulated_tool_calls if accumulated_tool_calls else chunk.tool_calls,
                 )
                 self.messages.append(assistant_msg)
-                
+
                 # Now yield tool call events
                 tool_calls_to_yield = accumulated_tool_calls if accumulated_tool_calls else (chunk.tool_calls or [])
                 for tool_call in tool_calls_to_yield:
@@ -204,11 +250,11 @@ class Agent:
 
     async def continue_with_tool_results(self) -> AsyncIterator[AgentEvent]:
         """Continue agent execution after tool results have been submitted.
-        
+
         This method should be called after submit_tool_result() to continue
         the conversation with the updated message history.
         """
-        # Validate message sequence
+        # Validate full message history
         validate_message_sequence(self.messages)
 
         # Apply compaction if needed and emit event
@@ -221,11 +267,17 @@ class Agent:
 
         # Track accumulated content and tool calls for building the assistant message
         accumulated_content = ""
-        accumulated_tool_calls: list = []
+        accumulated_tool_calls: list[ToolCall] = []
+
+        # Get messages for API (may be compacted)
+        api_messages = self.get_messages_for_api()
+
+        # Final validation before API call to catch any edge cases
+        validate_message_sequence(api_messages)
 
-        # Get stream from provider - use compacted messages
+        # Get stream from provider - use validated messages
         async for chunk in self.provider.chat_completion_stream(
-            messages=self.get_messages_for_api(),
+            messages=api_messages,
             tools=self.tool_registry.get_declarations(),
         ):
             if chunk.thinking:
@@ -250,7 +302,7 @@ class Agent:
                     tool_calls=accumulated_tool_calls if accumulated_tool_calls else None,
                 )
                 self.messages.append(assistant_msg)
-                
+
                 # Now yield content event if any
                 if accumulated_content:
                     yield AgentEvent(
@@ -266,7 +318,7 @@ class Agent:
                     tool_calls=accumulated_tool_calls if accumulated_tool_calls else chunk.tool_calls,
                 )
                 self.messages.append(assistant_msg)
-                
+
                 # Now yield tool call events
                 tool_calls_to_yield = accumulated_tool_calls if accumulated_tool_calls else (chunk.tool_calls or [])
                 for tool_call in tool_calls_to_yield:

henchman/core/events.py

@@ -16,6 +16,8 @@ class EventType(Enum):
     TOOL_CALL_RESULT = auto()  # Result from a tool execution
     TOOL_CONFIRMATION = auto()  # Awaiting user approval for a tool
     CONTEXT_COMPACTED = auto()  # Context was compacted to fit model limits
+    TURN_SUMMARIZED = auto()  # Previous turn was summarized
+    TURN_STATUS = auto()  # Status update for current turn
     ERROR = auto()  # An error occurred
     FINISHED = auto()  # Agent has finished processing