henchman-ai 0.1.14__tar.gz → 0.1.16__tar.gz

{henchman_ai-0.1.14 → henchman_ai-0.1.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: henchman-ai
-Version: 0.1.14
+Version: 0.1.16
 Summary: A model-agnostic AI agent CLI - your AI henchman for the terminal
 Project-URL: Homepage, https://github.com/MGPowerlytics/henchman-ai
 Project-URL: Repository, https://github.com/MGPowerlytics/henchman-ai

{henchman_ai-0.1.14 → henchman_ai-0.1.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "henchman-ai"
-version = "0.1.14"
+version = "0.1.16"
 description = "A model-agnostic AI agent CLI - your AI henchman for the terminal"
 readme = "README.md"
 license = "MIT"

{henchman_ai-0.1.14 → henchman_ai-0.1.16}/src/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_ai-0.1.14 → henchman_ai-0.1.16}/src/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_ai-0.1.16/src/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_ai-0.1.14 → henchman_ai-0.1.16}/src/henchman/providers/anthropic.py

@@ -4,12 +4,13 @@ This provider uses the Anthropic SDK to communicate with Claude models.
 Unlike OpenAI-compatible APIs, Anthropic has its own message format.
 """
 
+import asyncio
 import json
 import os
 from collections.abc import AsyncIterator
 from typing import Any
 
-from anthropic import AsyncAnthropic
+from anthropic import AsyncAnthropic, RateLimitError
 
 from henchman.providers.base import (
     FinishReason,
@@ -19,11 +20,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 +54,8 @@ class AnthropicProvider(ModelProvider):
         api_key: str | None = None,
         model: str = "claude-sonnet-4-20250514",
         max_tokens: int = 8192,
+        tokens_per_minute: int = 30000,
+        max_retries: int = 3,
     ) -> None:
         """Initialize the Anthropic provider.
 
@@ -57,11 +63,15 @@ 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).
+            max_retries: Maximum number of retries for rate limits.
         """
         self.api_key = api_key or os.getenv("ANTHROPIC_API_KEY", "")
         self.default_model = model
         self.max_tokens = max_tokens
+        self.max_retries = max_retries
         self._client = AsyncAnthropic(api_key=self.api_key or "placeholder")
+        self._rate_limiter = AsyncRateLimiter(tokens_per_minute)
 
     @property
     def name(self) -> str:
@@ -187,6 +197,7 @@ 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")
+
         system_prompt, formatted_messages = self._format_messages(messages)
 
         params: dict[str, Any] = {
@@ -202,62 +213,99 @@ class AnthropicProvider(ModelProvider):
         if tools:
             params["tools"] = [self._format_tool(t) for t in tools]
 
-        async with self._client.messages.stream(**params) as stream:
-            pending_tool_calls: dict[str, dict[str, Any]] = {}
-            current_tool_id: str | None = None
-
-            async for event in stream:
-                content: str | None = None
-                thinking: str | None = None
-                tool_calls: list[ToolCall] | None = None
-                finish_reason: FinishReason | None = None
-
-                if event.type == "content_block_start":
-                    block = event.content_block
-                    if block.type == "tool_use":
-                        current_tool_id = block.id
-                        pending_tool_calls[block.id] = {
-                            "id": block.id,
-                            "name": block.name,
-                            "arguments": "",
-                        }
-
-                elif event.type == "content_block_delta":
-                    delta = event.delta
-                    if delta.type == "text_delta":
-                        content = delta.text
-                    elif delta.type == "thinking_delta":
-                        thinking = delta.thinking
-                    elif delta.type == "input_json_delta" and current_tool_id:
-                        pending_tool_calls[current_tool_id]["arguments"] += delta.partial_json
-
-                elif event.type == "content_block_stop":
-                    current_tool_id = None
-
-                elif event.type == "message_delta":
-                    finish_reason = self._parse_finish_reason(event.delta.stop_reason)
-
-                    # Emit completed tool calls
-                    if finish_reason == FinishReason.TOOL_CALLS and pending_tool_calls:
-                        tool_calls = []
-                        for tc_data in pending_tool_calls.values():
-                            try:
-                                arguments = json.loads(tc_data["arguments"]) if tc_data["arguments"] else {}
-                            except json.JSONDecodeError:
-                                arguments = {}
-                            tool_calls.append(
-                                ToolCall(
-                                    id=tc_data["id"],
-                                    name=tc_data["name"],
-                                    arguments=arguments,
-                                )
+        input_tokens = TokenCounter.count_messages(messages, model=self.default_model)
+        retries = 0
+        while True:
+            try:
+                # Rate limiting: wait for capacity based on input tokens
+                await self._rate_limiter.wait_for_capacity(input_tokens)
+
+                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
+
+                    async for event in stream:
+                        content: str | None = None
+                        thinking: str | None = None
+                        tool_calls: list[ToolCall] | None = None
+                        finish_reason: FinishReason | None = None
+
+                        if event.type == "content_block_start":
+                            block = event.content_block
+                            if block.type == "tool_use":
+                                current_tool_id = block.id
+                                pending_tool_calls[block.id] = {
+                                    "id": block.id,
+                                    "name": block.name,
+                                    "arguments": "",
+                                }
+
+                        elif event.type == "content_block_delta":
+                            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
+
+                        elif event.type == "message_delta":
+                            finish_reason = self._parse_finish_reason(event.delta.stop_reason)
+
+                            # Emit completed tool calls
+                            if finish_reason == FinishReason.TOOL_CALLS and pending_tool_calls:
+                                tool_calls = []
+                                for tc_data in pending_tool_calls.values():
+                                    try:
+                                        arguments = json.loads(tc_data["arguments"]) if tc_data["arguments"] else {}
+                                    except json.JSONDecodeError:
+                                        arguments = {}
+                                    tool_calls.append(
+                                        ToolCall(
+                                            id=tc_data["id"],
+                                            name=tc_data["name"],
+                                            arguments=arguments,
+                                        )
+                                    )
+
+                        # Only yield if we have meaningful content
+                        if content is not None or thinking is not None or tool_calls or finish_reason:
+                            yield StreamChunk(
+                                content=content,
+                                tool_calls=tool_calls,
+                                finish_reason=finish_reason,
+                                thinking=thinking,
                             )
 
-                # Only yield if we have meaningful content
-                if content is not None or thinking is not None or tool_calls or finish_reason:
-                    yield StreamChunk(
-                        content=content,
-                        tool_calls=tool_calls,
-                        finish_reason=finish_reason,
-                        thinking=thinking,
-                    )
+                # Record final usage
+                await self._rate_limiter.add_usage(input_tokens + total_output_tokens)
+                break # Success, exit retry loop
+
+            except RateLimitError as e:
+                retries += 1
+                if retries > self.max_retries:
+                    raise
+
+                # Hit rate limit, wait and retry
+                # Extract wait time from headers if available, otherwise use exponential backoff
+                wait_time = 5.0 * (2 ** (retries - 1)) # Default backoff
+                
+                # Log to console if possible
+                from rich.console import Console
+                Console().print(f"[yellow]Rate limit reached (429). Retrying in {wait_time:.1f}s... (Attempt {retries}/{self.max_retries})[/yellow]")
+                
+                await asyncio.sleep(wait_time)
+                # After sleeping, we loop back and try again.
+                # The rate limiter's wait_for_capacity will be called again if we move it inside the loop,
+                # but we already called it once. However, Anthropic says we are OVER the limit,
+                # so we should probably record that usage or just wait.
+                # Let's move the wait_for_capacity INSIDE the retry loop.

henchman_ai-0.1.16/src/henchman/utils/ratelimit.py

@@ -0,0 +1,71 @@
+"""Rate limiting utilities for API providers."""
+
+import asyncio
+import time
+from collections import deque
+
+
+class AsyncRateLimiter:
+    """An asynchronous rate limiter using a sliding window.
+
+    Tracks token usage and provides a way to wait until enough capacity
+    is available.
+    """
+
+    def __init__(self, tokens_per_minute: int) -> None:
+        """Initialize the rate limiter.
+
+        Args:
+            tokens_per_minute: Maximum tokens allowed per 60-second window.
+        """
+        self.tokens_per_minute = tokens_per_minute
+        # Each entry is (timestamp, token_count)
+        self.usage: deque[tuple[float, int]] = deque()
+        self._lock = asyncio.Lock()
+
+    async def _clean_old_usage(self) -> None:
+        """Remove usage entries older than 60 seconds."""
+        now = time.time()
+        while self.usage and self.usage[0][0] < now - 60:
+            self.usage.popleft()
+
+    def _get_current_usage(self) -> int:
+        """Calculate the total tokens used in the last 60 seconds."""
+        return sum(tokens for _, tokens in self.usage)
+
+    async def wait_for_capacity(self, tokens: int) -> None:
+        """Wait until the specified number of tokens can be used.
+
+        Args:
+            tokens: The number of tokens to be used.
+        """
+        if tokens > self.tokens_per_minute:
+            # If a single request is larger than the limit, we can't really
+            # satisfy it, but we'll just wait for the window to be completely clear.
+            tokens = self.tokens_per_minute
+
+        async with self._lock:
+            while True:
+                await self._clean_old_usage()
+                current_usage = self._get_current_usage()
+
+                if current_usage + tokens <= self.tokens_per_minute:
+                    break
+
+                # Wait until the oldest entry expires
+                if self.usage:
+                    sleep_time = self.usage[0][0] + 60.1 - time.time()
+                    if sleep_time > 0:
+                        await asyncio.sleep(sleep_time)
+                else:
+                    # Should not happen if current_usage > 0, but safety first
+                    await asyncio.sleep(1)
+
+    async def add_usage(self, tokens: int) -> None:
+        """Record token usage.
+
+        Args:
+            tokens: The number of tokens used.
+        """
+        async with self._lock:
+            self.usage.append((time.time(), tokens))

{henchman_ai-0.1.14 → henchman_ai-0.1.16}/src/henchman/utils/tokens.py

@@ -27,6 +27,7 @@ MODEL_LIMITS: dict[str, int] = {
     "gpt-4": 8192,
     "gpt-3.5-turbo": 16385,
     # Anthropic models (these use different tokenization but we estimate)
+    "claude-opus-4-6": 200000,
     "claude-sonnet-4-20250514": 200000,
     "claude-3-7-sonnet-20250219": 200000,
     "claude-3-5-sonnet-20241022": 200000,

{henchman_ai-0.1.14 → henchman_ai-0.1.16}/src/henchman/version.py

@@ -1,6 +1,6 @@
 """Version information for Henchman-AI."""
 
-VERSION_TUPLE = (0, 1, 13)
+VERSION_TUPLE = (0, 1, 16)
 VERSION = ".".join(str(v) for v in VERSION_TUPLE)
 
 __all__ = ["VERSION", "VERSION_TUPLE"]