@opencompress/opencompress 1.9.2 → 2.0.1

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,423 @@
-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.1";
+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 {
-          data = JSON.parse(fs.readFileSync(modelsPath, "utf-8"));
+          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 {
+          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 (Save Tokens + Improve Quality)",
+    aliases: ["oc", "compress"],
+    envVars: ["OPENCOMPRESS_API_KEY"],
+    // Dynamic model catalog — mirrors user's existing providers
+    // Detect primary provider's API type for compatibility
+    models: (() => {
+      const providers = getProviders(api);
+      const firstProvider = Object.values(providers).find((p) => p.api);
+      const primaryApi = firstProvider?.api || "openai-completions";
+      return {
+        baseUrl: `http://${PROXY_HOST}:${PROXY_PORT}/v1`,
+        api: primaryApi,
+        models: generateModelCatalog(providers)
+      };
+    })(),
+    auth: [
+      {
+        id: "api-key",
+        label: "OpenCompress",
+        hint: "Save tokens and improve quality on any LLM. Your API keys stay local.",
+        kind: "custom",
+        run: async (ctx) => {
+          ctx.prompter.note(
+            "\u{1F99E} OpenCompress \u2014 save tokens and improve 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 sharpen output quality."
+          );
+          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: "Save tokens and improve quality on any LLM \u2014 use your existing providers",
   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": "Save tokens and improve quality on any LLM. Use your existing providers — 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.1",
   "description": "OpenCompress plugin for OpenClaw — automatic 5-layer prompt compression for any LLM",
   "type": "module",
   "main": "dist/index.js",