@robot-resources/openclaw-plugin 0.1.0 → 0.3.0

package/index.js

@@ -1,19 +1,18 @@
 /**
  * Robot Resources Router plugin for OpenClaw.
  *
- * Routes requests through the local Robot Resources Router for
- * cost-optimized model selection. The Router picks the cheapest
- * capable model per request via keyword/LLM confidence branching.
+ * Two routing modes depending on auth:
  *
- * Architecture:
- * - Plugin registers "robot-resources" as a provider (via manifest)
- * - before_model_resolve hook overrides provider to "robot-resources"
- * - OpenClaw sends requests to Router at localhost:3838
- * - Router selects optimal model, forwards to upstream provider
- * - Response flows back through OpenClaw transparently
+ * 1. API-key users: Registers "robot-resources" as a provider that proxies
+ *    requests through the Router at localhost:3838. Works end-to-end.
  *
- * The plugin survives gateway restarts because it lives in
- * ~/.openclaw/extensions/, not in openclaw.json.
+ * 2. Subscription (OAuth) users: Uses `message_received` hook to ask the
+ *    Router's /v1/route endpoint for the cheapest model, then logs the
+ *    recommendation. Full modelOverride requires a `before_model_select`
+ *    hook that the OpenClaw plugin SDK does not yet provide.
+ *
+ *    LIMITATION: `message_received` only fires for channel messages
+ *    (Telegram, Slack, etc.), NOT for `openclaw agent --local` CLI mode.
  *
  * Install: openclaw plugins install @robot-resources/openclaw-plugin
  * Requires: Robot Resources Router running (npx robot-resources)
@@ -21,24 +20,172 @@
 
 const DEFAULT_ROUTER_URL = 'http://localhost:3838';
 
-export default function register(api) {
-  const pluginConfig = api.config || {};
-  const routerUrl = pluginConfig.routerUrl || DEFAULT_ROUTER_URL;
+const ROUTER_MODELS = [
+  'claude-sonnet-4-20250514',
+  'claude-haiku-4-5-20251001',
+  'claude-opus-4-20250514',
+];
 
-  // Register provider with Router's baseUrl
-  if (typeof api.registerProvider === 'function') {
-    api.registerProvider('robot-resources', {
-      baseUrl: routerUrl,
-      api: 'anthropic-messages',
-    });
-  }
+/**
+ * Ask the Router which model is cheapest for this prompt.
+ * Returns { provider, model, savings } or null on failure.
+ */
+async function askRouter(routerUrl, prompt, providers = null) {
+  try {
+    const body = { prompt };
+    if (providers) body.providers = providers;
 
-  // Override model resolution to route through Robot Resources
-  api.on('before_model_resolve', (_event, _ctx) => {
+    const resp = await fetch(`${routerUrl}/v1/route`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(3000),
+    });
+    if (!resp.ok) return null;
+    const data = await resp.json();
     return {
-      providerOverride: 'robot-resources',
+      provider: data.provider || 'anthropic',
+      model: data.model || null,
+      savings: data.savings_percent || 0,
     };
-  }, { priority: 10 });
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Detect if OpenClaw is using subscription/OAuth auth.
+ */
+function detectSubscriptionMode(config) {
+  const profiles = config?.auth?.profiles;
+  if (profiles && typeof profiles === 'object') {
+    for (const profile of Object.values(profiles)) {
+      if (profile?.mode === 'token') return true;
+    }
+  }
+  if (config?.gateway?.auth?.mode === 'token') return true;
+  return false;
+}
+
+function buildModelDefinition(modelId) {
+  return {
+    id: modelId,
+    name: modelId,
+    api: 'anthropic-messages',
+    reasoning: false,
+    input: ['text', 'image'],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 200_000,
+    maxTokens: 8192,
+  };
 }
 
-export { DEFAULT_ROUTER_URL };
+const robotResourcesPlugin = {
+  id: 'openclaw-plugin',
+  name: 'Robot Resources Router',
+  description: 'Cost-optimized AI model routing — selects the cheapest capable model per request',
+
+  register(api) {
+    const pluginConfig = api.pluginConfig || {};
+    const routerUrl = pluginConfig.routerUrl || DEFAULT_ROUTER_URL;
+    const isSubscription = detectSubscriptionMode(api.config);
+
+    if (isSubscription) {
+      api.logger.info('[robot-resources] Subscription mode detected — routing restricted to Anthropic models');
+    }
+
+    // ── Model routing: before_model_resolve hook ──
+    // Fires before model selection. Returns { modelOverride, providerOverride }
+    // to redirect to the cheapest capable model via the Router.
+    // Works in ALL modes: CLI, channels, subagents.
+    const providers = isSubscription ? ['anthropic'] : null;
+    let lastRouting = null;
+
+    api.on('before_model_resolve', async (event, _ctx) => {
+      const prompt = event.prompt || '';
+      if (!prompt) return;
+
+      const decision = await askRouter(routerUrl, prompt, providers);
+      if (!decision?.model) return;
+
+      lastRouting = decision;
+      api.logger.info(
+        `[robot-resources] Routing: ${decision.model} (${decision.savings}% savings)`,
+      );
+
+      return {
+        modelOverride: decision.model,
+        providerOverride: decision.provider,
+      };
+    }, { priority: 10 });
+
+    // ── Append routing tag to outgoing messages ──
+    api.on('message_sending', (event, _ctx) => {
+      if (!lastRouting) return;
+      const tag = `\n\n⚡ _Routed → ${lastRouting.model} (${lastRouting.savings}% savings)_`;
+      lastRouting = null;
+      return { content: event.content + tag };
+    }, { priority: -10 });
+
+    // ── API-key mode: register provider for HTTP proxy ──
+    api.registerProvider({
+      id: 'robot-resources',
+      label: 'Robot Resources',
+      docsPath: '/providers/models',
+      auth: [
+        {
+          id: 'local',
+          label: 'Local Router proxy',
+          hint: 'Route requests through the Robot Resources Router for cost optimization',
+          kind: 'custom',
+          async run(ctx) {
+            const baseUrlInput = await ctx.prompter.text({
+              message: 'Robot Resources Router URL',
+              initialValue: routerUrl,
+              validate: (value) => {
+                try { new URL(value); } catch { return 'Enter a valid URL'; }
+                return undefined;
+              },
+            });
+
+            const baseUrl = baseUrlInput.trim().replace(/\/+$/, '');
+
+            return {
+              profiles: [
+                {
+                  profileId: 'robot-resources:local',
+                  credential: {
+                    type: 'token',
+                    provider: 'robot-resources',
+                    token: 'n/a',
+                  },
+                },
+              ],
+              configPatch: {
+                models: {
+                  providers: {
+                    'robot-resources': {
+                      baseUrl,
+                      apiKey: 'n/a',
+                      api: 'anthropic-messages',
+                      authHeader: false,
+                      models: ROUTER_MODELS.map(buildModelDefinition),
+                    },
+                  },
+                },
+              },
+              defaultModel: `robot-resources/${ROUTER_MODELS[0]}`,
+              notes: [
+                'Robot Resources Router must be running (npx robot-resources).',
+                'Requests are routed through localhost:3838 for cost optimization.',
+              ],
+            };
+          },
+        },
+      ],
+    });
+  },
+};
+
+export default robotResourcesPlugin;
+export { DEFAULT_ROUTER_URL, ROUTER_MODELS, askRouter, detectSubscriptionMode };

package/openclaw.plugin.json

@@ -1,5 +1,5 @@
 {
-  "id": "robot-resources-router",
+  "id": "openclaw-plugin",
   "name": "Robot Resources Router",
   "description": "Cost-optimized AI model routing — selects the cheapest capable model per request",
   "providers": ["robot-resources"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robot-resources/openclaw-plugin",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Robot Resources Router plugin for OpenClaw — cost-optimized AI model routing",
   "type": "module",
   "main": "index.js",
@@ -27,6 +27,11 @@
     "directory": "packages/openclaw-plugin"
   },
   "license": "MIT",
+  "openclaw": {
+    "extensions": [
+      "./index.js"
+    ]
+  },
   "devDependencies": {
     "vitest": "^3.0.0"
   }