@opencompress/opencompress 1.6.6 → 1.7.0

package/dist/index.js

@@ -6,7 +6,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/index.ts
-var VERSION = "1.6.6";
+var VERSION = "1.7.0";
 var DEFAULT_BASE_URL = "https://www.opencompress.ai/api";
 function getApiKey(api) {
   const auth = api.config.auth;
@@ -269,6 +269,151 @@ function persistAuthProfile(apiKey) {
   } catch {
   }
 }
+function proxyStatePath() {
+  const os = __require("os");
+  const path = __require("path");
+  return path.join(os.homedir(), ".openclaw", "opencompress-proxy.json");
+}
+function readProxyState() {
+  try {
+    const fs = __require("fs");
+    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 writeProxyState(state) {
+  try {
+    const fs = __require("fs");
+    fs.writeFileSync(proxyStatePath(), JSON.stringify(state, null, 2) + "\n");
+  } catch {
+  }
+}
+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;
+    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 {
+          data = JSON.parse(fs.readFileSync(modelsPath, "utf-8"));
+        } catch {
+        }
+        if (!data.providers) data.providers = {};
+      }
+      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(modelsPath, JSON.stringify(data, null, 2) + "\n");
+    }
+  } catch {
+  }
+}
+function enableProxy(api, baseUrl) {
+  const occKey = getApiKey(api);
+  if (!occKey) return { proxied: [], skipped: [] };
+  const providers = api.config.models?.providers;
+  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 === "anthropic-messages" || 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
+    };
+    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 };
+}
+function disableProxy(api) {
+  const state = readProxyState();
+  if (!state.enabled) return [];
+  const providers = api.config.models?.providers;
+  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"];
+        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",
@@ -375,7 +520,7 @@ var opencompressProvider = {
 var plugin = {
   id: "opencompress",
   name: "OpenCompress",
-  description: "5-layer prompt compression \u2014 53% input reduction, 62% latency cut, 96% quality",
+  description: "5-layer prompt compression \u2014 40-60% cost reduction, 62% latency cut, 6ms CompactClassifier",
   version: VERSION,
   register(api) {
     const baseUrl = api.pluginConfig?.baseUrl || DEFAULT_BASE_URL;
@@ -572,6 +717,82 @@ var plugin = {
       }
     });
     api.logger.info("Registered /compress-byok command");
+    api.registerCommand({
+      name: "compress",
+      description: "Toggle transparent compression for all LLM providers",
+      acceptsArgs: true,
+      requireAuth: false,
+      handler: async (ctx) => {
+        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.",
+            ""
+          ];
+          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") };
+        }
+        if (arg === "off" || arg === "disable") {
+          const restored = disableProxy(api);
+          if (restored.length === 0) {
+            return { text: "Compression proxy was not active." };
+          }
+          return {
+            text: [
+              "**Compression disabled.** Restored original provider configs.",
+              "",
+              `Restored: ${restored.join(", ")}`,
+              "",
+              "To re-enable: `/compress on`"
+            ].join("\n")
+          };
+        }
+        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(", ")}`);
+        }
+        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 command");
+    setTimeout(() => {
+      const proxyState = readProxyState();
+      if (proxyState.enabled) {
+        const result = enableProxy(api, baseUrl);
+        if (result.proxied.length > 0) {
+          api.logger.info(`Proxy auto-applied on startup: ${result.proxied.length} providers (${result.proxied.join(", ")})`);
+        }
+      }
+    }, 2e3);
     const os = __require("os");
     const fs = __require("fs");
     const path = __require("path");
@@ -580,46 +801,46 @@ var plugin = {
       fs.mkdirSync(logDir, { recursive: true });
     } catch {
     }
-    api.on("llm_input", async (event) => {
+    api.on("llm_input", (...args) => {
       try {
         const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-        const systemPromptLen = event.systemPrompt?.length || 0;
-        const historyLen = Array.isArray(event.historyMessages) ? event.historyMessages.length : 0;
-        const promptLen = event.prompt?.length || 0;
+        const event = args[0] || {};
+        const systemPromptLen = typeof event.systemPrompt === "string" ? event.systemPrompt.length : 0;
+        const historyMessages = Array.isArray(event.historyMessages) ? event.historyMessages : [];
+        const promptLen = typeof event.prompt === "string" ? event.prompt.length : 0;
         const systemTokens = Math.ceil(systemPromptLen / 4);
-        const historyText = JSON.stringify(event.historyMessages || []);
+        const historyText = JSON.stringify(historyMessages);
         const historyTokens = Math.ceil(historyText.length / 4);
         const promptTokens = Math.ceil(promptLen / 4);
         const totalTokens = systemTokens + historyTokens + promptTokens;
         const entry = {
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          _argCount: args.length,
+          _eventKeys: Object.keys(event),
           runId: event.runId,
           sessionId: event.sessionId,
           provider: event.provider,
           model: event.model,
           imagesCount: event.imagesCount || 0,
-          tokenEstimate: {
-            systemPrompt: systemTokens,
-            history: historyTokens,
-            currentPrompt: promptTokens,
-            total: totalTokens
-          },
-          charLengths: {
-            systemPrompt: systemPromptLen,
-            history: historyText.length,
-            currentPrompt: promptLen
-          },
-          historyMessageCount: historyLen,
+          tokenEstimate: { systemPrompt: systemTokens, history: historyTokens, currentPrompt: promptTokens, total: totalTokens },
+          charLengths: { systemPrompt: systemPromptLen, history: historyText.length, currentPrompt: promptLen },
+          historyMessageCount: historyMessages.length,
           systemPrompt: event.systemPrompt,
           historyMessages: event.historyMessages,
           prompt: event.prompt
         };
-        const filename = `${ts}_${event.model || "unknown"}.json`;
-        fs.writeFileSync(
-          path.join(logDir, filename),
-          JSON.stringify(entry, null, 2) + "\n"
-        );
-      } catch {
+        const model = typeof event.model === "string" ? event.model.replace(/\//g, "_") : "unknown";
+        const filename = `${ts}_${model}.json`;
+        fs.writeFileSync(path.join(logDir, filename), JSON.stringify(entry, null, 2) + "\n");
+      } catch (err) {
+        try {
+          const errFile = path.join(logDir, `error_${Date.now()}.txt`);
+          fs.writeFileSync(errFile, `${err}
+${err.stack || ""}
+args: ${JSON.stringify(args?.map((a) => typeof a))}
+`);
+        } catch {
+        }
       }
     });
     api.logger.info(`LLM input logging enabled \u2192 ${logDir}`);

package/package.json

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