@robot-resources/openclaw-plugin 0.1.0 → 0.4.0

package/index.js

@@ -1,19 +1,15 @@
 /**
- * Robot Resources Router plugin for OpenClaw.
+ * Robot Resources 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 integrations:
  *
- * 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. Model routing (before_model_resolve): Routes each LLM call through
+ *    the Router at localhost:3838 to select the cheapest capable model.
  *
- * The plugin survives gateway restarts because it lives in
- * ~/.openclaw/extensions/, not in openclaw.json.
+ * 2. Web fetch override (before_tool_call): Intercepts web_fetch calls
+ *    and routes them through the Scraper MCP for token-compressed output.
+ *    The scraper-mcp must be registered in openclaw.json (done by the
+ *    unified installer: npx robot-resources).
  *
  * Install: openclaw plugins install @robot-resources/openclaw-plugin
  * Requires: Robot Resources Router running (npx robot-resources)
@@ -21,24 +17,193 @@
 
 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;
+  }
 }
 
-export { DEFAULT_ROUTER_URL };
+/**
+ * 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,
+  };
+}
+
+const robotResourcesPlugin = {
+  id: 'openclaw-plugin',
+  name: 'Robot Resources',
+  description: 'Cost-optimized model routing + token-compressed web fetching',
+
+  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 });
+
+    // ── Scraper override: intercept web_fetch → use scraper_compress_url ──
+    // When the agent calls web_fetch, redirect to scraper_compress_url for
+    // token-compressed output. Falls through silently if scraper-mcp is not
+    // registered (the tool just won't exist).
+    api.on('before_tool_call', async (event, _ctx) => {
+      if (event.tool !== 'web_fetch') return;
+
+      const url = event.params?.url;
+      if (!url) return;
+
+      api.logger.info(`[robot-resources] Redirecting web_fetch → scraper_compress_url: ${url}`);
+
+      return {
+        toolOverride: 'scraper_compress_url',
+        paramsOverride: {
+          url,
+          mode: 'auto',
+        },
+      };
+    }, { 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,7 +1,7 @@
 {
-  "id": "robot-resources-router",
-  "name": "Robot Resources Router",
-  "description": "Cost-optimized AI model routing — selects the cheapest capable model per request",
+  "id": "openclaw-plugin",
+  "name": "Robot Resources",
+  "description": "Cost-optimized model routing + token-compressed web fetching",
   "providers": ["robot-resources"],
   "configSchema": {
     "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robot-resources/openclaw-plugin",
-  "version": "0.1.0",
+  "version": "0.4.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"
   }