@opencompress/opencompress 1.8.2 → 1.9.0

package/dist/index.js

@@ -6,7 +6,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/index.ts
-var VERSION = "1.8.2";
+var VERSION = "1.9.0";
 var DEFAULT_BASE_URL = "https://www.opencompress.ai/api";
 function getApiKey(api) {
   const auth = api.config.auth;
@@ -35,87 +35,7 @@ function getApiKey(api) {
   }
   return void 0;
 }
-var FALLBACK_MODELS = [
-  { id: "gpt-4o", name: "GPT-4o", reasoning: false, input: ["text", "image"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 128e3, maxTokens: 16384 },
-  { id: "gpt-4o-mini", name: "GPT-4o Mini", reasoning: false, input: ["text", "image"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 128e3, maxTokens: 16384 },
-  { id: "gpt-4.1", name: "GPT-4.1", reasoning: false, input: ["text", "image"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 1047576, maxTokens: 32768 },
-  { id: "gpt-4.1-mini", name: "GPT-4.1 Mini", reasoning: false, input: ["text", "image"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 1047576, maxTokens: 32768 },
-  { id: "claude-sonnet-4-6", name: "Claude Sonnet 4.6", reasoning: false, input: ["text", "image"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 2e5, maxTokens: 128e3 },
-  { id: "claude-haiku-4-5-20251001", name: "Claude Haiku 4.5", reasoning: false, input: ["text", "image"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 2e5, maxTokens: 128e3 },
-  { id: "gemini-2.5-pro", name: "Gemini 2.5 Pro", reasoning: true, input: ["text", "image"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 1048576, maxTokens: 65536 },
-  { id: "gemini-2.5-flash", name: "Gemini 2.5 Flash", reasoning: false, input: ["text", "image"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 1048576, maxTokens: 65536 },
-  { id: "deepseek/deepseek-chat-v3-0324", name: "DeepSeek V3", reasoning: false, input: ["text"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 131072, maxTokens: 8192 },
-  { id: "deepseek/deepseek-reasoner", name: "DeepSeek Reasoner", reasoning: true, input: ["text"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 131072, maxTokens: 8192 }
-];
-function readExistingModels(api) {
-  const providers = api.config.models?.providers;
-  if (!providers) return null;
-  const seen = /* @__PURE__ */ new Set();
-  const models = [];
-  for (const [providerId, providerConfig] of Object.entries(providers)) {
-    if (providerId === "opencompress") continue;
-    const providerModels = providerConfig.models || [];
-    for (const m of providerModels) {
-      if (m.name?.includes("\u2192")) continue;
-      const rawId = m.id.includes("/") ? m.id.split("/").slice(1).join("/") : m.id;
-      if (seen.has(rawId)) continue;
-      seen.add(rawId);
-      const upstreamId = m.id.startsWith(`${providerId}/`) ? rawId : m.id;
-      models.push({
-        ...m,
-        id: upstreamId,
-        name: m.name || upstreamId,
-        // Zero out cost — billing handled by OpenCompress proxy
-        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }
-      });
-    }
-  }
-  return models.length > 0 ? models : null;
-}
-function buildProviderModels(baseUrl, models, apiKey) {
-  return {
-    baseUrl: `${baseUrl}/v1`,
-    api: "openai-completions",
-    apiKey: apiKey || void 0,
-    models: models || FALLBACK_MODELS
-  };
-}
-function persistModelsConfig(providerModels) {
-  try {
-    const os = __require("os");
-    const fs = __require("fs");
-    const path = __require("path");
-    const configPath = path.join(os.homedir(), ".openclaw", "openclaw.json");
-    if (!fs.existsSync(configPath)) return;
-    const raw = fs.readFileSync(configPath, "utf-8");
-    let config;
-    try {
-      config = JSON.parse(raw);
-    } catch {
-      return;
-    }
-    if (!config.models) config.models = {};
-    const models = config.models;
-    if (!models.providers) models.providers = {};
-    const providers = models.providers;
-    const configSafeModels = providerModels.models.map((m) => ({
-      id: m.id,
-      name: m.name
-    }));
-    const configEntry = {
-      baseUrl: providerModels.baseUrl,
-      api: providerModels.api || "openai-completions",
-      models: configSafeModels
-    };
-    if (providerModels.apiKey) {
-      configEntry.apiKey = providerModels.apiKey;
-    }
-    providers.opencompress = configEntry;
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
-  } catch {
-  }
-}
-function persistAgentModelsJson(providerModels) {
+function persistAuthProfile(apiKey) {
   try {
     const os = __require("os");
     const fs = __require("fs");
@@ -124,36 +44,27 @@ function persistAgentModelsJson(providerModels) {
     if (!fs.existsSync(agentsDir)) return;
     const agentDirs = fs.readdirSync(agentsDir);
     for (const agent of agentDirs) {
-      const modelsPath = path.join(agentsDir, agent, "agent", "models.json");
-      const modelsDir = path.dirname(modelsPath);
-      if (!fs.existsSync(modelsDir)) continue;
-      let data = { providers: {} };
-      if (fs.existsSync(modelsPath)) {
+      const authPath = path.join(agentsDir, agent, "agent", "auth-profiles.json");
+      const authDir = path.dirname(authPath);
+      if (!fs.existsSync(authDir)) {
+        fs.mkdirSync(authDir, { recursive: true });
+      }
+      let profiles = {
+        version: 1,
+        profiles: {}
+      };
+      if (fs.existsSync(authPath)) {
         try {
-          data = JSON.parse(fs.readFileSync(modelsPath, "utf-8"));
-          if (!data.providers || typeof data.providers !== "object") {
-            data.providers = {};
-          }
+          profiles = JSON.parse(fs.readFileSync(authPath, "utf-8"));
         } catch {
-          data = { providers: {} };
         }
       }
-      data.providers.opencompress = {
-        baseUrl: providerModels.baseUrl,
-        api: providerModels.api || "openai-completions",
-        apiKey: providerModels.apiKey || void 0,
-        models: providerModels.models.map((m) => ({
-          id: m.id,
-          name: m.name,
-          api: m.api || "openai-completions",
-          reasoning: m.reasoning ?? false,
-          input: m.input || ["text"],
-          cost: m.cost || { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-          contextWindow: m.contextWindow || 2e5,
-          maxTokens: m.maxTokens || 8192
-        }))
+      profiles.profiles["opencompress:default"] = {
+        type: "api_key",
+        provider: "opencompress",
+        key: apiKey
       };
-      fs.writeFileSync(modelsPath, JSON.stringify(data, null, 2) + "\n");
+      fs.writeFileSync(authPath, JSON.stringify(profiles, null, 2) + "\n");
     }
   } catch {
   }
@@ -187,125 +98,215 @@ function persistAgentAuthJson(apiKey) {
   } catch {
   }
 }
-function injectModelsAllowlist(models) {
+function proxyStatePath() {
+  const os = __require("os");
+  const path = __require("path");
+  return path.join(os.homedir(), ".openclaw", "opencompress-proxy.json");
+}
+function readProxyState() {
   try {
-    const os = __require("os");
     const fs = __require("fs");
-    const path = __require("path");
-    const configPath = path.join(os.homedir(), ".openclaw", "openclaw.json");
-    if (!fs.existsSync(configPath)) return;
-    const raw = fs.readFileSync(configPath, "utf-8");
-    let config;
-    try {
-      config = JSON.parse(raw);
-    } catch {
-      return;
-    }
-    if (!config.agents) config.agents = {};
-    const agents = config.agents;
-    if (!agents.defaults) agents.defaults = {};
-    const defaults = agents.defaults;
-    if (!defaults.models) defaults.models = {};
-    const allowlist = defaults.models;
-    const existingKeys = Object.keys(allowlist);
-    if (existingKeys.length === 0) return;
-    let changed = false;
-    for (const m of models) {
-      const fullId = `opencompress/${m.id}`;
-      if (!allowlist[fullId]) {
-        allowlist[fullId] = {};
-        changed = true;
-      }
-    }
-    if (changed) {
-      const tmpPath = `${configPath}.tmp.${process.pid}`;
-      fs.writeFileSync(tmpPath, JSON.stringify(config, null, 2) + "\n");
-      fs.renameSync(tmpPath, configPath);
-    }
+    const p = proxyStatePath();
+    if (!fs.existsSync(p)) return { enabled: false, originals: {} };
+    return JSON.parse(fs.readFileSync(p, "utf-8"));
   } catch {
+    return { enabled: false, originals: {} };
   }
 }
-function persistAuthProfile(apiKey) {
+function writeProxyState(state) {
+  try {
+    const fs = __require("fs");
+    fs.writeFileSync(proxyStatePath(), JSON.stringify(state, null, 2) + "\n");
+  } catch {
+  }
+}
+function readProvidersFromDisk() {
   try {
     const os = __require("os");
     const fs = __require("fs");
     const path = __require("path");
+    const configPath = path.join(os.homedir(), ".openclaw", "openclaw.json");
+    if (!fs.existsSync(configPath)) return void 0;
+    const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    const providers = raw?.models?.providers;
+    if (!providers || Object.keys(providers).length === 0) return void 0;
+    return providers;
+  } catch {
+    return void 0;
+  }
+}
+function persistProviderToDisk(providerId, config) {
+  const os = __require("os");
+  const fs = __require("fs");
+  const path = __require("path");
+  try {
+    const configPath = path.join(os.homedir(), ".openclaw", "openclaw.json");
+    if (fs.existsSync(configPath)) {
+      const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      if (!raw.models) raw.models = {};
+      if (!raw.models.providers) raw.models.providers = {};
+      raw.models.providers[providerId] = {
+        baseUrl: config.baseUrl,
+        api: config.api || "openai-completions",
+        apiKey: config.apiKey || void 0,
+        models: config.models?.map((m) => ({ id: m.id, name: m.name })) || [],
+        ...config.headers ? { headers: config.headers } : {}
+      };
+      fs.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n");
+    }
+  } catch {
+  }
+  try {
     const agentsDir = path.join(os.homedir(), ".openclaw", "agents");
     if (!fs.existsSync(agentsDir)) return;
-    const agentDirs = fs.readdirSync(agentsDir);
-    for (const agent of agentDirs) {
-      const authPath = path.join(agentsDir, agent, "agent", "auth-profiles.json");
-      const authDir = path.dirname(authPath);
-      if (!fs.existsSync(authDir)) {
-        fs.mkdirSync(authDir, { recursive: true });
-      }
-      let profiles = {
-        version: 1,
-        profiles: {}
-      };
-      if (fs.existsSync(authPath)) {
+    for (const agent of fs.readdirSync(agentsDir)) {
+      const modelsPath = path.join(agentsDir, agent, "agent", "models.json");
+      if (!fs.existsSync(path.dirname(modelsPath))) continue;
+      let data = { providers: {} };
+      if (fs.existsSync(modelsPath)) {
         try {
-          profiles = JSON.parse(fs.readFileSync(authPath, "utf-8"));
+          data = JSON.parse(fs.readFileSync(modelsPath, "utf-8"));
         } catch {
         }
+        if (!data.providers) data.providers = {};
       }
-      profiles.profiles["opencompress:default"] = {
-        type: "api_key",
-        provider: "opencompress",
-        key: apiKey
+      data.providers[providerId] = {
+        baseUrl: config.baseUrl,
+        api: config.api || "openai-completions",
+        apiKey: config.apiKey || void 0,
+        models: config.models?.map((m) => ({
+          id: m.id,
+          name: m.name,
+          api: m.api || config.api || "openai-completions",
+          reasoning: m.reasoning ?? false,
+          input: m.input || ["text"],
+          cost: m.cost || { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+          contextWindow: m.contextWindow || 2e5,
+          maxTokens: m.maxTokens || 8192
+        })) || [],
+        ...config.headers ? { headers: config.headers } : {}
       };
-      fs.writeFileSync(authPath, JSON.stringify(profiles, null, 2) + "\n");
+      fs.writeFileSync(modelsPath, JSON.stringify(data, null, 2) + "\n");
     }
   } catch {
   }
 }
+function enableProxy(api, baseUrl) {
+  const occKey = getApiKey(api);
+  if (!occKey) return { proxied: [], skipped: [] };
+  let providers = api.config.models?.providers;
+  let source = "api.config";
+  if (!providers || Object.keys(providers).length === 0) {
+    providers = readProvidersFromDisk();
+    source = "disk (openclaw.json)";
+  }
+  if (!providers) return { proxied: [], skipped: [] };
+  const state = readProxyState();
+  const proxied = [];
+  const skipped = [];
+  for (const [id, raw] of Object.entries(providers)) {
+    if (id === "opencompress") continue;
+    const provider = raw;
+    if (provider.baseUrl?.includes("opencompress.ai")) continue;
+    const pApi = provider.api || "openai-completions";
+    if (pApi === "google-generative-ai") {
+      skipped.push(`${id} (${pApi})`);
+      continue;
+    }
+    state.originals[id] = {
+      baseUrl: provider.baseUrl,
+      apiKey: provider.apiKey,
+      api: provider.api,
+      headers: provider.headers ? { ...provider.headers } : void 0
+    };
+    if (pApi === "anthropic-messages") {
+      provider.headers = {
+        ...provider.headers || {},
+        "x-api-key": provider.apiKey || ""
+      };
+      provider.baseUrl = `${baseUrl}/v1`;
+      provider.apiKey = void 0;
+    } else {
+      provider.headers = {
+        ...provider.headers || {},
+        "X-Upstream-Key": provider.apiKey || "",
+        "X-Upstream-Base-Url": provider.baseUrl
+      };
+      provider.baseUrl = `${baseUrl}/v1`;
+      provider.apiKey = occKey;
+    }
+    persistProviderToDisk(id, provider);
+    proxied.push(id);
+  }
+  state.enabled = true;
+  writeProxyState(state);
+  return { proxied, skipped, source };
+}
+function disableProxy(api) {
+  const state = readProxyState();
+  if (!state.enabled) return [];
+  let providers = api.config.models?.providers;
+  if (!providers || Object.keys(providers).length === 0) {
+    providers = readProvidersFromDisk();
+  }
+  if (!providers) return [];
+  const restored = [];
+  for (const [id, orig] of Object.entries(state.originals)) {
+    const provider = providers[id];
+    if (!provider) continue;
+    provider.baseUrl = orig.baseUrl;
+    provider.apiKey = orig.apiKey;
+    provider.api = orig.api;
+    if (orig.headers) {
+      provider.headers = orig.headers;
+    } else {
+      const h = provider.headers;
+      if (h) {
+        delete h["X-Upstream-Key"];
+        delete h["X-Upstream-Base-Url"];
+        delete h["x-api-key"];
+        if (Object.keys(h).length === 0) delete provider.headers;
+      }
+    }
+    persistProviderToDisk(id, provider);
+    restored.push(id);
+  }
+  state.enabled = false;
+  state.originals = {};
+  writeProxyState(state);
+  return restored;
+}
 var opencompressProvider = {
   id: "opencompress",
   label: "OpenCompress",
   docsPath: "https://docs.opencompress.ai",
   aliases: ["oc", "compress"],
   envVars: ["OPENCOMPRESS_API_KEY"],
-  models: buildProviderModels(DEFAULT_BASE_URL),
+  // No models — we're a transparent proxy, not a router.
+  // Users keep their existing providers; we just compress their traffic.
+  models: {
+    baseUrl: `${DEFAULT_BASE_URL}/v1`,
+    api: "openai-completions",
+    models: []
+  },
   formatApiKey: (cred) => cred.apiKey || "",
   auth: [
     {
       id: "api-key",
       label: "OpenCompress",
-      hint: "Connect your LLM key \u2014 compress every call, save 40-70%",
+      hint: "Compress all LLM calls automatically \u2014 save 40-60% on any provider",
       kind: "custom",
       run: async (ctx) => {
         ctx.prompter.note(
-          "OpenCompress compresses all LLM prompts automatically.\n53% fewer tokens, 62% faster, 96% quality preserved.\n\nConnect your existing LLM API key to get started.\nSupported: OpenAI, Anthropic, OpenRouter, Google"
+          "\u{1F99E} Welcome to OpenCompress!\n\nWe compress your LLM prompts automatically \u2014 saving 40-70% on token costs.\nWorks with Claude, GPT, and any provider you already have.\nYour API keys stay yours. We just make the traffic smaller.\n\nWe're giving you $1 free credit to try it out!"
         );
-        const llmKey = await ctx.prompter.text({
-          message: "Enter your LLM API key (OpenAI/Anthropic/OpenRouter):",
-          validate: (val) => {
-            if (!val || val.length < 10) return "Please enter a valid API key";
-            if (val.startsWith("sk-occ-")) return "Enter your LLM provider key, not an OpenCompress key";
-            return void 0;
-          }
-        });
-        if (typeof llmKey === "symbol") {
-          throw new Error("Setup cancelled");
-        }
-        let provider = "openrouter";
-        let upstreamBaseUrl = "https://openrouter.ai/api/v1";
-        if (llmKey.startsWith("sk-proj-") || llmKey.startsWith("sk-") && !llmKey.startsWith("sk-ant-") && !llmKey.startsWith("sk-or-")) {
-          provider = "openai";
-          upstreamBaseUrl = "https://api.openai.com/v1";
-        } else if (llmKey.startsWith("sk-ant-")) {
-          provider = "anthropic";
-          upstreamBaseUrl = "https://api.anthropic.com/v1";
-        } else if (llmKey.startsWith("AIza")) {
-          provider = "google";
-          upstreamBaseUrl = "https://generativelanguage.googleapis.com/v1beta/openai";
-        }
-        const spinner = ctx.prompter.progress("Creating account...");
+        const spinner = ctx.prompter.progress("Setting up your account...");
         try {
           const res = await fetch(`${DEFAULT_BASE_URL}/v1/provision`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ upstreamApiKey: llmKey })
+            body: JSON.stringify({})
+            // BYOK — no upstream key needed here, user's existing providers handle that
           });
           if (!res.ok) {
             const err = await res.json().catch(() => ({ error: { message: "Unknown error" } }));
@@ -315,13 +316,38 @@ var opencompressProvider = {
             );
           }
           const data = await res.json();
-          spinner.stop("Account created");
-          const onboardModels = buildProviderModels(DEFAULT_BASE_URL, void 0, data.apiKey);
-          const modelCount = FALLBACK_MODELS.length;
-          persistModelsConfig(onboardModels);
-          persistAgentModelsJson(onboardModels);
+          spinner.stop("Account created!");
           persistAuthProfile(data.apiKey);
           persistAgentAuthJson(data.apiKey);
+          const enableNow = await ctx.prompter.text({
+            message: "Ready to compress? This will route your existing LLM providers through OpenCompress. Enable now? (yes/no)",
+            validate: (v) => {
+              const lower = v.toLowerCase().trim();
+              if (!["yes", "no", "y", "n"].includes(lower)) return "Please answer yes or no";
+              return void 0;
+            }
+          });
+          const shouldEnable = typeof enableNow === "string" && ["yes", "y"].includes(enableNow.toLowerCase().trim());
+          const notes = [
+            "\u{1F99E} OpenCompress is ready!",
+            `\u{1F4B0} $1 free credit \u2014 no credit card needed.`,
+            "",
+            "How it works: your existing API keys (Claude, GPT, etc.) stay the same.",
+            "We just compress the prompts in between \u2014 you save 40-70% on every call."
+          ];
+          if (shouldEnable) {
+            notes.push(
+              "",
+              "\u2705 Compression is now active! All your LLM calls are being compressed.",
+              "Run `/compress-stats` anytime to see how much you're saving."
+            );
+          } else {
+            notes.push(
+              "",
+              "Run `/compress on` whenever you're ready to start saving."
+            );
+          }
+          notes.push("", "Dashboard: https://www.opencompress.ai/dashboard");
           return {
             profiles: [
               {
@@ -329,19 +355,8 @@ var opencompressProvider = {
                 credential: { apiKey: data.apiKey }
               }
             ],
-            configPatch: {
-              models: {
-                providers: {
-                  opencompress: onboardModels
-                }
-              }
-            },
-            defaultModel: "gpt-4o-mini",
-            notes: [
-              `OpenCompress is ready! Connected to ${provider} (${modelCount} models).`,
-              "Your LLM key is stored locally only \u2014 never on our server.",
-              `Free credit: ${data.freeCredit}. Dashboard: opencompress.ai/dashboard`
-            ]
+            configPatch: shouldEnable ? { _autoEnableProxy: true } : void 0,
+            notes
           };
         } catch (err) {
           spinner.stop("Setup failed");
@@ -354,52 +369,19 @@ var opencompressProvider = {
 var plugin = {
   id: "opencompress",
   name: "OpenCompress",
-  description: "5-layer prompt compression \u2014 53% input reduction, 62% latency cut, 96% quality",
+  description: "Transparent prompt compression \u2014 save 40-70% on Claude, GPT, and any LLM provider",
   version: VERSION,
   register(api) {
     const baseUrl = api.pluginConfig?.baseUrl || DEFAULT_BASE_URL;
-    const existingApiKey = api.config.models?.providers?.opencompress?.apiKey || getApiKey(api);
-    const existingModels = readExistingModels(api);
-    const providerModels = buildProviderModels(baseUrl, existingModels || void 0, existingApiKey);
-    opencompressProvider.models = providerModels;
     api.registerProvider(opencompressProvider);
-    if (!api.config.models) {
-      api.config.models = { providers: {} };
-    }
-    if (!api.config.models.providers) {
-      api.config.models.providers = {};
-    }
-    api.config.models.providers.opencompress = providerModels;
-    persistModelsConfig(providerModels);
-    persistAgentModelsJson(providerModels);
-    {
-      if (!api.config.agents) api.config.agents = {};
-      const agents = api.config.agents;
-      if (!agents.defaults) agents.defaults = {};
-      const defaults = agents.defaults;
-      if (!defaults.models) defaults.models = {};
-      const allowlist = defaults.models;
-      if (Object.keys(allowlist).length > 0) {
-        for (const m of providerModels.models) {
-          const fullId = `opencompress/${m.id}`;
-          if (!allowlist[fullId]) {
-            allowlist[fullId] = {};
-          }
-        }
-      }
-    }
-    const modelsForAllowlist = providerModels.models;
-    setTimeout(() => injectModelsAllowlist(modelsForAllowlist), 3e3);
     const apiKey = getApiKey(api);
     if (apiKey) {
       persistAuthProfile(apiKey);
       persistAgentAuthJson(apiKey);
     }
-    const modelCount = existingModels ? existingModels.length : FALLBACK_MODELS.length;
-    const source = existingModels ? "from existing providers" : "fallback";
-    api.logger.info(`OpenCompress provider registered (${modelCount} models ${source}, 5-layer compression)`);
+    api.logger.info("OpenCompress registered (transparent proxy mode)");
     api.registerCommand({
-      name: "compress_stats",
+      name: "compress-stats",
       description: "Show OpenCompress usage statistics and savings",
       acceptsArgs: true,
       requireAuth: false,
@@ -418,26 +400,35 @@ var plugin = {
             return { text: `Failed to fetch stats: HTTP ${res.status}` };
           }
           const stats = await res.json();
-          const calls = stats.totalCalls ?? 0;
-          const savings = Number(stats.totalSavings || 0).toFixed(4);
+          const balance = Number(stats.balanceUsd || 0);
+          const calls = stats.monthlyApiCalls ?? stats.totalCalls ?? 0;
+          const savings = Number(stats.monthlySavings || stats.totalSavings || 0).toFixed(4);
           const rate = stats.avgCompressionRate ? `${(Number(stats.avgCompressionRate) * 100).toFixed(1)}%` : "N/A";
           const origTokens = Number(stats.totalOriginalTokens || 0).toLocaleString();
           const compTokens = Number(stats.totalCompressedTokens || 0).toLocaleString();
-          return {
-            text: [
-              "```",
-              "OpenCompress Stats",
-              "==================",
-              `API calls:          ${calls}`,
-              `Avg compression:    ${rate}`,
-              `Original tokens:    ${origTokens}`,
-              `Compressed tokens:  ${compTokens}`,
-              `Total savings:      $${savings}`,
-              "```",
+          const lines = [
+            "```",
+            "\u{1F99E} OpenCompress Stats",
+            "=====================",
+            `Balance:            $${balance.toFixed(2)}`,
+            `API calls:          ${calls}`,
+            `Avg compression:    ${rate}`,
+            `Original tokens:    ${origTokens}`,
+            `Compressed tokens:  ${compTokens}`,
+            `Total savings:      $${savings}`,
+            "```"
+          ];
+          if (balance < 0.5) {
+            const linkUrl = `https://www.opencompress.ai/dashboard?link=${encodeURIComponent(apiKey2)}`;
+            lines.push(
               "",
-              "Dashboard: https://www.opencompress.ai/dashboard"
-            ].join("\n")
-          };
+              "\u26A0\uFE0F **Balance is low!** Link your account to get **$10 bonus credit**:",
+              linkUrl
+            );
+          } else {
+            lines.push("", "Dashboard: https://www.opencompress.ai/dashboard");
+          }
+          return { text: lines.join("\n") };
         } catch (err) {
           return {
             text: `Error fetching stats: ${err instanceof Error ? err.message : String(err)}`
@@ -445,108 +436,84 @@ var plugin = {
         }
       }
     });
-    api.logger.info("Registered /compress_stats command");
+    api.logger.info("Registered /compress-stats command");
     api.registerCommand({
-      name: "compress_byok",
-      description: "Connect your own LLM key (OpenAI/Anthropic/OpenRouter) to save more",
+      name: "compress",
+      description: "Toggle transparent compression for all LLM providers",
       acceptsArgs: true,
       requireAuth: false,
       handler: async (ctx) => {
-        const apiKey2 = getApiKey(api);
-        if (!apiKey2) {
-          return { text: "Not set up. Run `openclaw onboard opencompress` first." };
+        const arg = ctx.args?.trim().toLowerCase();
+        if (arg === "on" || arg === "enable") {
+          const occKey2 = getApiKey(api);
+          if (!occKey2) {
+            return { text: "No API key found. Run `openclaw onboard opencompress` first." };
+          }
+          const result = enableProxy(api, baseUrl);
+          if (result.proxied.length === 0 && result.skipped.length === 0) {
+            return { text: "No providers found to proxy. Add LLM providers first." };
+          }
+          const lines = [
+            `**Compression enabled** for all compatible providers (source: ${result.source}).`,
+            ""
+          ];
+          if (result.proxied.length > 0) {
+            lines.push(`Proxied (${result.proxied.length}): ${result.proxied.join(", ")}`);
+          }
+          if (result.skipped.length > 0) {
+            lines.push(`Skipped (incompatible format): ${result.skipped.join(", ")}`);
+          }
+          lines.push("", "All requests now route through OpenCompress for automatic compression.");
+          lines.push("To disable: `/compress off`");
+          return { text: lines.join("\n") };
         }
-        const upstreamKey = ctx.args?.trim();
-        if (!upstreamKey) {
-          const res = await fetch(`${baseUrl}/v1/topup`, {
-            headers: { Authorization: `Bearer ${apiKey2}` }
-          });
-          const data = res.ok ? await res.json() : null;
+        if (arg === "off" || arg === "disable") {
+          const restored = disableProxy(api);
+          if (restored.length === 0) {
+            return { text: "Compression proxy was not active." };
+          }
           return {
             text: [
-              "**BYOK (Bring Your Own Key)**",
+              "**Compression disabled.** Restored original provider configs.",
               "",
-              "Connect your LLM provider key to pay them directly \u2014 we only charge the compression fee (20% of savings).",
+              `Restored: ${restored.join(", ")}`,
               "",
-              "**Usage:**",
-              "  `/compress_byok sk-proj-xxx`  \u2014 Connect OpenAI key",
-              "  `/compress_byok sk-ant-xxx`   \u2014 Connect Anthropic key",
-              "  `/compress_byok sk-or-xxx`    \u2014 Connect OpenRouter key",
-              "  `/compress_byok off`          \u2014 Switch back to router mode",
-              "",
-              data ? `**Balance:** $${Number(data.balance || 0).toFixed(2)}` : ""
+              "To re-enable: `/compress on`"
             ].join("\n")
           };
         }
-        if (upstreamKey === "off" || upstreamKey === "disable" || upstreamKey === "router") {
-          const cleanModels = buildProviderModels(baseUrl);
-          if (api.config.models?.providers) {
-            api.config.models.providers.opencompress = cleanModels;
-          }
-          persistModelsConfig(cleanModels);
-          persistAgentModelsJson(cleanModels);
-          try {
-            await fetch(`${baseUrl}/v1/byok`, {
-              method: "DELETE",
-              headers: { Authorization: `Bearer ${apiKey2}` }
-            });
-          } catch {
-          }
-          return { text: "Switched back to **router mode**. Your upstream key has been removed from local config." };
+        const proxyState = readProxyState();
+        const occKey = getApiKey(api);
+        const statusLines = [
+          "**OpenCompress Transparent Proxy**",
+          "",
+          `Status: ${proxyState.enabled ? "**ON**" : "**OFF**"}`,
+          `API key: ${occKey ? `${occKey.slice(0, 12)}...` : "not set"}`
+        ];
+        if (proxyState.enabled && Object.keys(proxyState.originals).length > 0) {
+          statusLines.push(`Proxied providers: ${Object.keys(proxyState.originals).join(", ")}`);
         }
-        if (upstreamKey.startsWith("sk-occ-")) {
-          return { text: "That's an OpenCompress key. Provide your LLM provider key (OpenAI, Anthropic, etc.)." };
-        }
-        if (upstreamKey.length < 10) {
-          return { text: "Key looks too short. Provide your full LLM API key." };
-        }
-        let provider = "unknown";
-        let upstreamBaseUrl = "";
-        if (upstreamKey.startsWith("sk-proj-") || upstreamKey.startsWith("sk-") && !upstreamKey.startsWith("sk-ant-") && !upstreamKey.startsWith("sk-or-")) {
-          provider = "openai";
-          upstreamBaseUrl = "https://api.openai.com/v1";
-        } else if (upstreamKey.startsWith("sk-ant-")) {
-          provider = "anthropic";
-          upstreamBaseUrl = "https://api.anthropic.com/v1";
-        } else if (upstreamKey.startsWith("sk-or-")) {
-          provider = "openrouter";
-          upstreamBaseUrl = "https://openrouter.ai/api/v1";
-        } else if (upstreamKey.startsWith("AIza")) {
-          provider = "google";
-          upstreamBaseUrl = "https://generativelanguage.googleapis.com/v1beta/openai";
-        }
-        const existingModels2 = readExistingModels(api);
-        const updatedModels = buildProviderModels(baseUrl, existingModels2 || void 0);
-        if (api.config.models?.providers) {
-          api.config.models.providers.opencompress = updatedModels;
-        }
-        persistModelsConfig(updatedModels);
-        persistAgentModelsJson(updatedModels);
-        try {
-          await fetch(`${baseUrl}/v1/byok`, {
-            method: "POST",
-            headers: {
-              Authorization: `Bearer ${apiKey2}`,
-              "Content-Type": "application/json"
-            },
-            body: JSON.stringify({ upstreamApiKey: upstreamKey, upstreamBaseUrl })
-          });
-        } catch {
-        }
-        const modelCount2 = existingModels2 ? existingModels2.length : FALLBACK_MODELS.length;
-        return {
-          text: [
-            `Switched to **BYOK mode** (${provider}).`,
-            `Loaded **${modelCount2} models** from your ${provider} account.`,
-            "",
-            "Your upstream key is stored securely on the server, associated with your API key.",
-            "",
-            "To switch back: `/compress_byok off`"
-          ].join("\n")
-        };
+        statusLines.push(
+          "",
+          "**Usage:**",
+          "  `/compress on`   \u2014 Route all providers through OpenCompress",
+          "  `/compress off`  \u2014 Restore original provider configs",
+          "  `/compress-stats` \u2014 View compression savings"
+        );
+        return { text: statusLines.join("\n") };
       }
     });
-    api.logger.info("Registered /compress_byok command");
+    api.logger.info("Registered /compress command");
+    setTimeout(() => {
+      const proxyState = readProxyState();
+      const autoEnable = api.pluginConfig?._autoEnableProxy;
+      if (proxyState.enabled || autoEnable) {
+        const result = enableProxy(api, baseUrl);
+        if (result.proxied.length > 0) {
+          api.logger.info(`Compression active: ${result.proxied.length} providers (${result.proxied.join(", ")})`);
+        }
+      }
+    }, 2e3);
     const os = __require("os");
     const fs = __require("fs");
     const path = __require("path");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencompress/opencompress",
-  "version": "1.8.2",
+  "version": "1.9.0",
   "description": "OpenCompress plugin for OpenClaw — automatic 5-layer prompt compression for any LLM",
   "type": "module",
   "main": "dist/index.js",