@rungate/llmrouter 0.1.0 → 0.1.2

package/README.md

@@ -35,6 +35,12 @@ openclaw plugins install @rungate/llmrouter
 openclaw gateway restart
 ```
 
+Or use the installer script from this repo:
+
+```bash
+bash scripts/install-openclaw.sh
+```
+
 Recommended production environment:
 
 ```bash
@@ -44,6 +50,8 @@ X402_NETWORK=eip155:8453
 
 `llm_router` remains local-only in this setup. OpenClaw still talks to the local proxy at `http://127.0.0.1:3000/v1`; the remote upstream is configured by environment.
 
+If `INFERENCE_PROVIDER_BASE_URL` is unset, the router defaults to `https://api.rungate.ai`.
+
 ## Local OpenClaw Install
 
 For local unpublished development, install from a packaged tarball:
@@ -61,8 +69,12 @@ For Docker/tempclaw-style testing, stage the tarball into the container and inst
 openclaw plugins install /staging/rungate-llmrouter-0.1.0.tgz
 ```
 
+The installer script is for real OpenClaw installs, not tempclaw. Tempclaw should keep using the explicit install flow so restart and verification stay visible.
+
 ## Environment
 
+For local development, override the production default upstream:
+
 ```bash
 LLM_ROUTER_HOST=127.0.0.1
 LLM_ROUTER_PORT=3000
@@ -70,20 +82,14 @@ INFERENCE_PROVIDER_BASE_URL=http://127.0.0.1:8787
 X402_NETWORK=eip155:84532
 ```
 
-For production, point the upstream at Rungate and use Base mainnet:
-
-```bash
-INFERENCE_PROVIDER_BASE_URL=https://api.rungate.ai
-X402_NETWORK=eip155:8453
-```
-
 ## OpenClaw Models
 
 - `llmrouter/auto`
 - `llmrouter/simple`
 - `llmrouter/coding`
 - `llmrouter/reasoning`
-- `llmrouter/vision`
+
+Image requests still route automatically to the vision-capable upstream model through `llmrouter/auto`.
 
 ## Release Workflow
 

package/dist/src/openclaw/config.js

@@ -3,7 +3,6 @@ const MODEL_LIST = [
     { id: 'simple', name: 'LLM Router Simple', reasoning: false },
     { id: 'coding', name: 'LLM Router Coding', reasoning: true },
     { id: 'reasoning', name: 'LLM Router Reasoning', reasoning: true },
-    { id: 'vision', name: 'LLM Router Vision', reasoning: true },
 ];
 // Inject the provider block and default model so OpenClaw can talk to the local proxy.
 export function ensureOpenClawProviderConfig(config, baseUrl) {
@@ -29,10 +28,18 @@ export function ensureOpenClawProviderConfig(config, baseUrl) {
     const agents = config.agents ?? {};
     const defaults = agents.defaults ?? {};
     const modelConfig = defaults.model ?? {};
+    const allowedModels = defaults.models ?? {};
     if (typeof modelConfig.primary !== 'string' || modelConfig.primary.length === 0) {
         modelConfig.primary = 'llmrouter/auto';
     }
+    for (const model of MODEL_LIST) {
+        const key = `llmrouter/${model.id}`;
+        if (!(key in allowedModels)) {
+            allowedModels[key] = {};
+        }
+    }
     defaults.model = modelConfig;
+    defaults.models = allowedModels;
     agents.defaults = defaults;
     config.agents = agents;
 }

package/dist/src/proxy/server.js

@@ -95,6 +95,51 @@ function copyResponseHeaders(upstream, res) {
         res.setHeader(key, value);
     }
 }
+function isRetryableUpstreamResponse(response) {
+    return response.status === 404 || response.status === 408 || response.status === 409 || response.status === 425
+        || response.status === 429 || response.status >= 500;
+}
+async function collectResponseText(response) {
+    try {
+        return await response.clone().text();
+    }
+    catch {
+        return '';
+    }
+}
+async function tryUpstreamModels(req, upstreamBaseUrl, payFetch, body, candidateModels) {
+    const attempts = [];
+    for (const model of candidateModels) {
+        const upstreamBody = {
+            ...body,
+            model,
+        };
+        try {
+            const response = await payFetch(new URL('/v1/chat/completions', upstreamBaseUrl), {
+                method: 'POST',
+                headers: {
+                    ...copyRequestHeaders(req),
+                    'content-type': 'application/json',
+                },
+                body: JSON.stringify(upstreamBody),
+            });
+            const attempt = { model, response };
+            attempts.push(attempt);
+            if (!isRetryableUpstreamResponse(response) || model === candidateModels[candidateModels.length - 1]) {
+                return { attempt, attempts };
+            }
+        }
+        catch (error) {
+            const attempt = { model, error };
+            attempts.push(attempt);
+            if (model === candidateModels[candidateModels.length - 1]) {
+                return { attempt, attempts };
+            }
+        }
+    }
+    const attempt = attempts[attempts.length - 1] ?? { model: body.model, error: new Error('No upstream attempt executed') };
+    return { attempt, attempts };
+}
 // Handle the only routed endpoint in this minimal version: chat completions.
 async function handleChat(req, res, upstreamBaseUrl, payFetch) {
     const raw = await collectBody(req);
@@ -105,10 +150,7 @@ async function handleChat(req, res, upstreamBaseUrl, payFetch) {
     }
     const normalizedLatestUser = normalizeLatestUserMessageForRouting(body);
     const decision = routeRequest(toRouterRequest(normalizedLatestUser.body));
-    const upstreamBody = {
-        ...body,
-        model: decision.resolvedModel,
-    };
+    const { attempt, attempts } = await tryUpstreamModels(req, upstreamBaseUrl, payFetch, body, decision.candidateModels);
     console.info(JSON.stringify({
         component: 'llm_router',
         event: 'route_request',
@@ -118,23 +160,38 @@ async function handleChat(req, res, upstreamBaseUrl, payFetch) {
         logicalModel: decision.logicalModel,
         category: decision.category,
         resolvedModel: decision.resolvedModel,
+        candidateModels: decision.candidateModels,
+        attemptedModels: attempts.map((current) => current.model),
         reason: decision.reason,
         hasTools: decision.hasTools,
         wantsJson: decision.wantsJson,
         hasImage: decision.hasImage,
     }));
-    const upstreamResponse = await payFetch(new URL('/v1/chat/completions', upstreamBaseUrl), {
-        method: 'POST',
-        headers: {
-            ...copyRequestHeaders(req),
-            'content-type': 'application/json',
-        },
-        body: JSON.stringify(upstreamBody),
-    });
+    if (attempt.error) {
+        throw attempt.error;
+    }
+    const upstreamResponse = attempt.response;
+    if (!upstreamResponse) {
+        throw new Error('Upstream returned no response');
+    }
+    if (attempts.length > 1) {
+        console.info(JSON.stringify({
+            component: 'llm_router',
+            event: 'route_fallback_result',
+            requestPath: req.url ?? '/v1/chat/completions',
+            finalModel: attempt.model,
+            attempts: await Promise.all(attempts.map(async (current) => ({
+                model: current.model,
+                status: current.response?.status,
+                error: current.error instanceof Error ? current.error.message : undefined,
+                bodyPreview: current.response ? (await collectResponseText(current.response)).slice(0, 200) : undefined,
+            }))),
+        }));
+    }
     copyResponseHeaders(upstreamResponse, res);
     res.setHeader('x-llm-router-logical-model', decision.logicalModel);
     res.setHeader('x-llm-router-category', decision.category);
-    res.setHeader('x-llm-router-resolved-model', decision.resolvedModel);
+    res.setHeader('x-llm-router-resolved-model', attempt.model);
     res.statusCode = upstreamResponse.status;
     if (!upstreamResponse.body) {
         res.end();
@@ -146,7 +203,7 @@ async function handleChat(req, res, upstreamBaseUrl, payFetch) {
 export async function startProxyServer(options = {}) {
     const host = options.host ?? process.env.LLM_ROUTER_HOST ?? '127.0.0.1';
     const port = options.port ?? Number(process.env.LLM_ROUTER_PORT ?? 3000);
-    const upstreamBaseUrl = options.upstreamBaseUrl ?? process.env.INFERENCE_PROVIDER_BASE_URL ?? 'http://127.0.0.1:8787';
+    const upstreamBaseUrl = options.upstreamBaseUrl ?? process.env.INFERENCE_PROVIDER_BASE_URL ?? 'https://api.rungate.ai';
     const payFetch = createPaymentFetch(fetch, process.env);
     const server = createServer(async (req, res) => {
         try {

package/dist/src/router/models.d.ts

@@ -1,4 +1,5 @@
 import type { RouteCategory } from '../types.js';
-export declare const LOGICAL_MODELS: readonly ["llmrouter/auto", "llmrouter/simple", "llmrouter/coding", "llmrouter/reasoning", "llmrouter/vision"];
+export declare const LOGICAL_MODELS: readonly ["llmrouter/auto", "llmrouter/simple", "llmrouter/coding", "llmrouter/reasoning"];
+export declare const CATEGORY_MODEL_CANDIDATES: Record<RouteCategory, string[]>;
 export declare const CATEGORY_MODEL_MAP: Record<RouteCategory, string>;
 export declare function logicalModelToCategory(model: string): RouteCategory | undefined;

package/dist/src/router/models.js

@@ -3,14 +3,34 @@ export const LOGICAL_MODELS = [
     'llmrouter/simple',
     'llmrouter/coding',
     'llmrouter/reasoning',
-    'llmrouter/vision',
 ];
-export const CATEGORY_MODEL_MAP = {
-    simple: 'deepseek/deepseek-chat',
-    coding: 'qwen/qwen3-coder-next',
-    reasoning: 'deepseek/deepseek-v3.2',
-    vision: 'qwen/qwen3-vl-235b-a22b-thinking',
+export const CATEGORY_MODEL_CANDIDATES = {
+    simple: [
+        'deepseek/deepseek-chat',
+        'xiaomi/mimo-v2-flash',
+        'minimax/minimax-m2.1',
+        'deepseek/deepseek-chat-v3.1',
+        'deepseek/deepseek-chat-v3-0324',
+    ],
+    coding: [
+        'qwen/qwen3-coder-next',
+        'deepseek/deepseek-v3.2',
+        'openai/gpt-oss-120b',
+        'moonshotai/kimi-k2.5',
+    ],
+    reasoning: [
+        'deepseek/deepseek-v3.2',
+        'deepseek/deepseek-r1',
+        'deepseek/deepseek-r1-0528',
+        'qwen/qwen3-235b-a22b-thinking-2507',
+        'moonshotai/kimi-k2.5',
+        'moonshotai/kimi-k2-0905',
+        'z-ai/glm-5',
+        'minimax/minimax-m2.5',
+    ],
+    vision: ['qwen/qwen3-vl-235b-a22b-thinking'],
 };
+export const CATEGORY_MODEL_MAP = Object.fromEntries(Object.entries(CATEGORY_MODEL_CANDIDATES).map(([category, models]) => [category, models[0]]));
 // Map logical OpenClaw-facing model names to fixed route categories.
 export function logicalModelToCategory(model) {
     if (model === 'llmrouter/simple' || model === 'simple')
@@ -19,8 +39,6 @@ export function logicalModelToCategory(model) {
         return 'coding';
     if (model === 'llmrouter/reasoning' || model === 'reasoning')
         return 'reasoning';
-    if (model === 'llmrouter/vision' || model === 'vision')
-        return 'vision';
     if (model === 'llmrouter/auto' || model === 'auto')
         return undefined;
     return undefined;

package/dist/src/router/route.js

@@ -1,5 +1,5 @@
 import { classifyPrompt, requestSignals } from './classify.js';
-import { CATEGORY_MODEL_MAP, logicalModelToCategory } from './models.js';
+import { CATEGORY_MODEL_CANDIDATES, CATEGORY_MODEL_MAP, logicalModelToCategory } from './models.js';
 function forcedClassification(request, category) {
     return {
         category,
@@ -17,6 +17,7 @@ export function routeRequest(request) {
         logicalModel: request.model,
         category: classification.category,
         resolvedModel: CATEGORY_MODEL_MAP[classification.category],
+        candidateModels: CATEGORY_MODEL_CANDIDATES[classification.category],
         reason: classification.reason,
         hasTools: classification.hasTools,
         wantsJson: classification.wantsJson,

package/dist/src/types.d.ts

@@ -49,6 +49,7 @@ export type RouteDecision = {
     logicalModel: string;
     category: RouteCategory;
     resolvedModel: string;
+    candidateModels: string[];
     reason: string;
     hasTools: boolean;
     wantsJson: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rungate/llmrouter",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",