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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: henchman-ai
-Version: 0.1.15
+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.15 → henchman_ai-0.1.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "henchman-ai"
-version = "0.1.15"
+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.15 → 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,
@@ -54,6 +55,7 @@ class AnthropicProvider(ModelProvider):
         model: str = "claude-sonnet-4-20250514",
         max_tokens: int = 8192,
         tokens_per_minute: int = 30000,
+        max_retries: int = 3,
     ) -> None:
         """Initialize the Anthropic provider.
 
@@ -62,10 +64,12 @@ class AnthropicProvider(ModelProvider):
             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)
 
@@ -194,10 +198,6 @@ class AnthropicProvider(ModelProvider):
             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] = {
@@ -213,71 +213,99 @@ 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
-
-            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,
-                                )
+        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)
+                # 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.15 → henchman_ai-0.1.16}/src/henchman/version.py

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

{henchman_ai-0.1.15 → henchman_ai-0.1.16}/tests/providers/test_anthropic_ratelimit.py

@@ -5,8 +5,8 @@ import time
 import pytest
 from unittest.mock import MagicMock, patch, AsyncMock
 
-from henchman.providers.anthropic import AnthropicProvider
-from henchman.providers.base import Message
+from henchman.providers.anthropic import AnthropicProvider, RateLimitError
+from henchman.providers.base import Message, StreamChunk, FinishReason
 
 
 @pytest.mark.asyncio
@@ -74,3 +74,43 @@ async def test_anthropic_rate_limiting_delays():
                 pass
             
             assert mock_sleep.called
+
+
+@pytest.mark.asyncio
+async def test_anthropic_rate_limit_retry():
+    """Test that AnthropicProvider retries on RateLimitError."""
+    limit = 100
+    messages = [Message(role="user", content="Hello")]
+    
+    with patch('henchman.providers.anthropic.AsyncAnthropic') as mock_anthropic:
+        mock_client = MagicMock()
+        mock_anthropic.return_value = mock_client
+        
+        provider = AnthropicProvider(api_key="test", tokens_per_minute=limit, max_retries=2)
+        
+        # Setup mock stream for successful call
+        mock_stream = AsyncMock()
+        
+        async def mock_aiter():
+            yield MagicMock(type="content_block_delta", delta=MagicMock(type="text_delta", text="Success"))
+            yield MagicMock(type="message_delta", delta=MagicMock(stop_reason="end_turn"))
+                
+        mock_stream.__aenter__.return_value = mock_aiter()
+        
+        # First call fails, second succeeds
+        # Anthropic SDK RateLimitError needs a message and response
+        error_response = MagicMock()
+        error_response.status_code = 429
+        rate_limit_error = RateLimitError(message="Rate limit hit", response=error_response, body={})
+        
+        mock_client.messages.stream.side_effect = [rate_limit_error, mock_stream]
+        
+        with patch('asyncio.sleep', new_callable=AsyncMock) as mock_sleep:
+            chunks = []
+            async for chunk in provider.chat_completion_stream(messages):
+                chunks.append(chunk)
+            
+            assert mock_client.messages.stream.call_count == 2
+            assert mock_sleep.call_count == 1
+            assert any(c.content == "Success" for c in chunks)
+            assert any(c.finish_reason == FinishReason.STOP for c in chunks)