Fix clw-llm-timeout: Resolve OpenClaw LLM request timeouts efficiently

- Application freezes or throws exceptions mid-request.
- High CPU usage during wait periods, followed by abrupt failure.
- Intermittent failures under load, especially with long prompts (>1000 tokens).
- Logs show repeated attempts if retries are enabled, e.g.:

This occurs in synchronous and asynchronous modes. In production, it leads to cascading failures in pipelines relying on LLM responses for tasks like code generation or data processing. Monitor via OpenClaw's debug logs (`CLW_LOG_LEVEL=DEBUG`) to confirm:

Affected versions: OpenClaw v2.1.0+, common in C++ applications integrating LLMs.

## 2. Root Cause

The `clw-llm-timeout` stems from OpenClaw's default HTTP client timeout (30 seconds) being insufficient for LLM requests. Root causes:

1. **Slow LLM Inference**: Large models (e.g., GPT-4, Claude-3) take 45-120s for complex prompts due to queueing, token generation, and server load.
2. **Network Latency**: High RTT (>200ms) in cloud environments, VPNs, or regions far from the LLM provider's data centers.
3. **Payload Size**: Prompts exceeding 4k tokens inflate transmission time; responses can be gigabytes for verbose outputs.
4. **Server-Side Issues**: Provider overload, rate limits, or maintenance without prior notice.
5. **Client Misconfiguration**: Default `ClwLLMClient` uses `curl` backend with no custom timeouts; async mode (`clw::async_request`) exacerbates if event loop blocks.

Internally, OpenClaw's `libclw_http.cpp` enforces:

```cpp
// Simplified from OpenClaw source (v2.1.2)
constexpr int DEFAULT_TIMEOUT_SEC = 30;
if (response_timeout > 0) {
    curl_easy_setopt(handle, CURLOPT_TIMEOUT, response_timeout);
} else {
    curl_easy_setopt(handle, CURLOPT_TIMEOUT, DEFAULT_TIMEOUT_SEC);
}

#include <openclaw/llm_client.h>

int main() {
    clw::LLMClient client("your-api-key", "https://api.llm-provider.com/v1");
    // Default 30s timeout leads to clw-llm-timeout

    auto response = client.complete("Explain quantum computing in detail.");
    // Fails with timeout
    std::cout << response.text << std::endl;
    return 0;
}

#include <openclaw/llm_client.h>

int main() {
    clw::LLMClient client("your-api-key", "https://api.llm-provider.com/v1");
    client.set_timeout(120);  // 2 minutes for large models
    client.set_retries(3, 5.0);  // 3 retries, 5s backoff

    auto response = client.complete("Explain quantum computing in detail.");
    if (response.error == clw::Error::None) {
        std::cout << response.text << std::endl;
    } else {
        std::cerr << "Error: " << clw::error_message(response.error) << std::endl;
    }
    return 0;
}

// Sync blocks main thread
auto sync_resp = client.complete(long_prompt);

#include <openclaw/llm_client.h>
#include <future>

std::future<clw::LLMResponse> fut = client.async_complete(long_prompt);
auto resp = fut.get();  // Waits with timeout propagation

export CLW_LLM_TIMEOUT_SEC=180
export CLW_LLM_RETRIES=5
export CLW_HTTP_CONNECT_TIMEOUT=10  # Separate connect timeout
./your_app

client.set_curl_option(CURLOPT_LOW_SPEED_LIMIT, 1024);  // Abort slow transfers
client.set_curl_option(CURLOPT_LOW_SPEED_TIME, 60);

std::string verbose_prompt = "Write a 5000-word essay on...";

std::string optimized_prompt = "Summarize key points on quantum computing (max 500 words):";

#!/bin/bash
for i in {1..10}; do
    echo "Test $i:"
    ./your_app --test-long-prompt | grep -v "clw-llm-timeout"
    if [ $? -eq 0 ]; then echo "PASS"; else echo "FAIL"; fi
done

Test 1: PASS
[INFO] LLM response received in 45s.

TEST(LLMClientTest, TimeoutFix) {
    clw::LLMClient client(/* mock */);
    client.set_timeout(120);
    EXPECT_EQ(client.complete("short").error, clw::Error::None);
}