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.pyindex 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.pyindex f0e6bc09..7d06d1f1 100644--- a/cli/session.py+++ b/cli/session.py@@ -139,16 +139,25 @@ class CLISession:session_id_extracted = Trueyield event+ stderr_text = Noneif 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 = Falsediff --git a/messaging/handler.py b/messaging/handler.pyindex 13dd7786..ac846f82 100644--- a/messaging/handler.py+++ b/messaging/handler.py@@ -44,7 +44,6 @@ class ClaudeMessageHandler:self.cli_manager = cli_managerself.session_store = session_storeself.tree_queue = TreeQueueManager()- self._flood_wait_until = 0async def handle_message(self, incoming: IncomingMessage) -> None:"""@@ -183,9 +182,7 @@ class ClaudeMessageHandler:nonlocal last_ui_updatenow = 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 = nowexcept 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 errorlogger.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 nodesfor node in cancelled_nodes:try:await self.platform.edit_message(diff --git a/messaging/tree_queue.py b/messaging/tree_queue.pyindex 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 errorReturns:- 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 stateswhile 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 = Falsetree._current_node_id = Nonediff --git a/providers/nvidia_nim.py b/providers/nvidia_nim.pyindex 22131de8..bb47d15a 100644--- a/providers/nvidia_nim.py+++ b/providers/nvidia_nim.py@@ -11,7 +11,6 @@ from httpx import TimeoutException, ReadTimeout, ConnectTimeoutfrom .base import BaseProvider, ProviderConfigfrom .utils import (- SlidingWindowRateLimiter,SSEBuilder,map_stop_reason,ThinkTagParser,@@ -28,6 +27,7 @@ from .exceptions import (OverloadedError,APIError,)+from .rate_limit import GlobalRateLimiterlogger = 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 cooldownreturn 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 summarydiff --git a/providers/rate_limit.py b/providers/rate_limit.pynew file mode 100644index 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.pyindex 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 CLIParserevent = {"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."""