clawmux 0.1.0

package/README.md

@@ -0,0 +1,178 @@
+![ClawMux logo](./docs/images/clawmux.png)
+# ClawMux
+
+Smart model routing + context compression proxy for OpenClaw.
+
+## Features
+
+- 🧠 **Smart Routing**: Embedding-based semantic classification → LIGHT/MEDIUM/HEAVY tier → automatic model selection
+- 📦 **Context Compression**: Preemptive background summarization at configurable threshold (default 75%)
+- 🔌 **All Providers**: Supports all OpenClaw providers via 6 API format adapters
+- ⚡ **Zero Config Auth**: Uses OpenClaw's existing provider credentials — no separate API keys
+- 📊 **Cost Tracking**: Real-time savings stats at /stats endpoint
+- 🔄 **Hot Reload**: Config changes apply without restart
+
+## Quick Start
+
+Requires [Bun](https://bun.sh) or [Node.js](https://nodejs.org) (18+) and a working OpenClaw installation.
+
+```bash
+# Clone and install
+git clone https://github.com/your-org/ClawMux
+cd ClawMux
+bash scripts/install.sh
+```
+
+The install script:
+1. Detects your OpenClaw config at `~/.openclaw/openclaw.json` (override with `OPENCLAW_CONFIG_PATH`)
+2. Creates `clawmux.json` from the example if it doesn't exist
+3. Registers ClawMux as a provider in your OpenClaw config
+
+Then start the proxy:
+
+```bash
+# Bun (recommended — faster startup & runtime)
+bun run dev        # watch mode (development)
+bun run start      # production
+
+# Node.js
+npm run start:node # requires tsx: npm i -D tsx
+```
+
+Select a provider in OpenClaw and start chatting:
+
+```bash
+openclaw provider clawmux-anthropic
+openclaw chat
+```
+
+## Configuration
+
+Copy `clawmux.example.json` to `clawmux.json` and adjust as needed:
+
+```jsonc
+{
+  "compression": {
+    "threshold": 0.75,       // trigger compression at 75% of context window
+    "model": "anthropic/claude-3-5-haiku-20241022",  // model used for summarization (provider/model format)
+    "targetRatio": 0.6       // compress to 60% of original token count
+  },
+  "routing": {
+    "models": {
+      "LIGHT": "anthropic/claude-3-5-haiku-20241022",
+      "MEDIUM": "anthropic/claude-sonnet-4-20250514",
+      "HEAVY": "anthropic/claude-opus-4-20250514"
+      // Model IDs use 'provider/model' format. Do NOT use provider names starting with "clawmux-" — causes infinite loops
+    },
+    "scoring": {
+      "confidenceThreshold": 0.7  // classification confidence below this → fallback to MEDIUM tier
+    }
+  },
+  "server": {
+    "port": 3456,
+    "host": "127.0.0.1"
+  }
+}
+```
+
+Config is watched for changes. Edit `clawmux.json` while the proxy is running and it reloads automatically.
+
+### Cross-Provider Routing
+
+Mix models from different providers by tier. ClawMux automatically translates request and response formats between providers:
+
+```jsonc
+{
+  "routing": {
+    "models": {
+      "LIGHT": "zai/glm-5",                          // ZAI (openai-completions)
+      "MEDIUM": "anthropic/claude-sonnet-4-20250514",  // Anthropic (anthropic-messages)
+      "HEAVY": "openai/gpt-5.4"                       // OpenAI (openai-completions)
+    }
+  }
+}
+```
+
+All three providers must be configured in your `openclaw.json`. ClawMux handles format translation transparently — a request arriving in Anthropic format gets translated to OpenAI format when routed to GPT, and the response is translated back to Anthropic format before returning to OpenClaw.
+
+Supported translation pairs: Anthropic ↔ OpenAI ↔ Google ↔ Ollama ↔ Bedrock (all combinations).
+
+## Supported Providers
+
+ClawMux registers itself as six providers in OpenClaw, one per API format:
+
+| API Format | Providers |
+|---|---|
+| `anthropic-messages` | Anthropic, Synthetic, Kimi Coding |
+| `openai-completions` | OpenAI, Moonshot, ZAI, Cerebras, vLLM, SGLang, LM Studio, OpenRouter, Together, NVIDIA, Venice, Groq, Mistral, xAI, HuggingFace, Cloudflare, Volcengine, BytePlus, Vercel, Kilocode, Qianfan, ModelStudio, MiniMax, Xiaomi |
+| `openai-responses` | OpenAI (newer), OpenAI Codex |
+| `google-generative-ai` | Google Gemini, Google Vertex |
+| `ollama` | Ollama |
+| `bedrock-converse-stream` | AWS Bedrock |
+
+Use `clawmux-anthropic`, `clawmux-openai`, `clawmux-openai-responses`, `clawmux-google`, `clawmux-ollama`, or `clawmux-bedrock` as the provider name in OpenClaw.
+
+## How It Works
+
+```
+OpenClaw → ClawMux Proxy (localhost:3456) → Upstream Provider(s)
+              │
+              ├── 1. Classify complexity (embedding model, ~4ms first run, <1ms cached)
+              ├── 2. Select tier → LIGHT/MEDIUM/HEAVY
+              ├── 3. Compress context if threshold exceeded
+              ├── 4. Translate request format if cross-provider
+              ├── 5. Forward to upstream with correct model
+              └── 6. Translate response back to original format
+```
+
+**Routing tiers** map to model IDs you configure. A local embedding model (`Xenova/paraphrase-multilingual-MiniLM-L12-v2`) classifies the semantic complexity of each request using nearest-centroid classification (~4ms first run, <1ms cached), supporting both Korean and English. Short queries are detected by a lightweight heuristic and routed to LIGHT tier directly. No external API calls are needed for classification.
+
+**Low confidence fallback**: When the classifier's confidence falls below `confidenceThreshold` (default 0.7), the request is routed to MEDIUM tier regardless of the computed score. This prevents unreliable classifications from sending requests to an inappropriate tier — MEDIUM provides a safe cost/quality balance compared to risking unnecessary cost (HEAVY) or degraded quality (LIGHT).
+
+**Context compression** runs in the background after each response. When the conversation approaches the configured threshold, ClawMux summarizes older messages before the next request goes out. This keeps costs down on long conversations without interrupting the flow.
+
+### Context Window Resolution
+
+ClawMux resolves each model's context window using this priority chain:
+
+1. **clawmux.json** `routing.contextWindows` — explicit per-model override
+2. **openclaw.json** `models.providers[provider].models[].contextWindow` — user config
+3. **OpenClaw built-in catalog** — pi-ai model database (812+ models)
+4. **Default: 200,000 tokens**
+
+Compression threshold uses the **minimum** context window across all routing models, since compression happens before routing decides which model to use.
+
+## API Endpoints
+
+| Method | Path | Description |
+|---|---|---|
+| `GET` | `/health` | Health check |
+| `GET` | `/stats` | Cost savings statistics |
+| `POST` | `/v1/messages` | Anthropic Messages |
+| `POST` | `/v1/chat/completions` | OpenAI Chat Completions |
+| `POST` | `/v1/responses` | OpenAI Responses |
+| `POST` | `/v1beta/models/*` | Google Generative AI |
+| `POST` | `/api/chat` | Ollama |
+| `POST` | `/model/*/converse-stream` | Bedrock |
+
+## Development
+
+```bash
+bun run dev          # start with watch mode
+bun test             # run all tests
+bun run typecheck    # type check without emit
+```
+
+Tests are co-located with source files as `*.test.ts`.
+
+## Uninstall
+
+```bash
+bash scripts/uninstall.sh
+```
+
+Removes all `clawmux-*` providers from your OpenClaw config. Your original config is backed up before any changes.
+
+## License
+
+MIT

package/bin/clawmux.cjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require("../dist/cli.cjs");

package/clawmux.example.json

@@ -0,0 +1,33 @@
+{
+  "_comment": "ClawMux configuration — copy this file to clawmux.json and adjust values.",
+  "compression": {
+    "threshold": 0.75,
+    "_comment_threshold": "Token ratio (0.1–0.95) that triggers context compression.",
+    "model": "anthropic/claude-3-5-haiku-20241022",
+    "_comment_model": "Model ID in 'provider/model' format used for the compression summarisation call.",
+    "targetRatio": 0.6,
+    "_comment_targetRatio": "Desired compression ratio (0.2–0.9). 0.6 = compress to 60% of original."
+  },
+  "routing": {
+    "models": {
+      "LIGHT": "anthropic/claude-3-5-haiku-20241022",
+      "MEDIUM": "anthropic/claude-sonnet-4-20250514",
+      "HEAVY": "anthropic/claude-opus-4-20250514",
+      "_comment_models": "Model IDs in 'provider/model' format for each routing tier. Do NOT use provider names starting with 'clawmux-' — this causes infinite loops."
+    },
+    "scoring": {
+      "confidenceThreshold": 0.7,
+      "_comment_confidenceThreshold": "Classification confidence below this threshold triggers a fallback to MEDIUM tier (range: 0.0–1.0)."
+    },
+    "contextWindows": {
+      "_comment_contextWindows": "Optional per-model context window overrides (in tokens). Keys use 'provider/model' format.",
+      "zai/glm-5": 204800,
+      "openai/gpt-5.4": 400000
+    }
+  },
+  "server": {
+    "port": 3456,
+    "host": "127.0.0.1",
+    "_comment_server": "Proxy listen address. Port range: 1024–65535."
+  }
+}

package/dist/cli.cjs

@@ -0,0 +1,376 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/proxy/node-http-adapter.ts
+var exports_node_http_adapter = {};
+__export(exports_node_http_adapter, {
+  writeWebResponse: () => writeWebResponse,
+  toWebRequest: () => toWebRequest
+});
+function toWebRequest(req) {
+  const protocol = "http";
+  const host = req.headers.host ?? "localhost";
+  const url = `${protocol}://${host}${req.url ?? "/"}`;
+  const headers = new Headers;
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value === undefined)
+      continue;
+    if (Array.isArray(value)) {
+      for (const v of value)
+        headers.append(key, v);
+    } else {
+      headers.set(key, value);
+    }
+  }
+  const method = (req.method ?? "GET").toUpperCase();
+  const hasBody = method !== "GET" && method !== "HEAD";
+  const init = {
+    method,
+    headers,
+    body: hasBody ? toReadableStream(req) : undefined
+  };
+  if (hasBody)
+    init.duplex = "half";
+  return new Request(url, init);
+}
+function toReadableStream(req) {
+  return new ReadableStream({
+    start(controller) {
+      req.on("data", (chunk) => controller.enqueue(new Uint8Array(chunk)));
+      req.on("end", () => controller.close());
+      req.on("error", (err) => controller.error(err));
+    }
+  });
+}
+async function writeWebResponse(res, response) {
+  res.writeHead(response.status, Object.fromEntries(response.headers.entries()));
+  if (!response.body) {
+    res.end();
+    return;
+  }
+  const reader = response.body.getReader();
+  try {
+    for (;; ) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      const flushed = res.write(value);
+      if (!flushed) {
+        await new Promise((resolve) => res.once("drain", resolve));
+      }
+    }
+  } finally {
+    reader.releaseLock();
+    res.end();
+  }
+}
+
+// src/cli.ts
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+
+// src/proxy/router.ts
+var VERSION = "0.1.0";
+function jsonResponse(body, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json" }
+  });
+}
+function stubNotImplemented(name) {
+  return async () => jsonResponse({ error: `${name} not implemented yet` }, 501);
+}
+var customHandlers = new Map;
+var routes = [
+  {
+    method: "GET",
+    match: (p) => p === "/health",
+    handler: async () => jsonResponse({ status: "ok", version: VERSION }),
+    key: "/health"
+  },
+  {
+    method: "GET",
+    match: (p) => p === "/stats",
+    handler: async () => jsonResponse({ message: "stats not implemented yet" }),
+    key: "/stats"
+  },
+  {
+    method: "POST",
+    match: (p) => p === "/v1/messages",
+    handler: stubNotImplemented("anthropic"),
+    key: "/v1/messages"
+  },
+  {
+    method: "POST",
+    match: (p) => p === "/v1/chat/completions",
+    handler: stubNotImplemented("openai-completions"),
+    key: "/v1/chat/completions"
+  },
+  {
+    method: "POST",
+    match: (p) => p === "/v1/responses",
+    handler: stubNotImplemented("openai-responses"),
+    key: "/v1/responses"
+  },
+  {
+    method: "POST",
+    match: (p) => p.startsWith("/v1beta/models/"),
+    handler: stubNotImplemented("google"),
+    key: "/v1beta/models/*"
+  },
+  {
+    method: "POST",
+    match: (p) => p === "/api/chat",
+    handler: stubNotImplemented("ollama"),
+    key: "/api/chat"
+  },
+  {
+    method: "POST",
+    match: (p) => p.startsWith("/model/") && p.endsWith("/converse-stream"),
+    handler: stubNotImplemented("bedrock"),
+    key: "/model/*/converse-stream"
+  }
+];
+async function parseJsonBody(req) {
+  const contentType = req.headers.get("content-type") ?? "";
+  if (!contentType.includes("application/json")) {
+    return { body: null, error: null };
+  }
+  try {
+    const text = await req.text();
+    if (text.length === 0) {
+      return { body: null, error: null };
+    }
+    return { body: JSON.parse(text), error: null };
+  } catch {
+    return {
+      body: null,
+      error: jsonResponse({ error: "invalid JSON body" }, 400)
+    };
+  }
+}
+async function dispatch(req) {
+  const url = new URL(req.url);
+  const { pathname } = url;
+  const method = req.method.toUpperCase();
+  for (const route of routes) {
+    if (route.method === method && route.match(pathname)) {
+      const handler = customHandlers.get(route.key) ?? route.handler;
+      if (method === "POST") {
+        const { body, error } = await parseJsonBody(req);
+        if (error)
+          return error;
+        return handler(req, body);
+      }
+      return handler(req, null);
+    }
+  }
+  return jsonResponse({ error: "not found" }, 404);
+}
+
+// src/utils/runtime.ts
+var isBun = typeof globalThis.Bun !== "undefined";
+
+// src/proxy/server.ts
+function createServer(config) {
+  if (isBun) {
+    return createBunServer(config);
+  }
+  return createNodeServer(config);
+}
+function createBunServer(config) {
+  let server = null;
+  return {
+    start() {
+      if (server)
+        return;
+      const bun = globalThis.Bun;
+      server = bun.serve({
+        port: config.port,
+        hostname: config.host,
+        fetch: dispatch
+      });
+    },
+    stop() {
+      if (!server)
+        return;
+      server.stop(true);
+      server = null;
+    }
+  };
+}
+function createNodeServer(config) {
+  let server = null;
+  return {
+    async start() {
+      if (server)
+        return;
+      const { createServer: createHttpServer } = await import("node:http");
+      const { toWebRequest: toWebRequest2, writeWebResponse: writeWebResponse2 } = await Promise.resolve().then(() => exports_node_http_adapter);
+      const httpServer = createHttpServer(async (req, res) => {
+        try {
+          const webReq = toWebRequest2(req);
+          const webRes = await dispatch(webReq);
+          await writeWebResponse2(res, webRes);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          res.writeHead(500, { "content-type": "application/json" });
+          res.end(JSON.stringify({ error: message }));
+        }
+      });
+      await new Promise((resolve) => {
+        httpServer.listen(config.port, config.host, resolve);
+      });
+      server = httpServer;
+    },
+    stop() {
+      if (!server)
+        return;
+      server.close();
+      server = null;
+    }
+  };
+}
+
+// src/cli.ts
+var VERSION2 = process.env.npm_package_version ?? "0.1.0";
+var HELP = `Usage: clawmux <command>
+
+Commands:
+  init      Detect OpenClaw config, create clawmux.json, register providers
+  start     Start the proxy server (foreground)
+  version   Print version
+  help      Show this help message
+
+Options:
+  --port, -p <port>   Override server port (default: 3456)
+
+Environment:
+  CLAWMUX_PORT            Server port override
+  OPENCLAW_CONFIG_PATH    Path to openclaw.json`;
+var PROVIDERS = [
+  { key: "clawmux-anthropic", api: "anthropic-messages" },
+  { key: "clawmux-openai", api: "openai-completions" },
+  { key: "clawmux-openai-responses", api: "openai-responses" },
+  { key: "clawmux-google", api: "google-generative-ai" },
+  { key: "clawmux-ollama", api: "ollama" },
+  { key: "clawmux-bedrock", api: "bedrock-converse-stream" }
+];
+async function fileExistsLocal(path) {
+  try {
+    await import_promises.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function init() {
+  const homeDir = process.env.HOME ?? "/root";
+  const openclawConfigPath = process.env.OPENCLAW_CONFIG_PATH ?? import_node_path.join(homeDir, ".openclaw", "openclaw.json");
+  if (!await fileExistsLocal(openclawConfigPath)) {
+    console.error(`[error] OpenClaw config not found at ${openclawConfigPath}`);
+    console.error("Set OPENCLAW_CONFIG_PATH or ensure ~/.openclaw/openclaw.json exists");
+    process.exit(1);
+  }
+  console.log(`[info] Using OpenClaw config: ${openclawConfigPath}`);
+  const backupPath = `${openclawConfigPath}.bak.${Date.now()}`;
+  await import_promises.copyFile(openclawConfigPath, backupPath);
+  console.log(`[info] Backup created: ${backupPath}`);
+  const clawmuxJsonPath = import_node_path.join(process.cwd(), "clawmux.json");
+  const examplePath = import_node_path.join(process.cwd(), "clawmux.example.json");
+  if (!await fileExistsLocal(clawmuxJsonPath)) {
+    if (await fileExistsLocal(examplePath)) {
+      await import_promises.copyFile(examplePath, clawmuxJsonPath);
+      console.log("[info] Created clawmux.json from clawmux.example.json");
+    } else {
+      console.warn("[warn] clawmux.json not found and no clawmux.example.json to copy from");
+    }
+  }
+  const raw = await import_promises.readFile(openclawConfigPath, "utf-8");
+  const config = JSON.parse(raw);
+  if (!config.models)
+    config.models = {};
+  const models = config.models;
+  if (!models.providers)
+    models.providers = {};
+  const providers = models.providers;
+  let added = 0;
+  for (const { key, api } of PROVIDERS) {
+    if (providers[key]) {
+      console.log(`  skip  ${key} (already exists)`);
+      continue;
+    }
+    providers[key] = {
+      baseUrl: "http://localhost:3456",
+      api,
+      models: [{ id: "auto", name: "ClawMux Auto Router" }]
+    };
+    added++;
+    console.log(`  added ${key}`);
+  }
+  if (added > 0) {
+    await import_promises.writeFile(openclawConfigPath, JSON.stringify(config, null, 2) + `
+`);
+    console.log(`
+Added ${added} provider(s) to openclaw.json`);
+  } else {
+    console.log(`
+All ClawMux providers already registered.`);
+  }
+  console.log(`
+[info] ClawMux provider registration complete!`);
+  console.log(`
+Next steps:`);
+  console.log("  1. Edit clawmux.json to configure your models");
+  console.log("  2. Run: clawmux start");
+  console.log("  3. Select a provider: openclaw provider clawmux-openai");
+  console.log("  4. Start chatting: openclaw chat");
+}
+function start() {
+  const args = process.argv.slice(2);
+  let port = parseInt(process.env.CLAWMUX_PORT ?? "3456", 10);
+  const portIdx = args.indexOf("--port") !== -1 ? args.indexOf("--port") : args.indexOf("-p");
+  if (portIdx !== -1 && args[portIdx + 1]) {
+    port = parseInt(args[portIdx + 1], 10);
+  }
+  const server = createServer({ port, host: "127.0.0.1" });
+  server.start();
+  console.log(`[clawmux] Proxy server running on http://127.0.0.1:${port}`);
+}
+var command = process.argv[2];
+switch (command) {
+  case "init":
+    init().catch((err) => {
+      console.error(`[error] ${err.message}`);
+      process.exit(1);
+    });
+    break;
+  case "start":
+    start();
+    break;
+  case "version":
+  case "--version":
+  case "-v":
+    console.log(VERSION2);
+    break;
+  case "help":
+  case "--help":
+  case "-h":
+  case undefined:
+    console.log(HELP);
+    break;
+  default:
+    console.error(`Unknown command: ${command}
+`);
+    console.log(HELP);
+    process.exit(1);
+}

package/dist/index.cjs

@@ -0,0 +1,243 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/proxy/node-http-adapter.ts
+var exports_node_http_adapter = {};
+__export(exports_node_http_adapter, {
+  writeWebResponse: () => writeWebResponse,
+  toWebRequest: () => toWebRequest
+});
+function toWebRequest(req) {
+  const protocol = "http";
+  const host = req.headers.host ?? "localhost";
+  const url = `${protocol}://${host}${req.url ?? "/"}`;
+  const headers = new Headers;
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value === undefined)
+      continue;
+    if (Array.isArray(value)) {
+      for (const v of value)
+        headers.append(key, v);
+    } else {
+      headers.set(key, value);
+    }
+  }
+  const method = (req.method ?? "GET").toUpperCase();
+  const hasBody = method !== "GET" && method !== "HEAD";
+  const init = {
+    method,
+    headers,
+    body: hasBody ? toReadableStream(req) : undefined
+  };
+  if (hasBody)
+    init.duplex = "half";
+  return new Request(url, init);
+}
+function toReadableStream(req) {
+  return new ReadableStream({
+    start(controller) {
+      req.on("data", (chunk) => controller.enqueue(new Uint8Array(chunk)));
+      req.on("end", () => controller.close());
+      req.on("error", (err) => controller.error(err));
+    }
+  });
+}
+async function writeWebResponse(res, response) {
+  res.writeHead(response.status, Object.fromEntries(response.headers.entries()));
+  if (!response.body) {
+    res.end();
+    return;
+  }
+  const reader = response.body.getReader();
+  try {
+    for (;; ) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      const flushed = res.write(value);
+      if (!flushed) {
+        await new Promise((resolve) => res.once("drain", resolve));
+      }
+    }
+  } finally {
+    reader.releaseLock();
+    res.end();
+  }
+}
+
+// src/proxy/router.ts
+var VERSION = "0.1.0";
+function jsonResponse(body, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json" }
+  });
+}
+function stubNotImplemented(name) {
+  return async () => jsonResponse({ error: `${name} not implemented yet` }, 501);
+}
+var customHandlers = new Map;
+var routes = [
+  {
+    method: "GET",
+    match: (p) => p === "/health",
+    handler: async () => jsonResponse({ status: "ok", version: VERSION }),
+    key: "/health"
+  },
+  {
+    method: "GET",
+    match: (p) => p === "/stats",
+    handler: async () => jsonResponse({ message: "stats not implemented yet" }),
+    key: "/stats"
+  },
+  {
+    method: "POST",
+    match: (p) => p === "/v1/messages",
+    handler: stubNotImplemented("anthropic"),
+    key: "/v1/messages"
+  },
+  {
+    method: "POST",
+    match: (p) => p === "/v1/chat/completions",
+    handler: stubNotImplemented("openai-completions"),
+    key: "/v1/chat/completions"
+  },
+  {
+    method: "POST",
+    match: (p) => p === "/v1/responses",
+    handler: stubNotImplemented("openai-responses"),
+    key: "/v1/responses"
+  },
+  {
+    method: "POST",
+    match: (p) => p.startsWith("/v1beta/models/"),
+    handler: stubNotImplemented("google"),
+    key: "/v1beta/models/*"
+  },
+  {
+    method: "POST",
+    match: (p) => p === "/api/chat",
+    handler: stubNotImplemented("ollama"),
+    key: "/api/chat"
+  },
+  {
+    method: "POST",
+    match: (p) => p.startsWith("/model/") && p.endsWith("/converse-stream"),
+    handler: stubNotImplemented("bedrock"),
+    key: "/model/*/converse-stream"
+  }
+];
+async function parseJsonBody(req) {
+  const contentType = req.headers.get("content-type") ?? "";
+  if (!contentType.includes("application/json")) {
+    return { body: null, error: null };
+  }
+  try {
+    const text = await req.text();
+    if (text.length === 0) {
+      return { body: null, error: null };
+    }
+    return { body: JSON.parse(text), error: null };
+  } catch {
+    return {
+      body: null,
+      error: jsonResponse({ error: "invalid JSON body" }, 400)
+    };
+  }
+}
+async function dispatch(req) {
+  const url = new URL(req.url);
+  const { pathname } = url;
+  const method = req.method.toUpperCase();
+  for (const route of routes) {
+    if (route.method === method && route.match(pathname)) {
+      const handler = customHandlers.get(route.key) ?? route.handler;
+      if (method === "POST") {
+        const { body, error } = await parseJsonBody(req);
+        if (error)
+          return error;
+        return handler(req, body);
+      }
+      return handler(req, null);
+    }
+  }
+  return jsonResponse({ error: "not found" }, 404);
+}
+
+// src/utils/runtime.ts
+var isBun = typeof globalThis.Bun !== "undefined";
+
+// src/proxy/server.ts
+function createServer(config) {
+  if (isBun) {
+    return createBunServer(config);
+  }
+  return createNodeServer(config);
+}
+function createBunServer(config) {
+  let server = null;
+  return {
+    start() {
+      if (server)
+        return;
+      const bun = globalThis.Bun;
+      server = bun.serve({
+        port: config.port,
+        hostname: config.host,
+        fetch: dispatch
+      });
+    },
+    stop() {
+      if (!server)
+        return;
+      server.stop(true);
+      server = null;
+    }
+  };
+}
+function createNodeServer(config) {
+  let server = null;
+  return {
+    async start() {
+      if (server)
+        return;
+      const { createServer: createHttpServer } = await import("node:http");
+      const { toWebRequest: toWebRequest2, writeWebResponse: writeWebResponse2 } = await Promise.resolve().then(() => exports_node_http_adapter);
+      const httpServer = createHttpServer(async (req, res) => {
+        try {
+          const webReq = toWebRequest2(req);
+          const webRes = await dispatch(webReq);
+          await writeWebResponse2(res, webRes);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          res.writeHead(500, { "content-type": "application/json" });
+          res.end(JSON.stringify({ error: message }));
+        }
+      });
+      await new Promise((resolve) => {
+        httpServer.listen(config.port, config.host, resolve);
+      });
+      server = httpServer;
+    },
+    stop() {
+      if (!server)
+        return;
+      server.close();
+      server = null;
+    }
+  };
+}
+
+// src/index.ts
+var port = parseInt(process.env.CLAWMUX_PORT ?? "3456", 10);
+var server = createServer({ port, host: "127.0.0.1" });
+server.start();
+console.log(`[clawmux] Proxy server running on http://127.0.0.1:${port}`);

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "clawmux",
+  "version": "0.1.0",
+  "description": "Smart model routing + context compression proxy for OpenClaw",
+  "type": "module",
+  "bin": {
+    "clawmux": "./bin/clawmux.cjs"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "clawmux.example.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "dev": "bun run --watch src/index.ts",
+    "start": "bun run src/index.ts",
+    "start:node": "node --import tsx src/index.ts",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "build": "bun build src/cli.ts --outfile dist/cli.cjs --target node --format cjs --external @huggingface/transformers && bun build src/index.ts --outfile dist/index.cjs --target node --format cjs --external @huggingface/transformers",
+    "build:check": "node dist/cli.cjs version",
+    "prepublishOnly": "npm run typecheck && npm run build && npm run build:check"
+  },
+  "dependencies": {
+    "@huggingface/transformers": "^3"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.11"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nagle-app/ClawMux.git"
+  },
+  "keywords": [
+    "llm",
+    "proxy",
+    "routing",
+    "compression",
+    "openclaw",
+    "ai",
+    "model-router"
+  ],
+  "license": "MIT"
+}