henchman-ai 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

henchman/cli/app.py

@@ -43,13 +43,17 @@ def _get_provider() -> ModelProvider:
         registry = get_default_registry()
 
         provider_name = settings.providers.default or "deepseek"
-        provider_settings = getattr(settings.providers, provider_name, None)
+        provider_settings = getattr(settings.providers, provider_name, {})
 
-        if provider_settings:
+        if isinstance(provider_settings, dict):
+            # Ensure api_key is handled correctly (backward compatibility or env var)
+            kwargs = provider_settings.copy()
+            if not kwargs.get("api_key"):
+                kwargs["api_key"] = os.environ.get("ANTHROPIC_API_KEY") if provider_name == "anthropic" else os.environ.get("HENCHMAN_API_KEY")
+            
             return registry.create(
                 provider_name,
-                api_key=getattr(provider_settings, "api_key", None) or "",
-                model=getattr(provider_settings, "model", None),
+                **kwargs
             )
     except Exception:  # pragma: no cover
         pass

henchman/cli/commands/builtins.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 from henchman.cli.commands import Command, CommandContext
 from henchman.cli.commands.chat import ChatCommand
 from henchman.cli.commands.mcp import McpCommand
+from henchman.cli.commands.model import ModelCommand
 from henchman.cli.commands.plan import PlanCommand
 from henchman.cli.commands.rag import RagCommand
 from henchman.cli.commands.skill import SkillCommand
@@ -57,10 +58,10 @@ class HelpCommand(Command):
         ctx.console.print("  /skill    - Manage and execute learned skills")
         ctx.console.print("  /chat     - Manage chat sessions (save, list, resume)")
         ctx.console.print("  /mcp      - Manage MCP server connections")
+        ctx.console.print("  /model    - Show or change model/provider")
         ctx.console.print("  /quit     - Exit the CLI")
         ctx.console.print("  /clear    - Clear the screen")
         ctx.console.print("  /tools    - List available tools")
-        ctx.console.print("  /model    - Show or change the model")
         ctx.console.print("")
 
 
@@ -212,6 +213,7 @@ def get_builtin_commands() -> list[Command]:
         ToolsCommand(),
         ChatCommand(),
         McpCommand(),
+        ModelCommand(),
         PlanCommand(),
         RagCommand(),
         SkillCommand(),

henchman/cli/commands/model.py

@@ -0,0 +1,285 @@
+"""Model and provider management commands."""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING
+
+from henchman.cli.commands import Command, CommandContext
+from henchman.config import load_settings
+from henchman.providers import get_default_registry
+
+if TYPE_CHECKING:
+    from henchman.providers.base import ModelProvider
+
+
+class ModelCommand(Command):
+    """Show or change the model and provider."""
+
+    @property
+    def name(self) -> str:
+        """Command name.
+
+        Returns:
+            Command name string.
+        """
+        return "model"
+
+    @property
+    def description(self) -> str:
+        """Command description.
+
+        Returns:
+            Description string.
+        """
+        return "Show or change the model and provider"
+
+    @property
+    def usage(self) -> str:
+        """Command usage.
+
+        Returns:
+            Usage string.
+        """
+        return "/model [list|set <provider> [<model>]]"
+
+    async def execute(self, ctx: CommandContext) -> None:
+        """Execute the model command.
+
+        Args:
+            ctx: Command context.
+        """
+        args = ctx.args
+        if not args:
+            await self._show_current(ctx)
+        elif args[0] == "list":
+            await self._list_providers(ctx)
+        elif args[0] == "set" and len(args) >= 2:
+            await self._set_provider(ctx, args[1], args[2] if len(args) > 2 else None)
+        else:
+            ctx.console.print(f"[yellow]Usage: {self.usage}[/]")
+
+    async def _show_current(self, ctx: CommandContext) -> None:
+        """Show current provider and model.
+
+        Args:
+            ctx: Command context.
+        """
+        if not ctx.agent:
+            ctx.console.print("[yellow]No active agent. Cannot show current model.[/]")
+            return
+
+        provider = ctx.agent.provider
+        settings = load_settings()
+        registry = get_default_registry()
+
+        ctx.console.print("\n[bold blue]Current Configuration[/]\n")
+        ctx.console.print(f"  Provider: [cyan]{provider.name}[/]")
+        
+        # Show model if available
+        if hasattr(provider, "default_model"):
+            ctx.console.print(f"  Model: [cyan]{provider.default_model}[/]")
+        
+        # Show available providers
+        available = registry.list_providers()
+        ctx.console.print(f"\n  Available providers: [dim]{', '.join(available)}[/]")
+        ctx.console.print(f"\n  Use [cyan]/model list[/] to see all providers")
+        ctx.console.print(f"  Use [cyan]/model set <provider> [model][/] to switch")
+        ctx.console.print("")
+
+    async def _list_providers(self, ctx: CommandContext) -> None:
+        """List all available providers and models.
+
+        Args:
+            ctx: Command context.
+        """
+        registry = get_default_registry()
+        providers = registry.list_providers()
+        
+        ctx.console.print("\n[bold blue]Available Providers[/]\n")
+        
+        for provider_name in sorted(providers):
+            try:
+                provider_class = registry.get(provider_name)
+                
+                # Get example configuration
+                example_config = self._get_example_config(provider_name)
+                
+                ctx.console.print(f"  [cyan]{provider_name}[/]")
+                if hasattr(provider_class, "__doc__") and provider_class.__doc__:
+                    doc_lines = provider_class.__doc__.strip().split('\n')
+                    first_line = doc_lines[0].strip()
+                    ctx.console.print(f"    [dim]{first_line}[/]")
+                
+                if example_config:
+                    ctx.console.print(f"    [yellow]Config:[/] {example_config}")
+                
+                # Show environment variables needed
+                env_vars = self._get_env_vars(provider_name)
+                if env_vars:
+                    ctx.console.print(f"    [yellow]Env vars:[/] {env_vars}")
+                
+                ctx.console.print("")
+            except Exception as e:
+                ctx.console.print(f"  [red]{provider_name}[/] - Error: {e}")
+
+    async def _set_provider(
+        self, 
+        ctx: CommandContext, 
+        provider_name: str,
+        model_name: str | None = None
+    ) -> None:
+        """Switch to a different provider.
+
+        Args:
+            ctx: Command context.
+            provider_name: Name of the provider to switch to.
+            model_name: Optional model name to use.
+
+        Raises:
+            ValueError: If provider cannot be created.
+        """
+        if not ctx.repl:
+            ctx.console.print("[yellow]Cannot switch providers without REPL context.[/]")
+            return
+
+        try:
+            # Get registry and create new provider
+            registry = get_default_registry()
+            
+            if provider_name not in registry.list_providers():
+                ctx.console.print(f"[red]Provider '{provider_name}' not found.[/]")
+                ctx.console.print(f"Available providers: {', '.join(registry.list_providers())}")
+                return
+
+            # Try to get API key from environment or settings
+            api_key = self._get_api_key_for_provider(provider_name)
+            
+            # Create provider instance
+            provider_kwargs = {"api_key": api_key or ""}
+            if model_name:
+                provider_kwargs["model"] = model_name
+            
+            new_provider = registry.create(provider_name, **provider_kwargs)
+            
+            # Test the provider with a simple call
+            ctx.console.print(f"[dim]Testing {provider_name} connection...[/]")
+            try:
+                # Simple test to verify provider works
+                if hasattr(new_provider, "default_model"):
+                    ctx.console.print(f"[green]✓ Connected to {provider_name}[/]")
+                    if model_name:
+                        ctx.console.print(f"[green]✓ Using model: {model_name}[/]")
+                    else:
+                        ctx.console.print(f"[green]✓ Using default model: {new_provider.default_model}[/]")
+                else:
+                    ctx.console.print(f"[green]✓ Connected to {provider_name}[/]")
+            except Exception as e:
+                ctx.console.print(f"[yellow]⚠ Connection test failed: {e}[/]")
+                ctx.console.print("[yellow]Provider created but may not work correctly.[/]")
+            
+            # Update the agent with new provider
+            old_provider = ctx.agent.provider
+            ctx.agent.provider = new_provider
+            
+            # Update REPL's provider reference
+            ctx.repl.provider = new_provider
+            
+            ctx.console.print(f"\n[bold green]✓ Switched from {old_provider.name} to {new_provider.name}[/]")
+            
+            # Show any configuration needed
+            if not api_key:
+                env_var = self._get_env_var_name(provider_name)
+                ctx.console.print(f"\n[yellow]⚠ No API key found for {provider_name}[/]")
+                ctx.console.print(f"  Set environment variable: [cyan]{env_var}=your-api-key[/]")
+                ctx.console.print(f"  Or configure in [cyan]~/.henchman/settings.yaml[/]:")
+                ctx.console.print(f"    providers:")
+                ctx.console.print(f"      {provider_name}:")
+                ctx.console.print(f"        api_key: your-api-key")
+            
+        except Exception as e:
+            ctx.console.print(f"[red]Failed to switch provider: {e}[/]")
+            ctx.console.print("[dim]Check that the provider is properly configured.[/]")
+
+    def _get_example_config(self, provider_name: str) -> str:
+        """Get example configuration for a provider.
+        
+        Args:
+            provider_name: Name of the provider.
+            
+        Returns:
+            Example configuration string.
+        """
+        examples = {
+            "deepseek": "deepseek-chat (default), deepseek-coder",
+            "openai": "gpt-4-turbo, gpt-3.5-turbo",
+            "anthropic": "claude-3-opus, claude-3-sonnet",
+            "ollama": "llama2, mistral, codellama",
+        }
+        return examples.get(provider_name, "Check provider documentation")
+
+    def _get_env_vars(self, provider_name: str) -> str:
+        """Get environment variables needed for a provider.
+        
+        Args:
+            provider_name: Name of the provider.
+            
+        Returns:
+            Environment variable names.
+        """
+        env_vars = {
+            "deepseek": "DEEPSEEK_API_KEY",
+            "openai": "OPENAI_API_KEY",
+            "anthropic": "ANTHROPIC_API_KEY",
+            "ollama": "OLLAMA_HOST (optional, defaults to http://localhost:11434)",
+        }
+        return env_vars.get(provider_name, "Check provider documentation")
+
+    def _get_env_var_name(self, provider_name: str) -> str:
+        """Get the environment variable name for a provider's API key.
+        
+        Args:
+            provider_name: Name of the provider.
+            
+        Returns:
+            Environment variable name.
+        """
+        mapping = {
+            "deepseek": "DEEPSEEK_API_KEY",
+            "openai": "OPENAI_API_KEY",
+            "anthropic": "ANTHROPIC_API_KEY",
+            "ollama": "OLLAMA_API_KEY",  # Ollama doesn't usually need API key
+        }
+        return mapping.get(provider_name, f"{provider_name.upper()}_API_KEY")
+
+    def _get_api_key_for_provider(self, provider_name: str) -> str | None:
+        """Get API key for a provider from environment or settings.
+        
+        Args:
+            provider_name: Name of the provider.
+            
+        Returns:
+            API key if found, None otherwise.
+        """
+        # Try environment variables first
+        env_var = self._get_env_var_name(provider_name)
+        api_key = os.environ.get(env_var)
+        
+        if api_key:
+            return api_key
+        
+        # Try generic HENCHMAN_API_KEY
+        api_key = os.environ.get("HENCHMAN_API_KEY")
+        if api_key:
+            return api_key
+        
+        # Try settings
+        try:
+            settings = load_settings()
+            provider_settings = getattr(settings.providers, provider_name, None)
+            if provider_settings and hasattr(provider_settings, "api_key"):
+                return provider_settings.api_key
+        except Exception:
+            pass
+        
+        return None

henchman/cli/input.py

@@ -210,14 +210,14 @@ class KeyMonitor:
                     self._in_raw_mode = True
                     with self.input.attach(lambda: None):
                         while not self._stop_event.is_set() and not self._exit_event.is_set() and self._suspended.is_set():
-                            # Check for keys every 100ms
+                            # Check for keys every 10ms
                             keys = self.input.read_keys()
                             for key in keys:
                                 if key.key == Keys.Escape:
                                     self._stop_event.set()
                                 elif key.key == Keys.ControlC:
                                     self._exit_event.set()
-                            await asyncio.sleep(0.1)
+                            await asyncio.sleep(0.01)
             finally:
                 self._in_raw_mode = False
                 # If we were suspended, wait a bit before potentially re-entering raw mode

henchman/cli/repl.py

@@ -198,6 +198,30 @@ class Repl:
 
         return status
 
+    def _get_rich_status_message(self) -> str:
+        """Get rich status message for persistent display."""
+        from henchman.utils.tokens import TokenCounter
+
+        parts = []
+
+        # Plan Mode
+        plan_mode = self.session.plan_mode if self.session else False
+        parts.append("[yellow]PLAN[/]" if plan_mode else "[blue]CHAT[/]")
+
+        # Tokens
+        try:
+            msgs = self.agent.get_messages_for_api()
+            tokens = TokenCounter.count_messages(msgs)
+            parts.append(f"Tokens: ~[cyan]{tokens}[/]")
+        except Exception:
+            pass
+
+        # RAG Status
+        if self.rag_system and getattr(self.rag_system, "is_indexing", False):
+            parts.append("[cyan]RAG: Indexing...[/]")
+
+        return " | ".join(parts)
+
     def _register_builtin_tools(self) -> None:
         """Register built-in tools with the registry."""
         from henchman.tools.builtins import (
@@ -209,6 +233,7 @@ class Repl:
             ReadFileTool,
             ShellTool,
             WebFetchTool,
+            DuckDuckGoSearchTool,
             WriteFileTool,
         )
 
@@ -222,6 +247,7 @@ class Repl:
             GrepTool(),
             ShellTool(),
             WebFetchTool(),
+            DuckDuckGoSearchTool(),
         ]
         for tool in tools:
             self.tool_registry.register(tool)
@@ -322,6 +348,8 @@ class Repl:
             KeyboardInterrupt: If user presses Ctrl+C.
             EOFError: If user presses Ctrl+D.
         """
+        # Ensure a fresh line for the prompt
+        self.console.print()
         return await self.prompt_session.prompt_async(self.config.prompt)
 
     async def process_input(self, user_input: str) -> bool:
@@ -417,13 +445,16 @@ class Repl:
         self.current_monitor = monitor
         monitor_task = asyncio.create_task(monitor.monitor())
 
-        # Run the agent stream processing as a separate task so we can cancel it
-        agent_task = asyncio.create_task(
-            self._process_agent_stream(
-                self.agent.run(user_input),
-                assistant_content
+        from rich.status import Status
+        with self.console.status(self._get_rich_status_message(), spinner="dots") as status_obj:
+            # Run the agent stream processing as a separate task so we can cancel it
+            agent_task = asyncio.create_task(
+                self._process_agent_stream(
+                    self.agent.run(user_input),
+                    assistant_content,
+                    status_obj
+                )
             )
-        )
 
         try:
             while not agent_task.done():
@@ -437,7 +468,7 @@ class Repl:
                     agent_task.cancel()
                     break
                 # Small sleep to keep the loop responsive
-                await asyncio.sleep(0.05)
+                await asyncio.sleep(0)
 
             if not agent_task.done():
                 try:
@@ -458,7 +489,8 @@ class Repl:
     async def _process_agent_stream(
         self,
         event_stream: AsyncIterator[AgentEvent],
-        content_collector: list[str] | None = None
+        content_collector: list[str] | None = None,
+        status_obj: Status | None = None, # New parameter
     ) -> None:
         """Process an agent event stream, handling tool calls properly.
 
@@ -499,6 +531,10 @@ class Repl:
         accumulated_content: list[str] = []
 
         async for event in event_stream:
+            # Update status continuously
+            if status_obj:
+                status_obj.update(self._get_rich_status_message())
+
             if event.type == EventType.CONTENT:
                 # Stream content to console
                 self.console.print(event.data, end="")

henchman/core/session.py

@@ -353,18 +353,32 @@ class SessionManager:
         """Load a session from disk.
 
         Args:
-            session_id: ID of session to load.
+            session_id: ID or ID prefix of session to load.
 
         Returns:
             Loaded Session instance.
 
         Raises:
-            FileNotFoundError: If session doesn't exist.
+            FileNotFoundError: If session doesn't exist or is ambiguous.
         """
         path = self._get_session_path(session_id)
-        if not path.exists():
+        if path.exists():
+            return Session.from_json(path.read_text())
+
+        # If not found by exact ID, try as prefix
+        if not self.data_dir.exists():
+            raise FileNotFoundError(f"Session not found: {session_id}")
+
+        matches = list(self.data_dir.glob(f"{session_id}*.json"))
+        if not matches:
             raise FileNotFoundError(f"Session not found: {session_id}")
-        return Session.from_json(path.read_text())
+        
+        if len(matches) > 1:
+            # Prefer exact match if somehow multiple match prefix but one is exact
+            # (though glob already failed exact match if we are here)
+            raise ValueError(f"Ambiguous session ID prefix: {session_id}")
+            
+        return Session.from_json(matches[0].read_text())
 
     def load_by_tag(
         self,

henchman/providers/anthropic.py

@@ -19,11 +19,14 @@ from henchman.providers.base import (
     ToolCall,
     ToolDeclaration,
 )
+from henchman.utils.ratelimit import AsyncRateLimiter
+from henchman.utils.tokens import TokenCounter
 
 __all__ = ["AnthropicProvider"]
 
 # Available Claude models
 ANTHROPIC_MODELS = [
+    "claude-opus-4-6",
     "claude-sonnet-4-20250514",
     "claude-3-7-sonnet-20250219",
     "claude-3-5-sonnet-20241022",
@@ -50,6 +53,7 @@ class AnthropicProvider(ModelProvider):
         api_key: str | None = None,
         model: str = "claude-sonnet-4-20250514",
         max_tokens: int = 8192,
+        tokens_per_minute: int = 30000,
     ) -> None:
         """Initialize the Anthropic provider.
 
@@ -57,11 +61,13 @@ class AnthropicProvider(ModelProvider):
             api_key: API key for authentication. Defaults to ANTHROPIC_API_KEY env var.
             model: Default model to use.
             max_tokens: Maximum tokens in response.
+            tokens_per_minute: Maximum tokens per minute (rate limit).
         """
         self.api_key = api_key or os.getenv("ANTHROPIC_API_KEY", "")
         self.default_model = model
         self.max_tokens = max_tokens
         self._client = AsyncAnthropic(api_key=self.api_key or "placeholder")
+        self._rate_limiter = AsyncRateLimiter(tokens_per_minute)
 
     @property
     def name(self) -> str:
@@ -187,6 +193,11 @@ class AnthropicProvider(ModelProvider):
             # All other messages must have non-empty content
             if not (message.content or '').strip():
                 raise ValueError(f"Message with role '{message.role}' cannot have empty content")
+
+        # Rate limiting: wait for capacity based on input tokens
+        input_tokens = TokenCounter.count_messages(messages, model=self.default_model)
+        await self._rate_limiter.wait_for_capacity(input_tokens)
+
         system_prompt, formatted_messages = self._format_messages(messages)
 
         params: dict[str, Any] = {
@@ -202,6 +213,7 @@ class AnthropicProvider(ModelProvider):
         if tools:
             params["tools"] = [self._format_tool(t) for t in tools]
 
+        total_output_tokens = 0
         async with self._client.messages.stream(**params) as stream:
             pending_tool_calls: dict[str, dict[str, Any]] = {}
             current_tool_id: str | None = None
@@ -226,10 +238,15 @@ class AnthropicProvider(ModelProvider):
                     delta = event.delta
                     if delta.type == "text_delta":
                         content = delta.text
+                        total_output_tokens += TokenCounter.count_text(content, model=self.default_model)
                     elif delta.type == "thinking_delta":
                         thinking = delta.thinking
+                        total_output_tokens += TokenCounter.count_text(thinking, model=self.default_model)
                     elif delta.type == "input_json_delta" and current_tool_id:
                         pending_tool_calls[current_tool_id]["arguments"] += delta.partial_json
+                        # Note: we don't count JSON tokens precisely here as they come in,
+                        # but we could count the delta text.
+                        total_output_tokens += TokenCounter.count_text(delta.partial_json, model=self.default_model)
 
                 elif event.type == "content_block_stop":
                     current_tool_id = None
@@ -261,3 +278,6 @@ class AnthropicProvider(ModelProvider):
                         finish_reason=finish_reason,
                         thinking=thinking,
                     )
+
+        # Record final usage
+        await self._rate_limiter.add_usage(input_tokens + total_output_tokens)

henchman/tools/builtins/__init__.py

@@ -10,6 +10,7 @@ from henchman.tools.builtins.ls import LsTool
 from henchman.tools.builtins.rag_search import RagSearchTool
 from henchman.tools.builtins.shell import ShellTool
 from henchman.tools.builtins.web_fetch import WebFetchTool
+from henchman.tools.builtins.web_search import DuckDuckGoSearchTool
 
 __all__ = [
     "AskUserTool",
@@ -21,5 +22,6 @@ __all__ = [
     "ReadFileTool",
     "ShellTool",
     "WebFetchTool",
+    "DuckDuckGoSearchTool",
     "WriteFileTool",
 ]

henchman/tools/builtins/shell.py

@@ -101,6 +101,10 @@ class ShellTool(Tool):
                     success=False,
                     error=f"Timeout after {timeout} seconds",
                 )
+            except asyncio.CancelledError:
+                process.kill()
+                await process.wait()
+                raise
 
             # Decode output
             stdout_text = stdout.decode("utf-8", errors="replace")