Fix clw-llm-limit-exceeded: OpenClaw exceeds LLM API rate limits

Applications freeze or crash in loops, batch processing halts midway, or web services return 429 HTTP status codes proxied through OpenClaw. Logs show spikes in request volume, often during parallel processing or unthrottled loops. Performance degrades as retries without backoff compound the issue, leading to cascading failures.

In production, this appears as:

Affected scenarios: real-time chatbots, bulk data processing, or automated testing suites exceeding tokens per minute (TPM) or requests per minute (RPM).

## 2. Root Cause

OpenClaw is an open-source Python library for seamless LLM integration, abstracting providers via a unified API. The `clw-llm-limit-exceeded` error triggers when OpenClaw's internal HTTP client hits provider-enforced rate limits:

- **RPM (Requests Per Minute)**: e.g., OpenAI GPT-4o tier 1: 500 RPM.
- **TPM (Tokens Per Minute)**: e.g., 40,000 TPM for GPT-4o.
- **RPD (Requests Per Day)**: Daily caps like 10,000.

Root causes:

1. **No Built-in Throttling**: Default OpenClaw config lacks aggressive rate limiting, allowing bursts.
2. **Parallelism Overload**: `concurrent.futures` or `asyncio.gather` spawns too many goroutines/threads.
3. **Missing Backoff**: Naive retries ignore `Retry-After` headers.
4. **Tier Mismatch**: Free/tier-1 accounts vs. production load.
5. **Token Bloat**: Unoptimized prompts exceed TPM silently.

Internally, OpenClaw checks response headers:

```python
# Simplified from openclaw/core.py
if resp.status_code == 429:
    retry_after = int(resp.headers.get('Retry-After', 1))
    raise LLMLimitExceededError(f"Rate limit exceeded. Retry after {retry_after}s.")

pip install --upgrade openclaw[rate-limiter]

from openclaw import ClawConfig

config = ClawConfig(
    provider="openai",
    api_key="your-key",
    rate_limit_rpm=400,  # Below tier limit
    rate_limit_tpm=35000,
    max_retries=5,
    backoff_factor=2.0
)
clw = OpenClaw(config)

# Broken: No backoff, infinite loop risk
from openclaw import OpenClaw

clw = OpenClaw()
prompts = ["Hello", "World"] * 1000  # Burst overload

for prompt in prompts:
    try:
        response = clw.llm.generate(prompt, model="gpt-4o")
        print(response)
    except Exception as e:
        print(f"Failed: {e}")  # No delay, hits limit faster

# Fixed: Exponential backoff with jitter
from openclaw import OpenClaw
from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
from openclaw.errors import LLMLimitExceededError
import random

clw = OpenClaw(config)  # From Step 1

@retry(
    stop=stop_after_attempt(5),
    wait=wait_exponential(multiplier=1, min=4, max=60) + random.uniform(0, 1),  # Jitter
    retry=retry_if_exception_type(LLMLimitExceededError)
)
def safe_generate(prompt):
    return clw.llm.generate(prompt, model="gpt-4o")

prompts = ["Hello", "World"] * 1000

for prompt in prompts:
    try:
        response = safe_generate(prompt)
        print(response)
    except Exception as e:
        print(f"Permanent fail: {e}")

# Broken: asyncio.gather overloads
import asyncio
from openclaw import OpenClaw

clw = OpenClaw()
async def gen(prompt):
    return clw.llm.generate(prompt)  # 100 concurrent = instant 429

prompts = [f"Prompt {i}" for i in range(100)]
responses = asyncio.run(asyncio.gather(*(gen(p) for p in prompts)))

# Fixed: Semaphore + queue
import asyncio
import aiometer  # pip install aiometer
from openclaw import OpenClaw

clw = OpenClaw(config)

async def gen(prompt):
    return clw.llm.generate(prompt)

prompts = [f"Prompt {i}" for i in range(100)]
# Limit to 10 concurrent, 400/min
responses = asyncio.run(
    aiometer.amap(gen, prompts, max_concurrent=10, max_rate=400/60)
)

batch = clw.llm.create_batch([{"prompt": p} for p in prompts[:50]])
results = clw.llm.submit_batch(batch)

python -m openclaw.test --rate-test 400rpm --duration 5m

[INFO] Requests: 350/min, Remaining RPM: 150/500

# test_fix.py
import time
start = time.time()
responses = [safe_generate(f"Test {i}") for i in range(500)]
assert len(responses) == 500
print(f"Success in {time.time() - start:.2f}s")

locust -f locustfile.py --users 50 --spawn-rate 5