Skip to content

Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)

Python

moved rate limiting to the api level

Alishahryar17a25c967b0db
diff --git a/cli/parser.py b/cli/parser.py
index 1fed6da9..4b25bb7f 100644
--- a/cli/parser.py
+++ b/cli/parser.py
@@ -104,11 +104,16 @@ class CLIParser:
msg = err.get("message") if isinstance(err, dict) else str(err)
return [{"type": "error", "message": msg}]
elif etype == "exit":
- return [
- {
- "type": "complete",
- "status": "success" if event.get("code") == 0 else "failed",
- }
- ]
+ code = event.get("code", 0)
+ stderr = event.get("stderr")
+ if code == 0:
+ return [{"type": "complete", "status": "success"}]
+ else:
+ # Non-zero exit is an error
+ error_msg = stderr if stderr else f"Process exited with code {code}"
+ return [
+ {"type": "error", "message": error_msg},
+ {"type": "complete", "status": "failed"},
+ ]
return []
diff --git a/cli/session.py b/cli/session.py
index f0e6bc09..7d06d1f1 100644
--- a/cli/session.py
+++ b/cli/session.py
@@ -139,16 +139,25 @@ class CLISession:
session_id_extracted = True
yield event
+ stderr_text = None
if self.process.stderr:
stderr_output = await self.process.stderr.read()
if stderr_output:
- logger.error(
- f"Claude CLI Stderr: {stderr_output.decode('utf-8', errors='replace')}"
- )
+ stderr_text = stderr_output.decode(
+ "utf-8", errors="replace"
+ ).strip()
+ logger.error(f"Claude CLI Stderr: {stderr_text}")
+ # Yield stderr as error event so it shows in UI
+ if stderr_text:
+ yield {"type": "error", "error": {"message": stderr_text}}
return_code = await self.process.wait()
logger.info(f"Claude CLI exited with code {return_code}")
- yield {"type": "exit", "code": return_code}
+ yield {
+ "type": "exit",
+ "code": return_code,
+ "stderr": stderr_text,
+ }
finally:
self._is_busy = False
diff --git a/messaging/handler.py b/messaging/handler.py
index 13dd7786..ac846f82 100644
--- a/messaging/handler.py
+++ b/messaging/handler.py
@@ -44,7 +44,6 @@ class ClaudeMessageHandler:
self.cli_manager = cli_manager
self.session_store = session_store
self.tree_queue = TreeQueueManager()
- self._flood_wait_until = 0
async def handle_message(self, incoming: IncomingMessage) -> None:
"""
@@ -183,9 +182,7 @@ class ClaudeMessageHandler:
nonlocal last_ui_update
now = time.time()
- if now < self._flood_wait_until:
- return
-
+ # Small 1s debounce for UI sanity (not a hard rate limit)
if not force and now - last_ui_update < 1.0:
return
@@ -197,6 +194,10 @@ class ClaudeMessageHandler:
)
last_ui_update = now
except Exception as e:
+ # Log but don't crash the task
+ if "flood" in str(e).lower() or "wait" in str(e).lower():
+ # Set a temporary skip to avoid spamming the log if we're flooded
+ last_ui_update = now + 10 # Skip for 10s on flood error
logger.error(f"UI update failed: {e}")
try:
@@ -277,32 +278,66 @@ class ClaudeMessageHandler:
self.session_store.save_tree(tree.root_id, tree.to_dict())
elif parsed["type"] == "error":
- components["errors"].append(
- parsed.get("message", "Unknown error")
- )
+ error_msg = parsed.get("message", "Unknown error")
+ components["errors"].append(error_msg)
await update_ui("❌ **Error**", force=True)
if tree:
- await tree.update_state(
- node_id,
- MessageState.ERROR,
- error_message=parsed.get("message"),
+ # Mark this node and propagate to pending children
+ affected = await self.tree_queue.mark_node_error(
+ node_id, error_msg, propagate_to_children=True
)
+ # Update status messages for all affected children
+ for child in affected[1:]: # Skip first (current node)
+ try:
+ await self.platform.edit_message(
+ child.incoming.chat_id,
+ child.status_message_id,
+ f"❌ **Cancelled:** Parent task failed",
+ parse_mode="markdown",
+ )
+ except Exception as e:
+ logger.error(f"Failed to update child status: {e}")
except asyncio.CancelledError:
components["errors"].append("Task was cancelled")
await update_ui("❌ **Cancelled**", force=True)
if tree:
- await tree.update_state(
- node_id, MessageState.ERROR, error_message="Cancelled"
+ # Mark this node and propagate to pending children
+ affected = await self.tree_queue.mark_node_error(
+ node_id, "Cancelled by user", propagate_to_children=True
)
+ # Update status messages for all affected children
+ for child in affected[1:]:
+ try:
+ await self.platform.edit_message(
+ child.incoming.chat_id,
+ child.status_message_id,
+ f"❌ **Cancelled:** Parent task was stopped",
+ parse_mode="markdown",
+ )
+ except Exception as e:
+ logger.error(f"Failed to update child status: {e}")
except Exception as e:
logger.error(f"Task failed: {e}")
- components["errors"].append(str(e)[:200])
+ error_msg = str(e)[:200]
+ components["errors"].append(error_msg)
await update_ui("💥 **Task Failed**", force=True)
if tree:
- await tree.update_state(
- node_id, MessageState.ERROR, error_message=str(e)[:200]
+ # Mark this node and propagate to pending children
+ affected = await self.tree_queue.mark_node_error(
+ node_id, error_msg, propagate_to_children=True
)
+ # Update status messages for all affected children
+ for child in affected[1:]:
+ try:
+ await self.platform.edit_message(
+ child.incoming.chat_id,
+ child.status_message_id,
+ f"❌ **Cancelled:** Parent task failed",
+ parse_mode="markdown",
+ )
+ except Exception as e:
+ logger.error(f"Failed to update child status: {e}")
def _build_message(
self,
@@ -388,12 +423,22 @@ class ClaudeMessageHandler:
async def stop_all_tasks(self) -> int:
"""
Stop all pending and in-progress tasks.
- Updates status messages for all affected nodes.
+
+ Order of operations:
+ 1. Stop CLI sessions first (kills subprocesses, unblocks I/O)
+ 2. Cancel async tasks in tree queue
+ 3. Update UI for all affected nodes
"""
- cancelled_nodes = await self.tree_queue.cancel_all()
+ # 1. Stop CLI sessions FIRST - this kills subprocess and unblocks I/O
+ logger.info("Stopping all CLI sessions...")
await self.cli_manager.stop_all()
- # Update UI for all cancelled nodes
+ # 2. Cancel tree queue tasks (now they should unblock immediately)
+ logger.info("Cancelling tree queue tasks...")
+ cancelled_nodes = await self.tree_queue.cancel_all()
+ logger.info(f"Cancelled {len(cancelled_nodes)} nodes")
+
+ # 3. Update UI for all cancelled nodes
for node in cancelled_nodes:
try:
await self.platform.edit_message(
diff --git a/messaging/tree_queue.py b/messaging/tree_queue.py
index a4ecb3b6..0d36665b 100644
--- a/messaging/tree_queue.py
+++ b/messaging/tree_queue.py
@@ -542,12 +542,77 @@ class TreeQueueManager:
tree = self.get_tree_for_node(node_id)
return tree.get_queue_size() if tree else 0
- def cancel_tree(self, root_id: str) -> List[MessageNode]:
+ def get_pending_children(self, node_id: str) -> List[MessageNode]:
+ """
+ Get all pending child nodes (recursively) of a given node.
+
+ Used for error propagation - when a node fails, its pending
+ children should also be marked as failed.
+ """
+ tree = self.get_tree_for_node(node_id)
+ if not tree:
+ return []
+
+ pending = []
+ node = tree.get_node(node_id)
+ if not node:
+ return []
+
+ for child_id in node.children_ids:
+ child = tree.get_node(child_id)
+ if child and child.state == MessageState.PENDING:
+ pending.append(child)
+ # Recursively get children of pending children
+ pending.extend(self.get_pending_children(child_id))
+
+ return pending
+
+ async def mark_node_error(
+ self,
+ node_id: str,
+ error_message: str,
+ propagate_to_children: bool = True,
+ ) -> List[MessageNode]:
"""
- Cancel all queued messages in a tree.
+ Mark a node as ERROR and optionally propagate to pending children.
+
+ Args:
+ node_id: The node to mark as error
+ error_message: Error description
+ propagate_to_children: If True, also mark pending children as error
Returns:
- List of cancelled nodes
+ List of all nodes marked as error (including children)
+ """
+ tree = self.get_tree_for_node(node_id)
+ if not tree:
+ return []
+
+ affected = []
+ node = tree.get_node(node_id)
+ if node:
+ await tree.update_state(
+ node_id, MessageState.ERROR, error_message=error_message
+ )
+ affected.append(node)
+
+ if propagate_to_children:
+ pending_children = self.get_pending_children(node_id)
+ for child in pending_children:
+ await tree.update_state(
+ child.node_id,
+ MessageState.ERROR,
+ error_message=f"Parent failed: {error_message}",
+ )
+ affected.append(child)
+
+ return affected
+
+ def cancel_tree(self, root_id: str) -> List[MessageNode]:
+ """
+ Cancel all queued and in-progress messages in a tree.
+
+ Updates node states to ERROR and returns list of affected nodes.
"""
tree = self._trees.get(root_id)
if not tree:
@@ -560,19 +625,33 @@ class TreeQueueManager:
tree._current_task.cancel()
if tree._current_node_id:
node = tree.get_node(tree._current_node_id)
- if node:
+ if node and node.state not in (
+ MessageState.COMPLETED,
+ MessageState.ERROR,
+ ):
+ node.state = MessageState.ERROR
+ node.error_message = "Cancelled by user"
cancelled_nodes.append(node)
- # Clear queue
+ # Clear queue and update states
while not tree._queue.empty():
try:
node_id = tree._queue.get_nowait()
node = tree.get_node(node_id)
if node:
+ node.state = MessageState.ERROR
+ node.error_message = "Cancelled by user"
cancelled_nodes.append(node)
except asyncio.QueueEmpty:
break
+ # Also cancel any PENDING nodes that weren't in queue
+ for node in tree.all_nodes():
+ if node.state == MessageState.PENDING and node not in cancelled_nodes:
+ node.state = MessageState.ERROR
+ node.error_message = "Cancelled by user"
+ cancelled_nodes.append(node)
+
tree._is_processing = False
tree._current_node_id = None
diff --git a/providers/nvidia_nim.py b/providers/nvidia_nim.py
index 22131de8..bb47d15a 100644
--- a/providers/nvidia_nim.py
+++ b/providers/nvidia_nim.py
@@ -11,7 +11,6 @@ from httpx import TimeoutException, ReadTimeout, ConnectTimeout
from .base import BaseProvider, ProviderConfig
from .utils import (
- SlidingWindowRateLimiter,
SSEBuilder,
map_stop_reason,
ThinkTagParser,
@@ -28,6 +27,7 @@ from .exceptions import (
OverloadedError,
APIError,
)
+from .rate_limit import GlobalRateLimiter
logger = logging.getLogger(__name__)
@@ -43,10 +43,7 @@ class NvidiaNimProvider(BaseProvider):
or os.getenv("NVIDIA_NIM_BASE_URL", "https://integrate.api.nvidia.com/v1")
).rstrip("/")
self._nim_params = self._load_nim_params()
- self._rate_limiter = SlidingWindowRateLimiter(
- rate_limit=config.rate_limit or 40,
- window_seconds=config.rate_window or 60,
- )
+ self._global_rate_limiter = GlobalRateLimiter.get_instance()
self._client = httpx.AsyncClient(
timeout=httpx.Timeout(300.0, connect=30.0, read=60.0),
limits=httpx.Limits(max_connections=100, max_keepalive_connections=20),
@@ -110,7 +107,8 @@ class NvidiaNimProvider(BaseProvider):
self, request: Any, input_tokens: int = 0
) -> AsyncIterator[str]:
"""Stream response in Anthropic SSE format."""
- await self._rate_limiter.acquire()
+ # Wait if globally rate limited
+ await self._global_rate_limiter.wait_if_blocked()
body = self._build_request_body(request, stream=True)
# Log compact request summary
@@ -289,6 +287,8 @@ class NvidiaNimProvider(BaseProvider):
if response_status == 401:
return AuthenticationError(message, raw_error=error_text)
if response_status == 429:
+ # Trigger global rate limit block
+ self._global_rate_limiter.set_blocked(60) # Default 60s cooldown
return RateLimitError(message, raw_error=error_text)
if response_status in (400, 422):
return InvalidRequestError(message, raw_error=error_text)
@@ -390,7 +390,8 @@ class NvidiaNimProvider(BaseProvider):
async def complete(self, request: Any) -> dict:
"""Make a non-streaming completion request."""
- await self._rate_limiter.acquire()
+ # Wait if globally rate limited
+ await self._global_rate_limiter.wait_if_blocked()
body = self._build_request_body(request, stream=False)
# Log compact request summary
diff --git a/providers/rate_limit.py b/providers/rate_limit.py
new file mode 100644
index 00000000..5b3cb815
--- /dev/null
+++ b/providers/rate_limit.py
@@ -0,0 +1,69 @@
+"""Global rate limiter for API requests."""
+
+import asyncio
+import time
+import logging
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+class GlobalRateLimiter:
+ """
+ Global singleton rate limiter that blocks all requests
+ when a rate limit error is encountered.
+
+ No proactive limits - only reactive when 429 is hit.
+ No retry logic - just pauses all requests until cooldown expires.
+ """
+
+ _instance: Optional["GlobalRateLimiter"] = None
+
+ def __init__(self):
+ self._blocked_until: float = 0
+ self._lock = asyncio.Lock()
+
+ @classmethod
+ def get_instance(cls) -> "GlobalRateLimiter":
+ """Get or create the singleton instance."""
+ if cls._instance is None:
+ cls._instance = cls()
+ return cls._instance
+
+ @classmethod
+ def reset_instance(cls) -> None:
+ """Reset singleton (for testing)."""
+ cls._instance = None
+
+ async def wait_if_blocked(self) -> float:
+ """
+ Wait if currently rate limited.
+
+ Returns:
+ The time waited in seconds (0 if not blocked)
+ """
+ now = time.time()
+ if now < self._blocked_until:
+ wait_time = self._blocked_until - now
+ logger.warning(f"Global rate limit active, waiting {wait_time:.1f}s...")
+ await asyncio.sleep(wait_time)
+ return wait_time
+ return 0
+
+ def set_blocked(self, seconds: float = 60) -> None:
+ """
+ Set global block for specified seconds.
+
+ Args:
+ seconds: How long to block (default 60s)
+ """
+ self._blocked_until = time.time() + seconds
+ logger.warning(f"Global rate limit set for {seconds:.1f}s")
+
+ def is_blocked(self) -> bool:
+ """Check if currently blocked."""
+ return time.time() < self._blocked_until
+
+ def remaining_wait(self) -> float:
+ """Get remaining wait time in seconds."""
+ return max(0, self._blocked_until - time.time())
diff --git a/tests/test_cli.py b/tests/test_cli.py
index 78d328eb..1eef7a2c 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -124,13 +124,20 @@ class TestCLIParser:
assert result[0]["status"] == "success"
def test_parse_exit_failure(self):
- """Test parsing exit event with failure."""
+ """Test parsing exit event with failure returns error then complete."""
from cli.parser import CLIParser
event = {"type": "exit", "code": 1}
result = CLIParser.parse_event(event)
- assert result[0]["type"] == "complete"
- assert result[0]["status"] == "failed"
+ # Non-zero exit now returns error first, then complete
+ assert len(result) == 2
+ assert result[0]["type"] == "error"
+ assert (
+ "exit" in result[0]["message"].lower()
+ or "code" in result[0]["message"].lower()
+ )
+ assert result[1]["type"] == "complete"
+ assert result[1]["status"] == "failed"
def test_parse_invalid_event(self):
"""Test parsing returns empty list for unrecognized event."""