feat: add OpenRouter as a model provider

Wires OpenRouter alongside GitHub Copilot in /provider_model. Chat and
model-list calls dispatch by provider; Copilot's 24-min token refresh is
gated so OpenRouter sessions don't trigger it. API key comes from
OPENROUTER_API_KEY env var if set, otherwise prompted once and saved to
config.json. /model skips the Copilot per-model test-ping loop for
OpenRouter since each call is billed.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: lzwjava

README.md

@@ -14,7 +14,8 @@ A minimal [openclaw](https://github.com/lzwjava/openclaw) implementation, built
 
 ## Features
 
-- **Multi-turn conversations** with GitHub Copilot in your terminal.
+- **Multi-turn conversations** with GitHub Copilot or OpenRouter in your terminal.
+- **Multiple Model Providers**: GitHub Copilot (OAuth) and OpenRouter (API key).
 - **Native Tool Calling**: The model can autonomously invoke web search, execute shell commands, and edit files.
 - **Multiple Search Providers**: DuckDuckGo (default), Startpage, Bing, and Tavily.
 - **GitHub OAuth device flow** authentication.
@@ -41,11 +42,12 @@ pip install -e .
    iclaw
    ```
 
-2. **Authenticate with GitHub** (on first run):
+2. **Authenticate** (on first run):
    ```
    /provider_model
    ```
-   Select `copilot`, then follow the GitHub device authorization flow. Your token is saved to `~/.config/iclaw/config.json`.
+   - **Copilot**: select option 1, follow the GitHub device authorization flow. Your token is saved to `~/.config/iclaw/config.json`.
+   - **OpenRouter**: select option 2. iclaw reads `OPENROUTER_API_KEY` from the environment, or prompts for a key and saves it to `~/.config/iclaw/config.json`.
 
 ### CLI Commands
 - `/provider_model`: Select and authenticate with the model provider.

iclaw/commands/model.py

@@ -1,12 +1,27 @@
 import sys
 import concurrent.futures
 from iclaw.github_api import get_models, get_copilot_token
+from iclaw.providers import openrouter
 from iclaw.commands.auth import handle_login_command
 from iclaw.commands.test_models import test_model
+from iclaw.config import load_openrouter_api_key, save_openrouter_api_key
+
+
+def _prompt_openrouter_key():
+    env_key = load_openrouter_api_key()
+    if env_key:
+        print("Using OPENROUTER_API_KEY from environment.\n")
+        return env_key
+    key = input("Enter OpenRouter API key (stored in config): ").strip()
+    if not key:
+        print("API key cannot be empty.\n")
+        return None
+    save_openrouter_api_key(key)
+    return key
 
 
 def handle_model_provider_command(config_path, current_provider):
-    PROVIDERS = ["copilot", "others"]
+    PROVIDERS = ["copilot", "openrouter"]
     print(f"\nCurrent model provider: {current_provider}")
     print("Available model providers:")
     for i, p in enumerate(PROVIDERS, 1):
@@ -17,31 +32,39 @@ def handle_model_provider_command(config_path, current_provider):
     if not choice:
         return current_provider, None
 
-    if choice.isdigit():
-        n = int(choice)
-        if 1 <= n <= len(PROVIDERS):
-            provider = PROVIDERS[n - 1]
-            if provider == "copilot":
-                github_token = handle_login_command(config_path)
-                if github_token:
-                    try:
-                        copilot_token = get_copilot_token(github_token)
-                        print("Connected to GitHub Copilot.\n")
-                        return provider, copilot_token
-                    except Exception as e:
-                        print(f"Error: {e}", file=sys.stderr)
-            else:
-                print(f"{provider} not implemented yet.\n")
-        else:
-            print("Invalid selection.\n")
-    return current_provider, None
+    if not choice.isdigit():
+        print("Invalid selection.\n")
+        return current_provider, None
 
+    n = int(choice)
+    if not (1 <= n <= len(PROVIDERS)):
+        print("Invalid selection.\n")
+        return current_provider, None
 
-def handle_model_command(copilot_token, current_model):
-    if not copilot_token:
-        print("Not authenticated with any model provider.\n", file=sys.stderr)
-        return current_model
+    provider = PROVIDERS[n - 1]
+    if provider == "copilot":
+        github_token = handle_login_command(config_path)
+        if not github_token:
+            return current_provider, None
+        try:
+            token = get_copilot_token(github_token)
+            print("Connected to GitHub Copilot.\n")
+            return provider, token
+        except Exception as e:
+            print(f"Error: {e}", file=sys.stderr)
+            return current_provider, None
 
+    if provider == "openrouter":
+        key = _prompt_openrouter_key()
+        if not key:
+            return current_provider, None
+        print("OpenRouter configured.\n")
+        return provider, key
+
+    return current_provider, None
+
+
+def _handle_copilot_model(copilot_token, current_model):
     try:
         model_data = get_models(copilot_token)
     except Exception as e:
@@ -57,49 +80,95 @@ def handle_model_command(copilot_token, current_model):
         working_models = []
         completed = 0
         for future in concurrent.futures.as_completed(futures):
-            model_id, works = future.result()
+            _model_id, works = future.result()
             if works:
                 working_models.append(futures[future])
             completed += 1
             pct = int(completed * 100 / total)
             print(f"\r{pct}% ({completed}/{total})", end="", flush=True)
     print()
 
-    groups = {}
-    for m in working_models:
-        owner = m.get("owned_by", "unknown")
-        groups.setdefault(owner, []).append(m["id"])
+    return _select_from_models(working_models, current_model, group_key="owned_by")
 
-    flat_models = [m["id"] for m in working_models]
+
+def _handle_openrouter_model(api_key, current_model):
+    try:
+        model_data = openrouter.get_models(api_key)
+    except Exception as e:
+        print(f"Error fetching models: {e}\n", file=sys.stderr)
+        return current_model
+    return _select_from_models(model_data, current_model, group_key=None)
+
+
+def _select_from_models(models, current_model, group_key):
+    if not models:
+        print("No models available.\n")
+        return current_model
+
+    flat_ids = [m["id"] for m in models]
     print(f"\nCurrent model: {current_model}")
     print("Available models:")
 
     idx = 1
     model_index = {}
-    for owner, ids in groups.items():
-        print(f"  [{owner}]")
-        for mid in ids:
+
+    if group_key:
+        groups = {}
+        for m in models:
+            groups.setdefault(m.get(group_key, "unknown"), []).append(m["id"])
+        for owner, ids in groups.items():
+            print(f"  [{owner}]")
+            for mid in ids:
+                marker = "*" if mid == current_model else " "
+                print(f"  {marker} {idx}. {mid}")
+                model_index[idx] = mid
+                idx += 1
+    else:
+        for mid in flat_ids:
             marker = "*" if mid == current_model else " "
             print(f"  {marker} {idx}. {mid}")
             model_index[idx] = mid
             idx += 1
 
     try:
         choice = input("Select model (number or name, Enter to keep current): ").strip()
-        if choice:
-            if choice.isdigit():
-                n = int(choice)
-                if n in model_index:
-                    print(f"Model set to: {model_index[n]}\n")
-                    return model_index[n]
-                else:
-                    print("Invalid selection.\n")
-            elif choice in flat_models:
-                print(f"Model set to: {choice}\n")
-                return choice
-            else:
-                print(f"Unknown model '{choice}'. Keeping {current_model}\n")
+        if not choice:
+            return current_model
+        if choice.isdigit():
+            n = int(choice)
+            if n in model_index:
+                print(f"Model set to: {model_index[n]}\n")
+                return model_index[n]
+            print("Invalid selection.\n")
+            return current_model
+        if choice in flat_ids:
+            print(f"Model set to: {choice}\n")
+            return choice
+        print(f"Unknown model '{choice}'. Keeping {current_model}\n")
     except (EOFError, KeyboardInterrupt):
         print()
+    return current_model
+
+
+def handle_model_command(provider_or_token, token_or_model, current_model=None):
+    """Dispatch model selection by provider.
 
+    Two call styles are accepted:
+      handle_model_command(provider, token, current_model)  — new, preferred
+      handle_model_command(copilot_token, current_model)    — legacy Copilot-only
+    """
+    if current_model is None:
+        copilot_token, current_model = provider_or_token, token_or_model
+        provider, token = "copilot", copilot_token
+    else:
+        provider, token = provider_or_token, token_or_model
+
+    if not token:
+        print("Not authenticated with any model provider.\n", file=sys.stderr)
+        return current_model
+    if provider == "copilot":
+        return _handle_copilot_model(token, current_model)
+    if provider == "openrouter":
+        return _handle_openrouter_model(token, current_model)
+    print(f"Unknown provider: {provider}\n", file=sys.stderr)
     return current_model

iclaw/config.py

@@ -25,6 +25,18 @@ def load_github_token():
     return _load_config().get("github_token")
 
 
+def load_openrouter_api_key():
+    return os.environ.get("OPENROUTER_API_KEY") or _load_config().get(
+        "openrouter_api_key"
+    )
+
+
+def save_openrouter_api_key(api_key):
+    config = _load_config()
+    config["openrouter_api_key"] = api_key
+    _save_config(config)
+
+
 def load_session_settings() -> dict:
     config = _load_config()
     return {