@opencompress/openclaw 3.0.0 → 3.0.2

package/README.md

@@ -1,108 +1,214 @@
-# OpenCompress Plugin for OpenClaw
+<p align="center">
+  <br />
+  <br />
+  <strong><code>🗜️ OpenCompress</code></strong>
+  <br />
+  <em>for OpenClaw</em>
+  <br />
+  <br />
+</p>
 
-Compress every LLM call automatically — keep your existing provider, same models, same quality, **40-70% cheaper**.
+<h3 align="center">Your keys. Your models. Fewer tokens. Better quality.</h3>
 
-## How it works
+<br />
 
-```
-Your Agent → OpenCompress (compress) → Your LLM Provider (OpenAI/Anthropic/OpenRouter/Google)
-```
+<p align="center">
+  <a href="https://www.npmjs.com/package/@opencompress/openclaw"><img src="https://img.shields.io/npm/v/@opencompress/openclaw?style=flat-square&color=000&label=npm" alt="npm" /></a>
+  &nbsp;
+  <a href="https://github.com/open-compress/opencompress-openclaw"><img src="https://img.shields.io/github/stars/open-compress/opencompress-openclaw?style=flat-square&color=000&label=stars" alt="stars" /></a>
+  &nbsp;
+  <a href="https://github.com/open-compress/opencompress-openclaw/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-000?style=flat-square" alt="license" /></a>
+  &nbsp;
+  <a href="https://openclaw.ai"><img src="https://img.shields.io/badge/OpenClaw-plugin-000?style=flat-square" alt="OpenClaw" /></a>
+</p>
 
-You already pay for an LLM provider. OpenCompress adds a compression layer on top — your prompts are compressed through a 5-layer pipeline before reaching your provider. You pay your provider at their normal rates, and we charge only **20% of what you save**.
+<br />
 
-- **53%** average input token reduction
-- **62%** latency improvement
-- **96%** quality preservation (SQuALITY benchmark)
+---
 
-## Install
+<p align="center">
+OpenCompress is an <a href="https://openclaw.ai">OpenClaw</a> plugin that optimizes LLM input and output using a state-of-the-art multi-stage compression pipeline. It reduces token usage and improves response quality, automatically, on every call. Works with any provider you already use: Anthropic, OpenAI, Google, OpenRouter, and any OpenAI-compatible API.
+</p>
+
+---
+
+<br />
+
+We don't sell tokens. We don't resell API access.
+
+You use your own keys, your own models, your own account. Billed directly by Anthropic, OpenAI, or whoever you choose. We compress the traffic so you get charged less and your agent thinks clearer.
+
+Compression doesn't just save money. It removes the noise. Leaner prompts mean the model focuses on what matters. Shorter context, better answers, better code.
+
+No vendor lock-in. Uninstall anytime. Everything goes back to exactly how it was.
+
+<br />
+
+---
+
+<br />
+
+### How it works
 
-```bash
-openclaw plugins install @opencompress/opencompress
 ```
+              ┌──────────────────────────────┐
+              │     Your OpenClaw Agent      │
+              │                              │
+              │   model: opencompress/auto   │
+              └──────────────┬───────────────┘
+                             │
+                             ▼
+              ┌──────────────────────────────┐
+              │     Local Proxy (:8401)      │
+              │                              │
+              │   reads your provider key    │
+              │   from OpenClaw config       │
+              └──────────────┬───────────────┘
+                             │
+                             ▼
+              ┌──────────────────────────────┐
+              │     opencompress.ai          │
+              │                              │
+              │   compress → forward         │
+              │   your key in header         │
+              │   never stored               │
+              └──────────────┬───────────────┘
+                             │
+                             ▼
+              ┌──────────────────────────────┐
+              │     Your LLM Provider        │
+              │     (Anthropic / OpenAI)     │
+              │                              │
+              │   sees fewer tokens          │
+              │   charges you less           │
+              └──────────────────────────────┘
+```
+
+<br />
 
-## Setup
+---
 
-### 1. Connect your LLM key
+<br />
 
-After installing, run onboard and connect your existing provider key:
+### Install
 
 ```bash
+openclaw plugins install @opencompress/openclaw
 openclaw onboard opencompress
+openclaw gateway restart
 ```
 
-The wizard auto-provisions your account ($1.00 free credit) and asks for your upstream LLM key. Supported providers:
+Select **`opencompress/auto`** as your model. Done.
 
-| Key prefix | Provider |
-|---|---|
-| `sk-proj-` or `sk-` | OpenAI |
-| `sk-ant-` | Anthropic |
-| `sk-or-` | OpenRouter |
-| `AIza...` | Google AI |
+<br />
 
-Once connected, every LLM call is compressed automatically — you pay your provider directly, we only charge the compression fee.
+### Models
 
-> Don't have an LLM key? No problem — we can route through OpenRouter for you. Just skip the key step during onboard.
-
-### 2. Use it
-
-Switch to the OpenCompress provider:
+Every provider you already have gets a compressed mirror:
 
 ```
-/model opencompress/gpt-4o-mini
+opencompress/auto                          → your default, compressed
+opencompress/anthropic/claude-sonnet-4     → Claude Sonnet, compressed
+opencompress/anthropic/claude-opus-4-6     → Claude Opus, compressed
+opencompress/openai/gpt-5.4               → GPT-5.4, compressed
 ```
 
-That's it. Same model IDs as your current provider — no config changes needed.
+Switch back to the original model anytime to disable compression.
+
+<br />
 
-### 3. Connect or switch your key anytime
+### Commands
 
 ```
-/compress-byok sk-proj-your-openai-key    # Connect OpenAI
-/compress-byok sk-ant-your-anthropic-key   # Connect Anthropic
-/compress-byok sk-or-your-openrouter-key   # Connect OpenRouter
-/compress-byok off                         # Switch back to router mode
+/compress-stats    view savings, balance, token metrics
+/compress          show status and available models
 ```
 
-## Commands
+<br />
 
-| Command | Description |
-|---------|-------------|
-| `/compress-stats` | Show compression savings (calls, tokens saved, cost saved) |
-| `/compress-byok <key>` | Connect or switch your LLM provider key |
-| `/compress-byok off` | Disconnect your key (switch to router fallback) |
+---
 
-## Supported models (20)
+<br />
 
-Works with all major providers — use whichever models you already use:
+### What we believe
 
-| Provider | Models |
-|----------|--------|
-| **OpenAI** | `gpt-4o`, `gpt-4o-mini`, `gpt-4.1`, `gpt-4.1-mini`, `gpt-4.1-nano`, `o3`, `o4-mini` |
-| **Anthropic** | `claude-sonnet-4-6`, `claude-opus-4-6`, `claude-haiku-4-5-20251001` |
-| **Google** | `gemini-2.5-pro`, `gemini-2.5-flash`, `google/gemini-2.5-pro-preview` |
-| **DeepSeek** | `deepseek/deepseek-chat-v3-0324`, `deepseek/deepseek-reasoner` |
-| **Meta** | `meta-llama/llama-4-maverick`, `meta-llama/llama-4-scout` |
-| **Qwen** | `qwen/qwen3-235b-a22b`, `qwen/qwen3-32b` |
-| **Mistral** | `mistralai/mistral-large-2411` |
+<table>
+<tr>
+<td width="50%">
 
-## Pricing
+**Your keys are yours.**
 
-You pay your LLM provider directly at their normal rates. OpenCompress charges **20% of the tokens you save** — if compression saves you $1.00 in tokens, you pay us $0.20. Net saving: **$0.80**.
+We read your API key from OpenClaw's config at runtime, pass it in a per-request header, and discard it immediately. We never store, log, or cache your provider credentials. Ever.
 
-$1.00 free credit on sign-up covers ~50-100 compressed calls.
+</td>
+<td width="50%">
 
-## Configuration
+**Your prompts are yours.**
 
-| Key | Default | Description |
-|-----|---------|-------------|
-| `apiKey` | — | Your `sk-occ-...` key (set during onboard) |
-| `baseUrl` | `https://www.opencompress.ai/api` | Custom API endpoint |
+Prompts are compressed in-memory and forwarded. Nothing is stored, logged, or used for training. The only thing we record is token counts for billing, original vs compressed. That's it.
 
-## Uninstall
+</td>
+</tr>
+<tr>
+<td>
 
-```bash
-openclaw plugins uninstall opencompress
+**Zero lock-in.**
+
+We don't replace your provider. We don't wrap your billing. If you uninstall, your agents keep working exactly as before. Same keys, same models, same everything.
+
+</td>
+<td>
+
+**Failure is invisible.**
+
+If our service goes down, your requests fall back directly to your provider. No errors, no downtime, no interruption. You just temporarily lose the compression savings.
+
+</td>
+</tr>
+</table>
+
+<br />
+
+---
+
+<br />
+
+### Supported providers
+
+```
+Anthropic    Claude Sonnet, Opus, Haiku          anthropic-messages
+OpenAI       GPT-5.x, o-series                   openai-completions
+Google       Gemini                               openai-compat
+OpenRouter   400+ models                          openai-completions
+Any          OpenAI-compatible endpoint           openai-completions
 ```
 
-## License
+<br />
+
+### Pricing
+
+Free credit on signup. No credit card. Pay only for the tokens you save.
+
+**[Dashboard →](https://www.opencompress.ai/dashboard)**
+
+<br />
+
+---
+
+<br />
+
+<p align="center">
+  <a href="https://www.opencompress.ai">opencompress.ai</a>
+  &nbsp;&nbsp;·&nbsp;&nbsp;
+  <a href="https://www.npmjs.com/package/@opencompress/openclaw">npm</a>
+  &nbsp;&nbsp;·&nbsp;&nbsp;
+  <a href="https://github.com/open-compress/opencompress-openclaw">github</a>
+</p>
+
+<p align="center">
+  <sub>MIT License · OpenCompress</sub>
+</p>
+
+<br />
 
-MIT
+<!-- SEO: OpenClaw plugin, LLM token compression, save LLM tokens, reduce token cost, prompt compression, token optimization, reduce OpenClaw token usage, save API costs, LLM cost reduction, compress prompts, token savings, reduce AI costs, BYOK compression, OpenAI cost reduction, Anthropic cost reduction, Claude token savings, GPT token optimization, context compression, agentic compression, save money on LLM, reduce LLM bill, compress LLM context, openclaw cost savings -->

package/dist/index.d.ts

@@ -1,9 +1,11 @@
 /**
- * OpenCompress — Save tokens, sharpen quality on every LLM call.
+ * OpenCompress for OpenClaw
  *
  * Registers as an OpenClaw Provider. Users select opencompress/* models.
  * Local HTTP proxy compresses requests via opencompress.ai, then forwards
  * to the user's upstream provider. Keys never leave your machine.
+ *
+ * Auto-provisions API key on first load. No onboard step needed.
  */
 type ModelApi = "openai-completions" | "openai-responses" | "anthropic-messages" | "google-generative-ai";
 type ModelDefinitionConfig = {

package/dist/index.js

@@ -1,11 +1,39 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/config.ts
-var VERSION = "3.0.0";
+var VERSION = "3.0.2";
 var PROXY_PORT = 8401;
 var PROXY_HOST = "127.0.0.1";
 var OCC_API = "https://www.opencompress.ai/api";
 var PROVIDER_ID = "opencompress";
 
 // src/models.ts
+var BUILTIN_PROVIDERS = {
+  anthropic: { baseUrl: "https://api.anthropic.com", api: "anthropic-messages", envVar: "ANTHROPIC_API_KEY" },
+  openai: { baseUrl: "https://api.openai.com", api: "openai-completions", envVar: "OPENAI_API_KEY" },
+  google: { baseUrl: "https://generativelanguage.googleapis.com", api: "google-generative-ai", envVar: "GOOGLE_API_KEY" },
+  xai: { baseUrl: "https://api.x.ai", api: "openai-completions", envVar: "XAI_API_KEY" },
+  deepseek: { baseUrl: "https://api.deepseek.com", api: "openai-completions", envVar: "DEEPSEEK_API_KEY" }
+};
+function resolveBuiltin(providerId) {
+  const builtin = BUILTIN_PROVIDERS[providerId];
+  if (!builtin) return null;
+  const key = process.env[builtin.envVar];
+  if (!key) return null;
+  return {
+    upstreamProvider: providerId,
+    upstreamModel: "",
+    // caller must set
+    upstreamKey: key,
+    upstreamBaseUrl: builtin.baseUrl,
+    upstreamApi: builtin.api
+  };
+}
 function resolveUpstream(modelId, providers) {
   const stripped = modelId.replace(/^opencompress\//, "");
   if (stripped === "auto") {
@@ -21,31 +49,54 @@ function resolveUpstream(modelId, providers) {
         upstreamApi: config2.api || "openai-completions"
       };
     }
+    for (const [id, builtin2] of Object.entries(BUILTIN_PROVIDERS)) {
+      const key = process.env[builtin2.envVar];
+      if (key) {
+        return {
+          upstreamProvider: id,
+          upstreamModel: "",
+          // OpenClaw will set the actual model
+          upstreamKey: key,
+          upstreamBaseUrl: builtin2.baseUrl,
+          upstreamApi: builtin2.api
+        };
+      }
+    }
     return null;
   }
   const slashIdx = stripped.indexOf("/");
   if (slashIdx === -1) {
     const config2 = providers[stripped];
-    if (!config2) return null;
-    return {
-      upstreamProvider: stripped,
-      upstreamModel: config2.models?.[0]?.id || stripped,
-      upstreamKey: config2.apiKey,
-      upstreamBaseUrl: config2.baseUrl,
-      upstreamApi: config2.api || "openai-completions"
-    };
+    if (config2) {
+      return {
+        upstreamProvider: stripped,
+        upstreamModel: config2.models?.[0]?.id || stripped,
+        upstreamKey: config2.apiKey,
+        upstreamBaseUrl: config2.baseUrl,
+        upstreamApi: config2.api || "openai-completions"
+      };
+    }
+    const builtin2 = resolveBuiltin(stripped);
+    if (builtin2) return builtin2;
+    return null;
   }
   const upstreamProvider = stripped.slice(0, slashIdx);
   const upstreamModel = stripped.slice(slashIdx + 1);
   const config = providers[upstreamProvider];
-  if (!config) return null;
-  return {
-    upstreamProvider,
-    upstreamModel,
-    upstreamKey: config.apiKey,
-    upstreamBaseUrl: config.baseUrl,
-    upstreamApi: config.api || "openai-completions"
-  };
+  if (config) {
+    return {
+      upstreamProvider,
+      upstreamModel,
+      upstreamKey: config.apiKey,
+      upstreamBaseUrl: config.baseUrl,
+      upstreamApi: config.api || "openai-completions"
+    };
+  }
+  const builtin = resolveBuiltin(upstreamProvider);
+  if (builtin) {
+    return { ...builtin, upstreamModel };
+  }
+  return null;
 }
 function generateModelCatalog(providers) {
   const models = [];
@@ -84,6 +135,37 @@ function startProxy(getProviders2, getOccKey) {
       res.end(JSON.stringify({ status: "ok", version: "2.0.0" }));
       return;
     }
+    if (req.url === "/provision" && req.method === "POST") {
+      try {
+        const provRes = await fetch(`${OCC_API}/v1/provision`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: "{}"
+        });
+        const data = await provRes.text();
+        res.writeHead(provRes.status, { "Content-Type": "application/json" });
+        res.end(data);
+      } catch (err) {
+        res.writeHead(502, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: { message: String(err) } }));
+      }
+      return;
+    }
+    if (req.url === "/stats" && req.method === "GET") {
+      const authHeader = req.headers["authorization"] || "";
+      try {
+        const statsRes = await fetch(`${OCC_API}/user/stats`, {
+          headers: { Authorization: authHeader }
+        });
+        const data = await statsRes.text();
+        res.writeHead(statsRes.status, { "Content-Type": "application/json" });
+        res.end(data);
+      } catch (err) {
+        res.writeHead(502, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: { message: String(err) } }));
+      }
+      return;
+    }
     if (req.method !== "POST") {
       res.writeHead(405);
       res.end("Method not allowed");
@@ -263,17 +345,76 @@ function readBody(req) {
 }
 
 // src/index.ts
+var _cachedKey;
 function getApiKey(api) {
+  if (_cachedKey) return _cachedKey;
   const auth = api.config.auth;
   const fromConfig = auth?.profiles?.opencompress?.credentials?.["api-key"]?.apiKey;
-  if (fromConfig) return fromConfig;
-  if (process.env.OPENCOMPRESS_API_KEY) return process.env.OPENCOMPRESS_API_KEY;
-  if (api.pluginConfig?.apiKey) return api.pluginConfig.apiKey;
+  if (fromConfig) {
+    _cachedKey = fromConfig;
+    return fromConfig;
+  }
+  if (process.env.OPENCOMPRESS_API_KEY) {
+    _cachedKey = process.env.OPENCOMPRESS_API_KEY;
+    return _cachedKey;
+  }
+  if (api.pluginConfig?.apiKey) {
+    _cachedKey = api.pluginConfig.apiKey;
+    return _cachedKey;
+  }
+  try {
+    const fs = __require("fs");
+    const os = __require("os");
+    const path = __require("path");
+    const keyPath = path.join(os.homedir(), ".openclaw", "opencompress", "api-key");
+    if (fs.existsSync(keyPath)) {
+      const key = fs.readFileSync(keyPath, "utf-8").trim();
+      if (key.startsWith("sk-occ-")) {
+        _cachedKey = key;
+        return key;
+      }
+    }
+  } catch {
+  }
   return void 0;
 }
+async function autoProvision(api) {
+  try {
+    const res = await fetch(`http://${PROXY_HOST}:${PROXY_PORT}/provision`, {
+      method: "POST"
+    });
+    if (!res.ok) return void 0;
+    const data = await res.json();
+    const key = data.apiKey;
+    if (!key) return void 0;
+    try {
+      const fs = __require("fs");
+      const os = __require("os");
+      const path = __require("path");
+      const dir = path.join(os.homedir(), ".openclaw", "opencompress");
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(path.join(dir, "api-key"), key, { mode: 384 });
+    } catch {
+    }
+    _cachedKey = key;
+    api.logger.info(`OpenCompress: auto-provisioned API key (${data.freeCredit} free credit)`);
+    return key;
+  } catch {
+    return void 0;
+  }
+}
 function getProviders(api) {
   return api.config.models?.providers || {};
 }
+function injectEnvVars(api) {
+  const envVars = api.config.env?.vars;
+  if (!envVars) return;
+  for (const [key, value] of Object.entries(envVars)) {
+    if (!process.env[key] && value) {
+      process.env[key] = value;
+    }
+  }
+}
 function createProvider(api) {
   return {
     id: PROVIDER_ID,
@@ -298,7 +439,7 @@ function createProvider(api) {
         kind: "custom",
         run: async (ctx) => {
           ctx.prompter.note(
-            "\u{1F5DC}\uFE0F OpenCompress \u2014 save tokens and sharpen quality on every LLM call\n\nUse your existing LLM providers. Your API keys stay on your machine.\nWe compress prompts to reduce costs and improve output quality."
+            "OpenCompress compresses LLM input and output to save tokens and improve quality.\nYour existing API keys stay on your machine. We just make the traffic smaller."
           );
           const spinner = ctx.prompter.progress("Creating your account...");
           try {
@@ -313,19 +454,17 @@ function createProvider(api) {
             }
             const data = await res.json();
             spinner.stop("Account created!");
+            _cachedKey = data.apiKey;
             return {
               profiles: [{
                 profileId: "default",
                 credential: { apiKey: data.apiKey }
               }],
               notes: [
-                "\u{1F5DC}\uFE0F OpenCompress ready!",
-                `\u{1F4B0} ${data.freeCredit} free credit.`,
-                "",
-                "Select any opencompress/* model to enable compression.",
-                "Your existing provider keys are used automatically.",
+                "OpenCompress ready!",
+                `${data.freeCredit} free credit. No credit card needed.`,
                 "",
-                "Dashboard: https://www.opencompress.ai/dashboard"
+                "Select any opencompress/* model to enable compression."
               ]
             };
           } catch (err) {
@@ -340,9 +479,10 @@ function createProvider(api) {
 var plugin = {
   id: "opencompress",
   name: "OpenCompress",
-  description: "Save tokens and sharpen quality on any LLM \u2014 use your existing providers",
+  description: "Save tokens and sharpen quality on any LLM. Use your existing providers.",
   version: VERSION,
   register(api) {
+    injectEnvVars(api);
     api.registerProvider(createProvider(api));
     api.logger.info(`OpenCompress v${VERSION} registered`);
     api.registerService({
@@ -358,7 +498,10 @@ var plugin = {
         stopProxy();
       }
     });
-    setTimeout(() => {
+    setTimeout(async () => {
+      if (!getApiKey(api)) {
+        await autoProvision(api);
+      }
       try {
         startProxy(
           () => getProviders(api),
@@ -366,14 +509,17 @@ var plugin = {
         );
       } catch {
       }
-    }, 1e3);
+    }, 1500);
     api.registerCommand({
-      name: "compress-stats",
+      name: "compress_stats",
       description: "Show OpenCompress savings and balance",
       handler: async () => {
-        const key = getApiKey(api);
+        let key = getApiKey(api);
         if (!key) {
-          return { text: "No API key. Run `openclaw onboard opencompress` first." };
+          key = await autoProvision(api) || void 0;
+        }
+        if (!key) {
+          return { text: "Could not provision API key. Check your network connection." };
         }
         try {
           const res = await fetch(`${OCC_API}/user/stats`, {
@@ -387,15 +533,15 @@ var plugin = {
           return {
             text: [
               "```",
-              "\u{1F5DC}\uFE0F OpenCompress Stats",
-              "======================",
+              "OpenCompress Stats",
+              "==================",
               `Balance:         $${balance.toFixed(2)}`,
               `API calls:       ${calls}`,
               `Avg compression: ${rate}`,
               `Tokens saved:    ${(Number(s.totalOriginalTokens || 0) - Number(s.totalCompressedTokens || 0)).toLocaleString()}`,
               "```",
               "",
-              balance < 0.5 ? `\u26A0\uFE0F Low balance! Link account for $10 bonus: https://www.opencompress.ai/dashboard?link=${encodeURIComponent(key)}` : "Dashboard: https://www.opencompress.ai/dashboard"
+              balance < 0.5 ? `Low balance. Link your account for $10 bonus: https://www.opencompress.ai/dashboard?link=${encodeURIComponent(key)}` : "Dashboard: https://www.opencompress.ai/dashboard"
             ].join("\n")
           };
         } catch (err) {
@@ -407,20 +553,23 @@ var plugin = {
       name: "compress",
       description: "Show OpenCompress status and available models",
       handler: async () => {
-        const key = getApiKey(api);
+        let key = getApiKey(api);
+        if (!key) {
+          key = await autoProvision(api) || void 0;
+        }
         const providers = getProviders(api);
         const models = generateModelCatalog(providers);
         return {
           text: [
             "**OpenCompress**",
             "",
-            `API key: ${key ? `${key.slice(0, 12)}...` : "not set \u2014 run `openclaw onboard opencompress`"}`,
+            `API key: ${key ? `${key.slice(0, 15)}...` : "provisioning failed"}`,
             `Proxy: http://${PROXY_HOST}:${PROXY_PORT}`,
             "",
             "**Compressed models:**",
             ...models.map((m) => `  ${m.id}`),
             "",
-            "Select any opencompress/* model to enable compression."
+            "Use `/model opencompress/auto` to enable compression."
           ].join("\n")
         };
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencompress/openclaw",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "description": "OpenCompress for OpenClaw — save tokens and sharpen quality on any LLM",
   "type": "module",
   "main": "dist/index.js",