@opencompress/opencompress 1.9.2 → 2.0.0

package/dist/index.d.ts

@@ -0,0 +1,84 @@
+/**
+ * OpenCompress Plugin for OpenClaw v2
+ *
+ * Registers as a Provider — users select opencompress/* models.
+ * Runs a local HTTP proxy that compresses requests via opencompress.ai
+ * then forwards to the user's upstream provider. Keys stay local.
+ */
+type ModelApi = "openai-completions" | "openai-responses" | "anthropic-messages" | "google-generative-ai";
+type ModelDefinitionConfig = {
+    id: string;
+    name: string;
+    api?: ModelApi;
+    reasoning?: boolean;
+    input?: string[];
+    cost?: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+    };
+    contextWindow?: number;
+    maxTokens?: number;
+    [key: string]: unknown;
+};
+type ModelProviderConfig = {
+    baseUrl: string;
+    apiKey?: string;
+    api?: ModelApi;
+    models: ModelDefinitionConfig[];
+    [key: string]: unknown;
+};
+type ProviderPlugin = {
+    id: string;
+    label: string;
+    aliases?: string[];
+    envVars?: string[];
+    models?: ModelProviderConfig;
+    auth: Array<{
+        id: string;
+        label: string;
+        hint?: string;
+        kind: string;
+        run: (ctx: any) => Promise<any>;
+    }>;
+};
+type OpenClawPluginApi = {
+    id: string;
+    name: string;
+    version?: string;
+    config: Record<string, any>;
+    pluginConfig?: Record<string, any>;
+    logger: {
+        info: (msg: string) => void;
+        warn: (msg: string) => void;
+        error: (msg: string) => void;
+    };
+    registerProvider: (provider: ProviderPlugin) => void;
+    registerService: (service: {
+        id: string;
+        start: () => void | Promise<void>;
+        stop?: () => void | Promise<void>;
+    }) => void;
+    registerCommand: (command: {
+        name: string;
+        description: string;
+        acceptsArgs?: boolean;
+        handler: (ctx: {
+            args?: string;
+        }) => Promise<{
+            text: string;
+        }>;
+    }) => void;
+    resolvePath: (input: string) => string;
+    on: (hookName: string, handler: unknown) => void;
+};
+declare const plugin: {
+    id: string;
+    name: string;
+    description: string;
+    version: string;
+    register(api: OpenClawPluginApi): void;
+};
+
+export { plugin as default };

package/dist/index.js

@@ -1,512 +1,417 @@
-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 = "2.0.0";
+var PROXY_PORT = 8401;
+var PROXY_HOST = "127.0.0.1";
+var OCC_API = "https://www.opencompress.ai/api";
+var PROVIDER_ID = "opencompress";
 
-// src/index.ts
-var VERSION = "1.9.2";
-var DEFAULT_BASE_URL = "https://www.opencompress.ai/api";
-function getApiKey(api2) {
-  const auth = api2.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 (api2.pluginConfig?.apiKey) return api2.pluginConfig.apiKey;
-  return void 0;
-}
-function persistApiKey(api2, apiKey) {
-  try {
-    const fs = __require("fs");
-    const path = __require("path");
-    const agentDir = api2.resolvePath(".");
-    const authPath = path.join(agentDir, "auth-profiles.json");
-    let profiles = {
-      version: 1,
-      profiles: {}
-    };
-    if (fs.existsSync(authPath)) {
-      try {
-        profiles = JSON.parse(fs.readFileSync(authPath, "utf-8"));
-      } catch {
-      }
+// src/models.ts
+function resolveUpstream(modelId, providers) {
+  const stripped = modelId.replace(/^opencompress\//, "");
+  if (stripped === "auto") {
+    for (const [id, config2] of Object.entries(providers)) {
+      if (id === "opencompress") continue;
+      const firstModel = config2.models?.[0]?.id;
+      if (!firstModel) continue;
+      return {
+        upstreamProvider: id,
+        upstreamModel: firstModel,
+        upstreamKey: config2.apiKey,
+        upstreamBaseUrl: config2.baseUrl,
+        upstreamApi: config2.api || "openai-completions"
+      };
     }
-    profiles.profiles["opencompress:default"] = {
-      type: "api_key",
-      provider: "opencompress",
-      key: apiKey
-    };
-    fs.writeFileSync(authPath, JSON.stringify(profiles, null, 2) + "\n");
-  } catch {
+    return null;
   }
-}
-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 {
+  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"
+    };
   }
+  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"
+  };
 }
-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 generateModelCatalog(providers) {
+  const models = [];
+  for (const [providerId, config] of Object.entries(providers)) {
+    if (providerId === "opencompress") continue;
+    for (const model of config.models || []) {
+      models.push({
+        ...model,
+        id: `opencompress/${providerId}/${model.id}`,
+        name: `${model.name || model.id} (compressed)`,
+        api: config.api || "openai-completions"
+      });
+    }
   }
+  models.unshift({
+    id: "opencompress/auto",
+    name: "OpenCompress Auto (compressed, uses default provider)",
+    api: "openai-completions",
+    reasoning: false,
+    input: ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 2e5,
+    maxTokens: 8192
+  });
+  return models;
 }
-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");
+
+// src/proxy.ts
+import http from "http";
+var server = null;
+function startProxy(getProviders2, getOccKey2) {
+  if (server) return server;
+  server = http.createServer(async (req, res) => {
+    if (req.url === "/health" && req.method === "GET") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "ok", version: "2.0.0" }));
+      return;
     }
-  } 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)) {
+    if (req.method !== "POST") {
+      res.writeHead(405);
+      res.end("Method not allowed");
+      return;
+    }
+    const isMessages = req.url === "/v1/messages";
+    const isCompletions = req.url === "/v1/chat/completions";
+    if (!isMessages && !isCompletions) {
+      res.writeHead(404);
+      res.end("Not found");
+      return;
+    }
+    try {
+      const body = await readBody(req);
+      const parsed = JSON.parse(body);
+      const modelId = parsed.model || "opencompress/auto";
+      const upstream = resolveUpstream(modelId, getProviders2());
+      if (!upstream) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          error: { message: `Cannot resolve upstream for model: ${modelId}. Check your provider config.` }
+        }));
+        return;
+      }
+      const occKey = getOccKey2();
+      if (!occKey) {
+        res.writeHead(401, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          error: { message: "No OpenCompress API key. Run: openclaw onboard opencompress" }
+        }));
+        return;
+      }
+      const occEndpoint = upstream.upstreamApi === "anthropic-messages" ? `${OCC_API}/v1/messages` : `${OCC_API}/v1/chat/completions`;
+      const headers = {
+        "Content-Type": "application/json",
+        "x-api-key": occKey
+      };
+      if (upstream.upstreamKey) {
+        headers["x-upstream-key"] = upstream.upstreamKey;
+      }
+      if (upstream.upstreamBaseUrl) {
+        headers["x-upstream-base-url"] = upstream.upstreamBaseUrl;
+      }
+      if (upstream.upstreamApi === "anthropic-messages") {
+        headers["anthropic-version"] = req.headers["anthropic-version"] || "2023-06-01";
+      }
+      for (const [key, val] of Object.entries(req.headers)) {
+        if (key.startsWith("anthropic-") && typeof val === "string") {
+          headers[key] = val;
+        }
+      }
+      parsed.model = upstream.upstreamModel;
+      const isStream = parsed.stream !== false;
+      if (isStream) {
+        res.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive"
+        });
+        const heartbeat = setInterval(() => {
+          try {
+            res.write(": heartbeat\n\n");
+          } catch {
+            clearInterval(heartbeat);
+          }
+        }, 2e3);
+        try {
+          const occRes = await fetch(occEndpoint, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(parsed)
+          });
+          clearInterval(heartbeat);
+          if (!occRes.ok) {
+            const fallbackRes = await directUpstream(upstream, parsed, req.headers);
+            if (fallbackRes) {
+              for await (const chunk of fallbackRes.body) {
+                res.write(chunk);
+              }
+            } else {
+              res.write(`data: ${JSON.stringify({ error: { message: `OpenCompress error: ${occRes.status}` } })}
+
+`);
+            }
+            res.end();
+            return;
+          }
+          for await (const chunk of occRes.body) {
+            res.write(chunk);
+          }
+          res.end();
+        } catch (err) {
+          clearInterval(heartbeat);
+          try {
+            const fallbackRes = await directUpstream(upstream, parsed, req.headers);
+            if (fallbackRes) {
+              for await (const chunk of fallbackRes.body) {
+                res.write(chunk);
+              }
+            }
+          } catch {
+          }
+          res.end();
+        }
+      } else {
         try {
-          data = JSON.parse(fs.readFileSync(modelsPath, "utf-8"));
+          const occRes = await fetch(occEndpoint, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(parsed)
+          });
+          if (!occRes.ok) {
+            const fallbackRes = await directUpstream(upstream, parsed, req.headers);
+            const fallbackBody = fallbackRes ? await fallbackRes.text() : JSON.stringify({ error: { message: "Compression + direct both failed" } });
+            res.writeHead(fallbackRes?.status || 502, { "Content-Type": "application/json" });
+            res.end(fallbackBody);
+            return;
+          }
+          const data = await occRes.text();
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(data);
         } catch {
+          const fallbackRes = await directUpstream(upstream, parsed, req.headers);
+          const fallbackBody = fallbackRes ? await fallbackRes.text() : JSON.stringify({ error: { message: "Both paths failed" } });
+          res.writeHead(fallbackRes?.status || 502, { "Content-Type": "application/json" });
+          res.end(fallbackBody);
         }
-        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 (err) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: { message: String(err) } }));
     }
-  } catch {
-  }
+  });
+  server.listen(PROXY_PORT, PROXY_HOST, () => {
+  });
+  server.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      server = null;
+    }
+  });
+  return server;
 }
-function enableProxy(api2, baseUrl) {
-  const occKey = getApiKey(api2);
-  if (!occKey) return { proxied: [], skipped: [] };
-  let providers = api2.config.models?.providers;
-  let source = "api.config";
-  if (!providers || Object.keys(providers).length === 0) {
-    providers = readProvidersFromDisk();
-    source = "disk (openclaw.json)";
+function stopProxy() {
+  if (server) {
+    server.close();
+    server = null;
   }
-  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
+}
+async function directUpstream(upstream, body, originalHeaders) {
+  try {
+    const url = upstream.upstreamApi === "anthropic-messages" ? `${upstream.upstreamBaseUrl}/v1/messages` : `${upstream.upstreamBaseUrl}/v1/chat/completions`;
+    const headers = {
+      "Content-Type": "application/json"
     };
-    if (pApi === "anthropic-messages") {
-      provider.headers = {
-        ...provider.headers || {},
-        "x-upstream-key": provider.apiKey || ""
-      };
-      provider.baseUrl = `${baseUrl}/v1`;
-      provider.apiKey = occKey;
+    if (upstream.upstreamApi === "anthropic-messages") {
+      headers["x-api-key"] = upstream.upstreamKey || "";
+      headers["anthropic-version"] = originalHeaders["anthropic-version"] || "2023-06-01";
     } else {
-      provider.headers = {
-        ...provider.headers || {},
-        "X-Upstream-Key": provider.apiKey || "",
-        "X-Upstream-Base-Url": provider.baseUrl
-      };
-      provider.baseUrl = `${baseUrl}/v1`;
-      provider.apiKey = occKey;
+      headers["Authorization"] = `Bearer ${upstream.upstreamKey || ""}`;
     }
-    persistProviderToDisk(id, provider);
-    proxied.push(id);
+    return await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+  } catch {
+    return null;
   }
-  state.enabled = true;
-  writeProxyState(state);
-  return { proxied, skipped, source };
 }
-function disableProxy(api2) {
-  const state = readProxyState();
-  if (!state.enabled) return [];
-  let providers = api2.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"];
-        delete h["x-upstream-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;
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    req.on("data", (chunk) => data += chunk);
+    req.on("end", () => resolve(data));
+    req.on("error", reject);
+  });
 }
-var opencompressProvider = {
-  id: "opencompress",
-  label: "OpenCompress",
-  docsPath: "https://docs.opencompress.ai",
-  aliases: ["oc", "compress"],
-  envVars: ["OPENCOMPRESS_API_KEY"],
-  // 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: "Compress all LLM calls automatically \u2014 save 40-60% on any provider",
-      kind: "custom",
-      run: async (ctx) => {
-        ctx.prompter.note(
-          "\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 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({})
-            // 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" } }));
-            spinner.stop("Setup failed");
-            throw new Error(
-              `Provisioning failed: ${err.error?.message || res.statusText}`
-            );
-          }
-          const data = await res.json();
-          spinner.stop("Account created!");
-          persistApiKey(api, 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;
+
+// src/index.ts
+function getOccKey(api) {
+  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;
+  return void 0;
+}
+function getProviders(api) {
+  return api.config.models?.providers || {};
+}
+function createProvider(api) {
+  return {
+    id: PROVIDER_ID,
+    label: "OpenCompress (BYOK Compression Proxy)",
+    aliases: ["oc", "compress"],
+    envVars: ["OPENCOMPRESS_API_KEY"],
+    // Dynamic model catalog — mirrors user's existing providers
+    models: {
+      baseUrl: `http://${PROXY_HOST}:${PROXY_PORT}/v1`,
+      api: "openai-completions",
+      models: generateModelCatalog(getProviders(api))
+    },
+    auth: [
+      {
+        id: "api-key",
+        label: "OpenCompress",
+        hint: "Save 20-40% on any LLM. Your API keys stay local.",
+        kind: "custom",
+        run: async (ctx) => {
+          ctx.prompter.note(
+            "\u{1F99E} OpenCompress \u2014 compress every LLM call, save 20-40%\n\nYour existing API keys (Claude, GPT, etc.) stay on your machine.\nWe just compress the prompts before they're sent."
+          );
+          const spinner = ctx.prompter.progress("Creating your account...");
+          try {
+            const res = await fetch(`${OCC_API}/v1/provision`, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({})
+            });
+            if (!res.ok) {
+              spinner.stop("Failed");
+              throw new Error(`Provisioning failed: ${res.statusText}`);
             }
-          });
-          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: [
-              {
+            const data = await res.json();
+            spinner.stop("Account created!");
+            return {
+              profiles: [{
                 profileId: "default",
                 credential: { apiKey: data.apiKey }
-              }
-            ],
-            configPatch: shouldEnable ? { _autoEnableProxy: true } : void 0,
-            notes
-          };
-        } catch (err) {
-          spinner.stop("Setup failed");
-          throw err instanceof Error ? err : new Error(String(err));
+              }],
+              notes: [
+                "\u{1F99E} OpenCompress ready!",
+                `\u{1F4B0} ${data.freeCredit} free credit.`,
+                "",
+                "Select any opencompress/* model to use compression.",
+                "Your existing provider keys are used automatically.",
+                "",
+                "Dashboard: https://www.opencompress.ai/dashboard"
+              ]
+            };
+          } catch (err) {
+            spinner.stop("Failed");
+            throw err instanceof Error ? err : new Error(String(err));
+          }
         }
       }
-    }
-  ]
-};
+    ]
+  };
+}
 var plugin = {
   id: "opencompress",
   name: "OpenCompress",
-  description: "Transparent prompt compression \u2014 save 40-70% on Claude, GPT, and any LLM provider",
+  description: "BYOK prompt compression \u2014 save 20-40% on any LLM provider",
   version: VERSION,
-  register(api2) {
-    const baseUrl = api2.pluginConfig?.baseUrl || DEFAULT_BASE_URL;
-    api2.registerProvider(opencompressProvider);
-    const apiKey = getApiKey(api2);
-    if (apiKey) {
-      persistApiKey(api2, apiKey);
-    }
-    api2.logger.info("OpenCompress registered (transparent proxy mode)");
-    api2.registerCommand({
+  register(api) {
+    api.registerProvider(createProvider(api));
+    api.logger.info(`OpenCompress v${VERSION} registered as provider`);
+    api.registerService({
+      id: "opencompress-proxy",
+      start: () => {
+        startProxy(
+          () => getProviders(api),
+          () => getOccKey(api)
+        );
+        api.logger.info(`Compression proxy started on ${PROXY_HOST}:${PROXY_PORT}`);
+      },
+      stop: () => {
+        stopProxy();
+        api.logger.info("Compression proxy stopped");
+      }
+    });
+    api.registerCommand({
       name: "compress-stats",
-      description: "Show OpenCompress usage statistics and savings",
-      acceptsArgs: true,
-      requireAuth: false,
+      description: "Show compression savings and balance",
       handler: async () => {
-        const apiKey2 = getApiKey(api2);
-        if (!apiKey2) {
-          return {
-            text: "No API key found. Run `openclaw onboard opencompress` to set up."
-          };
+        const occKey = getOccKey(api);
+        if (!occKey) {
+          return { text: "No API key. Run `openclaw onboard opencompress` first." };
         }
         try {
-          const res = await fetch(`${baseUrl}/user/stats`, {
-            headers: { Authorization: `Bearer ${apiKey2}` }
+          const res = await fetch(`${OCC_API}/user/stats`, {
+            headers: { Authorization: `Bearer ${occKey}` }
           });
-          if (!res.ok) {
-            return { text: `Failed to fetch stats: HTTP ${res.status}` };
-          }
-          const stats = await res.json();
-          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();
-          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(
-              "",
-              "\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)}`
-          };
-        }
-      }
-    });
-    api2.logger.info("Registered /compress-stats command");
-    api2.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(api2);
-          if (!occKey2) {
-            return { text: "No API key found. Run `openclaw onboard opencompress` first." };
-          }
-          const result = enableProxy(api2, 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") };
-        }
-        if (arg === "off" || arg === "disable") {
-          const restored = disableProxy(api2);
-          if (restored.length === 0) {
-            return { text: "Compression proxy was not active." };
-          }
+          if (!res.ok) return { text: `Failed: HTTP ${res.status}` };
+          const s = await res.json();
+          const balance = Number(s.balanceUsd || s.balance || 0);
+          const calls = s.monthlyApiCalls ?? s.totalCalls ?? 0;
+          const rate = s.avgCompressionRate ? `${(Number(s.avgCompressionRate) * 100).toFixed(1)}%` : "N/A";
           return {
             text: [
-              "**Compression disabled.** Restored original provider configs.",
-              "",
-              `Restored: ${restored.join(", ")}`,
+              "```",
+              "\u{1F99E} OpenCompress Stats",
+              "=====================",
+              `Balance:         $${balance.toFixed(2)}`,
+              `API calls:       ${calls}`,
+              `Avg compression: ${rate}`,
+              `Tokens saved:    ${(Number(s.totalOriginalTokens || 0) - Number(s.totalCompressedTokens || 0)).toLocaleString()}`,
+              "```",
               "",
-              "To re-enable: `/compress on`"
+              balance < 0.5 ? `\u26A0\uFE0F Low balance! Link account for $10 bonus: https://www.opencompress.ai/dashboard?link=${encodeURIComponent(occKey)}` : "Dashboard: https://www.opencompress.ai/dashboard"
             ].join("\n")
           };
+        } catch (err) {
+          return { text: `Error: ${err instanceof Error ? err.message : String(err)}` };
         }
-        const proxyState = readProxyState();
-        const occKey = getApiKey(api2);
-        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") };
       }
     });
-    api2.logger.info("Registered /compress command");
-    setTimeout(() => {
-      const proxyState = readProxyState();
-      const autoEnable = api2.pluginConfig?._autoEnableProxy;
-      if (proxyState.enabled || autoEnable) {
-        const result = enableProxy(api2, baseUrl);
-        if (result.proxied.length > 0) {
-          api2.logger.info(`Compression active: ${result.proxied.length} providers (${result.proxied.join(", ")})`);
-        }
-      }
-    }, 2e3);
-    const os = __require("os");
-    const fs = __require("fs");
-    const path = __require("path");
-    const logDir = path.join(os.homedir(), ".openclaw", "opencompress-logs");
-    try {
-      fs.mkdirSync(logDir, { recursive: true });
-    } catch {
-    }
-    api2.on("llm_input", (...args) => {
-      try {
-        const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-        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(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: historyMessages.length,
-          systemPrompt: event.systemPrompt,
-          historyMessages: event.historyMessages,
-          prompt: event.prompt
-        };
-        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.registerCommand({
+      name: "compress",
+      description: "Show OpenCompress status and available compressed models",
+      handler: async () => {
+        const occKey = getOccKey(api);
+        const providers = getProviders(api);
+        const models = generateModelCatalog(providers);
+        const lines = [
+          "**OpenCompress Status**",
+          "",
+          `API key: ${occKey ? `${occKey.slice(0, 12)}...` : "not set (run `openclaw onboard opencompress`)"}`,
+          `Proxy: http://${PROXY_HOST}:${PROXY_PORT}`,
+          "",
+          "**Available compressed models:**",
+          ...models.map((m) => `  ${m.id}`),
+          "",
+          "Select any of these models to use compression."
+        ];
+        return { text: lines.join("\n") };
       }
     });
-    api2.logger.info(`LLM input logging enabled \u2192 ${logDir}`);
   }
 };
 var index_default = plugin;

package/openclaw.plugin.json

@@ -1,20 +1,19 @@
 {
   "id": "opencompress",
   "name": "OpenCompress",
-  "description": "5-layer prompt compression — 53% input reduction, 62% latency cut, 96% quality. Save 40-70% on any LLM.",
+  "description": "BYOK prompt compression — save 20-40% on any LLM. Your keys stay local.",
+  "providers": ["opencompress"],
   "configSchema": {
     "type": "object",
     "properties": {
       "apiKey": {
         "type": "string",
         "description": "OpenCompress API key (sk-occ-...)"
-      },
-      "baseUrl": {
-        "type": "string",
-        "default": "https://www.opencompress.ai/api",
-        "description": "OpenCompress API base URL"
       }
     },
     "required": []
+  },
+  "providerAuthEnvVars": {
+    "opencompress": ["OPENCOMPRESS_API_KEY"]
   }
 }

package/openclaw.security.json

@@ -1,14 +1,10 @@
 {
   "id": "opencompress",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "securityProfile": {
     "dataHandling": {
-      "promptContent": "pass-through",
-      "promptStorage": "none",
-      "responseContent": "pass-through",
-      "responseStorage": "none",
-      "upstreamApiKeys": "local-only",
-      "upstreamApiKeyStorage": "never-server-side"
+      "promptContent": "pass-through (compressed in-transit, never stored)",
+      "upstreamApiKeys": "local-only (read from api.config, sent per-request as header, never persisted)"
     },
     "networkAccess": {
       "outbound": [
@@ -16,57 +12,26 @@
           "host": "www.opencompress.ai",
           "port": 443,
           "protocol": "https",
-          "purpose": "API proxy — compress prompts and forward to upstream LLM provider"
-        }
-      ],
-      "inbound": []
-    },
-    "localStorage": {
-      "authProfiles": {
-        "path": "~/.openclaw/agents/*/agent/auth-profiles.json",
-        "content": "OpenCompress API key (sk-occ-*)",
-        "sensitive": true
-      },
-      "providerConfig": {
-        "path": "~/.openclaw/openclaw.json",
-        "content": "Provider config, optional upstream key in headers (BYOK pass-through)",
-        "sensitive": true
-      }
-    },
-    "secrets": {
-      "required": [
+          "purpose": "Compress prompts and forward to user's upstream LLM provider"
+        },
         {
-          "name": "OpenCompress API Key",
-          "format": "sk-occ-*",
-          "purpose": "Authentication and billing for compression service",
-          "serverSideStorage": "hashed (SHA-256), never plaintext"
-        }
-      ],
-      "optional": [
-        {
-          "name": "Upstream LLM API Key",
-          "format": "sk-proj-* / sk-ant-* / sk-or-* / AIza*",
-          "purpose": "BYOK mode — forwarded to user's LLM provider",
-          "serverSideStorage": "NEVER stored. Passed via X-Upstream-Key header per-request, discarded after forwarding."
+          "host": "127.0.0.1",
+          "port": 8401,
+          "protocol": "http",
+          "purpose": "Local proxy — receives requests from OpenClaw, routes to opencompress.ai"
         }
       ]
     },
     "permissions": {
-      "fileSystem": "read/write ~/.openclaw/ config files only",
-      "environment": ["OPENCOMPRESS_API_KEY", "OPENCOMPRESS_LLM_KEY"],
+      "fileSystem": "none (all config via api.config runtime API)",
+      "environment": ["OPENCOMPRESS_API_KEY"],
       "shell": "none",
-      "network": "outbound HTTPS to www.opencompress.ai only"
+      "network": "outbound HTTPS to www.opencompress.ai + local HTTP proxy on 127.0.0.1:8401"
     }
   },
   "privacyPolicy": {
-    "promptsAndResponses": "OpenCompress compresses prompts in-memory and forwards to the upstream LLM provider. Prompt and response content is NEVER stored, logged, or used for training. Only token counts are recorded for billing.",
-    "apiKeys": "Your upstream LLM API key (OpenAI, Anthropic, etc.) is stored ONLY on your local machine. It is sent to our server as a per-request header (X-Upstream-Key) and discarded immediately after forwarding. We never persist your upstream keys.",
-    "billing": "We record: timestamp, model, original token count, compressed token count, cost. We do NOT record prompt content.",
-    "thirdParties": "We do not share any data with third parties. Your requests are forwarded only to the LLM provider you specify."
-  },
-  "auditability": {
-    "pluginSource": "Open source — https://github.com/claw-compactor/openclaw-plugin",
-    "serverSource": "Forwarding logic documented in security docs. Core proxy is open for audit.",
-    "verification": "Users can inspect all network requests via OpenClaw's diagnostics plugin or standard proxy tools."
+    "prompts": "Compressed in-memory and forwarded. NEVER stored or logged.",
+    "upstreamKeys": "Read from OpenClaw runtime config (api.config). Sent per-request via x-upstream-key header. Never persisted server-side.",
+    "billing": "Only token counts recorded (original, compressed, model). No prompt content."
   }
 }

package/package.json

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