clawmux 0.3.0 → 0.3.2

package/dist/cli.cjs

@@ -79,8 +79,8 @@ async function writeWebResponse(res, response) {
 }
 
 // src/cli.ts
-var import_promises = require("node:fs/promises");
-var import_node_path2 = require("node:path");
+var import_promises6 = require("node:fs/promises");
+var import_node_path6 = require("node:path");
 var import_node_child_process = require("node:child_process");
 var import_node_os = require("node:os");
 
@@ -159,98 +159,3719 @@ async function parseJsonBody(req) {
     return { body: JSON.parse(text), error: null };
   } catch {
     return {
-      body: null,
-      error: jsonResponse({ error: "invalid JSON body" }, 400)
+      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);
+}
+function setRouteHandler(path, handler) {
+  customHandlers.set(path, handler);
+}
+function clearCustomHandlers() {
+  customHandlers.clear();
+}
+
+// src/utils/runtime.ts
+var import_promises = require("node:fs/promises");
+var isBun = typeof globalThis.Bun !== "undefined";
+async function readFileText(path) {
+  if (isBun) {
+    const bun = globalThis.Bun;
+    return bun.file(path).text();
+  }
+  return import_promises.readFile(path, "utf-8");
+}
+async function fileExists(path) {
+  if (isBun) {
+    const bun = globalThis.Bun;
+    return bun.file(path).exists();
+  }
+  try {
+    await import_promises.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// 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/config/loader.ts
+var import_promises2 = require("node:fs/promises");
+var import_node_path = require("node:path");
+
+// src/config/defaults.ts
+var DEFAULT_CONFIG = {
+  compression: {
+    threshold: 0.75,
+    model: "",
+    targetRatio: 0.6
+  },
+  routing: {
+    models: {
+      LIGHT: "",
+      MEDIUM: "",
+      HEAVY: ""
+    },
+    contextWindows: {}
+  },
+  server: {
+    port: 3456,
+    host: "127.0.0.1"
+  }
+};
+function applyDefaults(partial) {
+  const defaults = DEFAULT_CONFIG;
+  return {
+    compression: {
+      threshold: partial.compression.threshold ?? defaults.compression.threshold,
+      model: partial.compression.model ?? defaults.compression.model,
+      targetRatio: partial.compression.targetRatio ?? defaults.compression.targetRatio
+    },
+    routing: {
+      models: {
+        LIGHT: partial.routing.models.LIGHT ?? defaults.routing.models.LIGHT,
+        MEDIUM: partial.routing.models.MEDIUM ?? defaults.routing.models.MEDIUM,
+        HEAVY: partial.routing.models.HEAVY ?? defaults.routing.models.HEAVY
+      },
+      contextWindows: { ...defaults.routing.contextWindows, ...partial.routing.contextWindows }
+    },
+    server: {
+      port: partial.server?.port ?? defaults.server.port,
+      host: partial.server?.host ?? defaults.server.host
+    }
+  };
+}
+
+// src/config/validator.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireNumber(errors, path, value) {
+  if (typeof value !== "number") {
+    errors.push(`${path}: must be a number, got ${typeof value}`);
+    return false;
+  }
+  return true;
+}
+function requireString(errors, path, value) {
+  if (typeof value !== "string") {
+    errors.push(`${path}: must be a string, got ${typeof value}`);
+    return false;
+  }
+  return true;
+}
+function requireInRange(errors, path, value, min, max) {
+  if (value < min || value > max) {
+    errors.push(`${path}: must be between ${min} and ${max}, got ${value}`);
+  }
+}
+function checkRequiredString(errors, errorPath, obj, key) {
+  if (!isObject(obj)) {
+    errors.push(`${errorPath}: is required`);
+    return;
+  }
+  const value = obj[key];
+  if (typeof value !== "string" || value === "") {
+    errors.push(`${errorPath}: is required`);
+    return;
+  }
+  return value;
+}
+function checkProviderModelFormat(errors, path, model) {
+  if (!model.includes("/")) {
+    errors.push(`${path} must be in 'provider/model' format (e.g., 'anthropic/claude-sonnet-4-20250514')`);
+    return;
+  }
+  const providerName = model.split("/", 2)[0];
+  if (providerName.toLowerCase().startsWith("clawmux-")) {
+    errors.push(`Self-referencing model detected: ${model}. This would cause an infinite routing loop.`);
+  }
+}
+function checkOptionalNumberRange(errors, path, value, min, max) {
+  if (requireNumber(errors, path, value)) {
+    requireInRange(errors, path, value, min, max);
+  }
+}
+function validateConfig(raw) {
+  const errors = [];
+  const obj = isObject(raw) ? raw : {};
+  const compression = isObject(obj.compression) ? obj.compression : {};
+  const threshold = compression.threshold;
+  if (threshold === undefined) {
+    errors.push("compression.threshold: is required");
+  } else {
+    checkOptionalNumberRange(errors, "compression.threshold", threshold, 0.1, 0.95);
+  }
+  if (compression.model === undefined || compression.model === "") {
+    errors.push("compression.model: is required");
+  } else if (requireString(errors, "compression.model", compression.model)) {
+    checkProviderModelFormat(errors, "compression.model", compression.model);
+  }
+  if (compression.targetRatio !== undefined) {
+    checkOptionalNumberRange(errors, "compression.targetRatio", compression.targetRatio, 0.2, 0.9);
+  }
+  const routing = isObject(obj.routing) ? obj.routing : {};
+  const models = isObject(routing.models) ? routing.models : {};
+  const light = checkRequiredString(errors, "routing.models.LIGHT", models, "LIGHT");
+  const medium = checkRequiredString(errors, "routing.models.MEDIUM", models, "MEDIUM");
+  const heavy = checkRequiredString(errors, "routing.models.HEAVY", models, "HEAVY");
+  if (light)
+    checkProviderModelFormat(errors, "routing.models.LIGHT", light);
+  if (medium)
+    checkProviderModelFormat(errors, "routing.models.MEDIUM", medium);
+  if (heavy)
+    checkProviderModelFormat(errors, "routing.models.HEAVY", heavy);
+  if (routing.contextWindows !== undefined) {
+    if (!isObject(routing.contextWindows)) {
+      errors.push("routing.contextWindows: must be an object");
+    } else {
+      for (const [key, value] of Object.entries(routing.contextWindows)) {
+        if (typeof key !== "string") {
+          errors.push(`routing.contextWindows: keys must be strings`);
+        }
+        if (typeof value !== "number" || value <= 0) {
+          errors.push(`routing.contextWindows["${key}"]: must be a positive number, got ${String(value)}`);
+        }
+      }
+    }
+  }
+  const server = obj.server !== undefined && isObject(obj.server) ? obj.server : null;
+  if (server !== null && server.port !== undefined) {
+    checkOptionalNumberRange(errors, "server.port", server.port, 1024, 65535);
+  }
+  if (errors.length > 0) {
+    return { valid: false, errors };
+  }
+  return { valid: true, config: applyDefaults(obj) };
+}
+
+// src/config/loader.ts
+function findConfigPath() {
+  const envPath = process.env.CLAWMUX_CONFIG;
+  if (envPath) {
+    return import_node_path.resolve(envPath);
+  }
+  return import_node_path.resolve(process.cwd(), "clawmux.json");
+}
+async function loadConfig(configPath) {
+  const filePath = configPath ?? findConfigPath();
+  let raw;
+  try {
+    raw = await import_promises2.readFile(filePath, "utf-8");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      valid: false,
+      errors: [`Failed to read config file at ${filePath}: ${message}`]
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      valid: false,
+      errors: [`Invalid JSON in config file ${filePath}: ${message}`]
+    };
+  }
+  return validateConfig(parsed);
+}
+
+// src/config/watcher.ts
+var import_node_fs = require("node:fs");
+var import_promises3 = require("node:fs/promises");
+function createConfigWatcher(configPath, onReload, options) {
+  const debounceMs = options?.debounceMs ?? 2000;
+  let watcher = null;
+  let debounceTimer = null;
+  let reloading = false;
+  let pendingReload = false;
+  async function reloadConfig() {
+    if (reloading) {
+      pendingReload = true;
+      return;
+    }
+    reloading = true;
+    try {
+      let raw;
+      try {
+        raw = await import_promises3.readFile(configPath, "utf-8");
+      } catch {
+        console.warn(`[config] Config file ${configPath} not found, keeping old config`);
+        return;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.warn(`[config] Invalid JSON in config change, ignored: ${message}`);
+        return;
+      }
+      const result = validateConfig(parsed);
+      if (result.valid) {
+        onReload(result.config);
+        console.log("[config] Reloaded clawmux.json");
+      } else {
+        console.warn(`[config] Invalid config change ignored: ${result.errors.join(", ")}`);
+      }
+    } finally {
+      reloading = false;
+      if (pendingReload) {
+        pendingReload = false;
+        scheduleReload();
+      }
+    }
+  }
+  function scheduleReload() {
+    if (debounceTimer !== null) {
+      clearTimeout(debounceTimer);
+    }
+    debounceTimer = setTimeout(() => {
+      debounceTimer = null;
+      reloadConfig();
+    }, debounceMs);
+  }
+  return {
+    start() {
+      if (watcher !== null)
+        return;
+      watcher = import_node_fs.watch(configPath, (eventType) => {
+        if (eventType === "rename") {
+          console.warn(`[config] Config file ${configPath} was deleted, keeping old config`);
+          return;
+        }
+        scheduleReload();
+      });
+      watcher.on("error", (err) => {
+        console.warn(`[config] Watcher error: ${err instanceof Error ? err.message : String(err)}`);
+      });
+    },
+    stop() {
+      if (debounceTimer !== null) {
+        clearTimeout(debounceTimer);
+        debounceTimer = null;
+      }
+      if (watcher !== null) {
+        watcher.close();
+        watcher = null;
+      }
+    },
+    isWatching() {
+      return watcher !== null;
+    }
+  };
+}
+
+// src/openclaw/config-reader.ts
+var import_promises4 = require("node:fs/promises");
+var import_node_path2 = require("node:path");
+var ENV_VAR_PATTERN = /^\$\{([^}]+)\}$/;
+function resolveEnvVar(value) {
+  const match = value.match(ENV_VAR_PATTERN);
+  if (match) {
+    return process.env[match[1]] ?? "";
+  }
+  return value;
+}
+function getHomeDir() {
+  return process.env.HOME ?? "/root";
+}
+function getConfigPath(override) {
+  if (override)
+    return override;
+  if (process.env.OPENCLAW_CONFIG_PATH)
+    return process.env.OPENCLAW_CONFIG_PATH;
+  return import_node_path2.join(getHomeDir(), ".openclaw", "openclaw.json");
+}
+async function readOpenClawConfig(configPath) {
+  const path = getConfigPath(configPath);
+  let text;
+  try {
+    text = await import_promises4.readFile(path, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT" || code === "ENOTDIR") {
+      throw new Error(`openclaw.json not found at ${path}. Ensure OpenClaw is installed.`);
+    }
+    throw err;
+  }
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse openclaw.json: ${message}`);
+  }
+}
+function getAuthProfilesPath(agentId) {
+  const id = agentId ?? "main";
+  return import_node_path2.join(getHomeDir(), ".openclaw", "agents", id, "agent", "auth-profiles.json");
+}
+function parseAuthProfilesFile(text) {
+  try {
+    const parsed = JSON.parse(text);
+    if (Array.isArray(parsed))
+      return parsed;
+    if (parsed && typeof parsed === "object" && parsed.profiles) {
+      return Object.entries(parsed.profiles).map(([key, profile]) => ({
+        provider: profile.provider ?? key.split(":")[0],
+        apiKey: profile.access ?? profile.apiKey ?? profile.key,
+        token: profile.token
+      })).filter((p) => {
+        const token = p.apiKey ?? p.token;
+        if (!token || !token.includes("."))
+          return true;
+        try {
+          const payload = token.split(".")[1];
+          const decoded = JSON.parse(Buffer.from(payload, "base64").toString());
+          if (decoded.exp && decoded.exp * 1000 < Date.now())
+            return false;
+        } catch (_) {
+          return true;
+        }
+        return true;
+      });
+    }
+    return [];
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse auth-profiles.json: ${message}`);
+  }
+}
+async function readAuthProfiles(_agentId, _profilesPath, agentsDirOverride) {
+  const agentsDir = agentsDirOverride ?? import_node_path2.join(getHomeDir(), ".openclaw", "agents");
+  let agentDirs;
+  try {
+    agentDirs = (await import_promises4.readdir(agentsDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+  } catch {
+    const path = getAuthProfilesPath(_agentId);
+    try {
+      return parseAuthProfilesFile(await import_promises4.readFile(path, "utf-8"));
+    } catch {
+      return [];
+    }
+  }
+  const ordered = ["main", ...agentDirs.filter((d) => d !== "main")];
+  const merged = new Map;
+  for (const agentId of ordered) {
+    const profilePath = import_node_path2.join(agentsDir, agentId, "agent", "auth-profiles.json");
+    try {
+      const text = await import_promises4.readFile(profilePath, "utf-8");
+      const profiles = parseAuthProfilesFile(text);
+      for (const p of profiles) {
+        merged.set(p.provider, p);
+      }
+    } catch {}
+  }
+  return Array.from(merged.values());
+}
+function getProviderConfig(provider, config) {
+  return config.models?.providers?.[provider];
+}
+function lookupContextWindowFromConfig(modelKey, config) {
+  const [provider, ...rest] = modelKey.split("/");
+  const modelId = rest.join("/");
+  if (!provider || !modelId)
+    return;
+  const providerConfig = config.models?.providers?.[provider];
+  if (!providerConfig?.models)
+    return;
+  const model = providerConfig.models.find((m) => m.id === modelId);
+  return model?.contextWindow;
+}
+
+// src/openclaw/model-limits.ts
+var import_promises5 = require("node:fs/promises");
+var import_node_path3 = require("node:path");
+var DEFAULT_CONTEXT_TOKENS = 200000;
+var cachedCatalog = null;
+function resolveContextWindow(modelKey, clawmuxContextWindows, openclawConfig, piAiCatalog) {
+  const fromClawmux = clawmuxContextWindows[modelKey];
+  if (typeof fromClawmux === "number" && fromClawmux > 0) {
+    return fromClawmux;
+  }
+  const fromOpenclaw = lookupContextWindowFromConfig(modelKey, openclawConfig);
+  if (typeof fromOpenclaw === "number" && fromOpenclaw > 0) {
+    return fromOpenclaw;
+  }
+  if (piAiCatalog) {
+    const [provider, ...rest] = modelKey.split("/");
+    const modelId = rest.join("/");
+    if (provider && modelId) {
+      const providerModels = piAiCatalog[provider];
+      if (providerModels) {
+        const entry = providerModels[modelId];
+        if (entry && typeof entry.contextWindow === "number" && entry.contextWindow > 0) {
+          return entry.contextWindow;
+        }
+      }
+    }
+  }
+  return DEFAULT_CONTEXT_TOKENS;
+}
+function resolveCompressionContextWindow(routingModels, clawmuxContextWindows, openclawConfig, piAiCatalog) {
+  const modelKeys = [routingModels.LIGHT, routingModels.MEDIUM, routingModels.HEAVY];
+  const uniqueKeys = [...new Set(modelKeys.filter((k) => k !== ""))];
+  if (uniqueKeys.length === 0) {
+    return DEFAULT_CONTEXT_TOKENS;
+  }
+  let min = Infinity;
+  for (const key of uniqueKeys) {
+    const window = resolveContextWindow(key, clawmuxContextWindows, openclawConfig, piAiCatalog);
+    if (window < min) {
+      min = window;
+    }
+  }
+  return min === Infinity ? DEFAULT_CONTEXT_TOKENS : min;
+}
+async function findOpenClawNodeModulesPath() {
+  try {
+    const { execSync } = await import("node:child_process");
+    const whichResult = execSync("which openclaw", { encoding: "utf-8" }).trim();
+    if (!whichResult)
+      return;
+    const resolved = await import_promises5.realpath(whichResult);
+    let dir = import_node_path3.dirname(resolved);
+    for (let i = 0;i < 10; i++) {
+      const candidate = import_node_path3.join(dir, "node_modules", "@mariozechner", "pi-ai", "dist", "models.generated.js");
+      try {
+        if (await fileExists(candidate)) {
+          return candidate;
+        }
+      } catch {}
+      const parent = import_node_path3.dirname(dir);
+      if (parent === dir)
+        break;
+      dir = parent;
+    }
+  } catch {}
+  const homeDir = process.env.HOME ?? "/root";
+  const fallbackPaths = [
+    import_node_path3.join(homeDir, ".npm-global", "lib", "node_modules", "openclaw", "node_modules", "@mariozechner", "pi-ai", "dist", "models.generated.js"),
+    import_node_path3.join(homeDir, ".local", "lib", "node_modules", "openclaw", "node_modules", "@mariozechner", "pi-ai", "dist", "models.generated.js")
+  ];
+  for (const path of fallbackPaths) {
+    try {
+      if (await fileExists(path)) {
+        return path;
+      }
+    } catch {}
+  }
+  return;
+}
+function parseCatalogFromSource(source) {
+  const modelsMatch = source.match(/export\s+const\s+MODELS\s*=\s*(\{[\s\S]*\});?\s*$/m);
+  if (!modelsMatch)
+    return;
+  try {
+    const fn = new Function(`return (${modelsMatch[1]});`);
+    const result = fn();
+    if (typeof result === "object" && result !== null && !Array.isArray(result)) {
+      return result;
+    }
+  } catch (err) {
+    console.warn("[clawmux] Failed to parse pi-ai model catalog:", err instanceof Error ? err.message : String(err));
+  }
+  return;
+}
+async function loadPiAiCatalog() {
+  if (cachedCatalog !== null) {
+    return cachedCatalog;
+  }
+  const filePath = await findOpenClawNodeModulesPath();
+  if (!filePath) {
+    console.warn("[clawmux] pi-ai model catalog not found — using default context windows");
+    cachedCatalog = undefined;
+    return;
+  }
+  try {
+    const source = await readFileText(filePath);
+    const catalog = parseCatalogFromSource(source);
+    if (catalog) {
+      const providerCount = Object.keys(catalog).length;
+      const modelCount = Object.values(catalog).reduce((sum, models) => sum + Object.keys(models).length, 0);
+      console.log(`[clawmux] Loaded pi-ai model catalog: ${providerCount} providers, ${modelCount} models`);
+      cachedCatalog = catalog;
+      return catalog;
+    }
+    console.warn("[clawmux] pi-ai model catalog found but could not be parsed");
+    cachedCatalog = undefined;
+    return;
+  } catch (err) {
+    console.warn("[clawmux] Failed to load pi-ai model catalog:", err instanceof Error ? err.message : String(err));
+    cachedCatalog = undefined;
+    return;
+  }
+}
+
+// src/adapters/registry.ts
+var adapters = new Map;
+function registerAdapter(adapter) {
+  adapters.set(adapter.apiType, adapter);
+}
+function getAdapter(apiType) {
+  return adapters.get(apiType);
+}
+
+// src/adapters/tool-converter.ts
+function toOpenAITools(tools) {
+  if (!Array.isArray(tools) || tools.length === 0)
+    return;
+  return tools.map((tool) => {
+    if (tool.type === "function" && tool.function)
+      return tool;
+    return {
+      type: "function",
+      function: {
+        name: tool.name ?? "",
+        description: tool.description ?? "",
+        parameters: tool.input_schema ?? tool.parameters ?? { type: "object", properties: {} }
+      }
+    };
+  });
+}
+function toAnthropicTools(tools) {
+  if (!Array.isArray(tools) || tools.length === 0)
+    return;
+  return tools.map((tool) => {
+    if (tool.input_schema && !tool.type)
+      return tool;
+    const fn = tool.function ?? tool;
+    return {
+      name: fn.name ?? "",
+      description: fn.description ?? "",
+      input_schema: fn.parameters ?? { type: "object", properties: {} }
+    };
+  });
+}
+
+// src/adapters/anthropic.ts
+class AnthropicAdapter {
+  apiType = "anthropic-messages";
+  parseRequest(body) {
+    const raw = body;
+    const model = String(raw.model ?? "");
+    const messages = raw.messages ?? [];
+    const stream = raw.stream !== false;
+    const maxTokens = typeof raw.max_tokens === "number" ? raw.max_tokens : undefined;
+    const system = raw.system;
+    return {
+      model,
+      messages,
+      system,
+      stream,
+      maxTokens,
+      rawBody: raw
+    };
+  }
+  buildUpstreamRequest(parsed, targetModel, baseUrl, auth) {
+    const url = `${baseUrl}/v1/messages`;
+    const headers = {
+      "x-api-key": auth.apiKey,
+      "anthropic-version": "2023-06-01",
+      "content-type": "application/json"
+    };
+    const isHaiku = targetModel.toLowerCase().includes("haiku");
+    const hasThinking = "thinking" in parsed.rawBody;
+    if (hasThinking && !isHaiku) {
+      headers["anthropic-beta"] = "interleaved-thinking-2025-05-14";
+    }
+    const ANTHROPIC_SAMPLING_KEYS = [
+      "temperature",
+      "top_p",
+      "top_k",
+      "stop_sequences",
+      "metadata",
+      "service_tier"
+    ];
+    const samplingParams = {};
+    for (const key of ANTHROPIC_SAMPLING_KEYS) {
+      if (key in parsed.rawBody) {
+        samplingParams[key] = parsed.rawBody[key];
+      }
+    }
+    let bodyObj = {
+      model: targetModel,
+      messages: parsed.messages,
+      stream: parsed.stream,
+      ...samplingParams
+    };
+    if (parsed.system !== undefined) {
+      bodyObj.system = parsed.system;
+    }
+    if (parsed.maxTokens !== undefined) {
+      bodyObj.max_tokens = parsed.maxTokens;
+    }
+    if (parsed.rawBody.tools) {
+      bodyObj.tools = toAnthropicTools(parsed.rawBody.tools);
+    }
+    if (!isHaiku && hasThinking) {
+      bodyObj.thinking = parsed.rawBody.thinking;
+    }
+    return {
+      url,
+      method: "POST",
+      headers,
+      body: JSON.stringify(bodyObj)
+    };
+  }
+  modifyMessages(rawBody, compressedMessages) {
+    return {
+      ...rawBody,
+      messages: compressedMessages
+    };
+  }
+  parseResponse(body) {
+    const raw = body;
+    const id = String(raw.id ?? "");
+    const model = String(raw.model ?? "");
+    let content = "";
+    const contentBlocks = raw.content;
+    if (Array.isArray(contentBlocks)) {
+      const textParts = [];
+      for (const block of contentBlocks) {
+        if (typeof block === "object" && block !== null && block.type === "text" && typeof block.text === "string") {
+          textParts.push(block.text);
+        }
+      }
+      content = textParts.join("");
+    }
+    const stopReason = typeof raw.stop_reason === "string" ? raw.stop_reason : null;
+    let usage;
+    const rawUsage = raw.usage;
+    if (rawUsage) {
+      usage = {
+        inputTokens: typeof rawUsage.input_tokens === "number" ? rawUsage.input_tokens : 0,
+        outputTokens: typeof rawUsage.output_tokens === "number" ? rawUsage.output_tokens : 0
+      };
+    }
+    return { id, model, content, role: "assistant", stopReason, usage };
+  }
+  buildResponse(parsed) {
+    const result = {
+      id: parsed.id,
+      type: "message",
+      role: "assistant",
+      model: parsed.model,
+      content: [{ type: "text", text: parsed.content }],
+      stop_reason: parsed.stopReason
+    };
+    if (parsed.usage) {
+      result.usage = {
+        input_tokens: parsed.usage.inputTokens,
+        output_tokens: parsed.usage.outputTokens
+      };
+    }
+    return result;
+  }
+  parseStreamChunk(chunk) {
+    const events = [];
+    let eventType = "";
+    let dataStr = "";
+    for (const line of chunk.split(`
+`)) {
+      if (line.startsWith("event: ")) {
+        eventType = line.slice(7).trim();
+      } else if (line.startsWith("data: ")) {
+        dataStr = line.slice(6);
+      }
+    }
+    if (!eventType && !dataStr)
+      return events;
+    if (eventType === "ping" || eventType === "content_block_start") {
+      return events;
+    }
+    let data = {};
+    if (dataStr) {
+      try {
+        data = JSON.parse(dataStr);
+      } catch {
+        return events;
+      }
+    }
+    switch (eventType) {
+      case "message_start": {
+        const message = data.message;
+        events.push({
+          type: "message_start",
+          id: String(message?.id ?? data.id ?? ""),
+          model: String(message?.model ?? data.model ?? "")
+        });
+        break;
+      }
+      case "content_block_delta": {
+        const delta = data.delta;
+        if (delta?.type === "text_delta" && typeof delta.text === "string") {
+          events.push({
+            type: "content_delta",
+            text: delta.text,
+            index: typeof data.index === "number" ? data.index : 0
+          });
+        }
+        break;
+      }
+      case "content_block_stop": {
+        events.push({
+          type: "content_stop",
+          index: typeof data.index === "number" ? data.index : 0
+        });
+        break;
+      }
+      case "message_delta": {
+        const rawUsage = data.usage;
+        let usage;
+        if (rawUsage) {
+          usage = {
+            inputTokens: typeof rawUsage.input_tokens === "number" ? rawUsage.input_tokens : 0,
+            outputTokens: typeof rawUsage.output_tokens === "number" ? rawUsage.output_tokens : 0
+          };
+        }
+        events.push({ type: "message_stop", usage });
+        break;
+      }
+      case "message_stop": {
+        events.push({ type: "message_stop" });
+        break;
+      }
+    }
+    return events;
+  }
+  buildStreamChunk(event) {
+    switch (event.type) {
+      case "message_start":
+        return `event: message_start
+data: ${JSON.stringify({
+          type: "message_start",
+          message: {
+            id: event.id,
+            type: "message",
+            role: "assistant",
+            model: event.model
+          }
+        })}
+
+`;
+      case "content_delta":
+        return `event: content_block_delta
+data: ${JSON.stringify({
+          type: "content_block_delta",
+          index: event.index,
+          delta: { type: "text_delta", text: event.text }
+        })}
+
+`;
+      case "content_stop":
+        return `event: content_block_stop
+data: ${JSON.stringify({
+          type: "content_block_stop",
+          index: event.index
+        })}
+
+`;
+      case "message_stop":
+        if (event.usage) {
+          return `event: message_delta
+data: ${JSON.stringify({
+            type: "message_delta",
+            usage: {
+              input_tokens: event.usage.inputTokens,
+              output_tokens: event.usage.outputTokens
+            }
+          })}
+
+` + `event: message_stop
+data: ${JSON.stringify({
+            type: "message_stop"
+          })}
+
+`;
+        }
+        return `event: message_stop
+data: ${JSON.stringify({
+          type: "message_stop"
+        })}
+
+`;
+      case "error":
+        return `event: error
+data: ${JSON.stringify({
+          type: "error",
+          error: { message: event.message }
+        })}
+
+`;
+      default:
+        return "";
+    }
+  }
+}
+
+// src/adapters/openai-shared.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isMessageArray(value) {
+  if (!Array.isArray(value))
+    return false;
+  return value.every((item) => isRecord(item) && typeof item.role === "string" && ("content" in item));
+}
+function extractSystemMessage(messages) {
+  const systemMessages = [];
+  const filtered = [];
+  for (const msg of messages) {
+    if (msg.role === "system" || msg.role === "developer") {
+      if (typeof msg.content === "string") {
+        systemMessages.push(msg.content);
+      } else if (Array.isArray(msg.content)) {
+        for (const part of msg.content) {
+          if (isRecord(part) && part.type === "text" && typeof part.text === "string") {
+            systemMessages.push(part.text);
+          }
+        }
+      }
+    } else {
+      filtered.push(msg);
+    }
+  }
+  return {
+    system: systemMessages.length > 0 ? systemMessages.join(`
+`) : undefined,
+    filtered
+  };
+}
+function parseOpenAIBody(body) {
+  if (!isRecord(body)) {
+    throw new Error("Request body must be a JSON object");
+  }
+  const model = typeof body.model === "string" ? body.model : "";
+  if (!model) {
+    throw new Error("Missing required field: model");
+  }
+  const rawMessages = body.messages ?? body.input;
+  if (!isMessageArray(rawMessages)) {
+    throw new Error("Request must contain a valid 'messages' or 'input' array");
+  }
+  const { system, filtered } = extractSystemMessage(rawMessages);
+  const stream = body.stream === true;
+  const rawMax = body.max_tokens ?? body.max_output_tokens;
+  const maxTokens = typeof rawMax === "number" ? rawMax : undefined;
+  const rawBody = { ...body };
+  return {
+    model,
+    messages: filtered,
+    system,
+    stream,
+    maxTokens,
+    rawBody
+  };
+}
+
+// src/adapters/openai-completions.ts
+class OpenAICompletionsAdapter {
+  apiType = "openai-completions";
+  parseRequest(body) {
+    return parseOpenAIBody(body);
+  }
+  buildUpstreamRequest(parsed, targetModel, baseUrl, auth) {
+    const messages = [];
+    if (parsed.system !== undefined) {
+      messages.push({ role: "system", content: parsed.system });
+    }
+    messages.push(...parsed.messages);
+    const OPENAI_SAMPLING_KEYS = [
+      "temperature",
+      "top_p",
+      "frequency_penalty",
+      "presence_penalty",
+      "logprobs",
+      "top_logprobs",
+      "seed",
+      "stop",
+      "n",
+      "logit_bias",
+      "response_format",
+      "reasoning_effort"
+    ];
+    const samplingParams = {};
+    for (const key of OPENAI_SAMPLING_KEYS) {
+      if (key in parsed.rawBody) {
+        samplingParams[key] = parsed.rawBody[key];
+      }
+    }
+    const upstreamBody = {
+      model: targetModel,
+      messages,
+      stream: parsed.stream,
+      ...samplingParams
+    };
+    if (parsed.maxTokens !== undefined) {
+      upstreamBody.max_tokens = parsed.maxTokens;
+    }
+    if (parsed.rawBody.tools) {
+      upstreamBody.tools = toOpenAITools(parsed.rawBody.tools);
+    }
+    return {
+      url: /\/v\d+\/?$/.test(baseUrl) ? `${baseUrl.replace(/\/$/, "")}/chat/completions` : `${baseUrl}/v1/chat/completions`,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${auth.apiKey}`
+      },
+      body: JSON.stringify(upstreamBody)
+    };
+  }
+  modifyMessages(rawBody, compressedMessages) {
+    return {
+      ...rawBody,
+      messages: compressedMessages
+    };
+  }
+  parseResponse(body) {
+    const raw = body;
+    const id = String(raw.id ?? "");
+    const model = String(raw.model ?? "");
+    let content = "";
+    let stopReason = null;
+    const choices = raw.choices;
+    if (Array.isArray(choices) && choices.length > 0) {
+      const choice = choices[0];
+      const message = choice.message;
+      if (message) {
+        const messageText = message.content ?? message.reasoning_content;
+        if (typeof messageText === "string") {
+          content = messageText;
+        }
+      }
+      if (typeof choice.finish_reason === "string") {
+        stopReason = choice.finish_reason;
+      }
+    }
+    let usage;
+    const rawUsage = raw.usage;
+    if (rawUsage) {
+      usage = {
+        inputTokens: typeof rawUsage.prompt_tokens === "number" ? rawUsage.prompt_tokens : 0,
+        outputTokens: typeof rawUsage.completion_tokens === "number" ? rawUsage.completion_tokens : 0
+      };
+    }
+    return { id, model, content, role: "assistant", stopReason, usage };
+  }
+  buildResponse(parsed) {
+    const result = {
+      id: parsed.id,
+      object: "chat.completion",
+      model: parsed.model,
+      choices: [
+        {
+          index: 0,
+          message: { role: "assistant", content: parsed.content },
+          finish_reason: parsed.stopReason
+        }
+      ]
+    };
+    if (parsed.usage) {
+      result.usage = {
+        prompt_tokens: parsed.usage.inputTokens,
+        completion_tokens: parsed.usage.outputTokens,
+        total_tokens: parsed.usage.inputTokens + parsed.usage.outputTokens
+      };
+    }
+    return result;
+  }
+  parseStreamChunk(chunk) {
+    const events = [];
+    for (const line of chunk.split(`
+`)) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("data: "))
+        continue;
+      const payload = trimmed.slice(6);
+      if (payload === "[DONE]") {
+        events.push({ type: "message_stop" });
+        continue;
+      }
+      let data;
+      try {
+        data = JSON.parse(payload);
+      } catch {
+        continue;
+      }
+      const choices = data.choices;
+      if (!Array.isArray(choices) || choices.length === 0) {
+        if (data.id && data.model) {
+          events.push({
+            type: "message_start",
+            id: String(data.id),
+            model: String(data.model)
+          });
+        }
+        continue;
+      }
+      const choice = choices[0];
+      const delta = choice.delta;
+      const finishReason = choice.finish_reason;
+      const textContent = delta?.content ?? delta?.reasoning_content;
+      if (delta?.role === "assistant" && textContent == null) {
+        events.push({
+          type: "message_start",
+          id: String(data.id ?? ""),
+          model: String(data.model ?? "")
+        });
+      } else if (typeof textContent === "string") {
+        events.push({
+          type: "content_delta",
+          text: textContent,
+          index: typeof choice.index === "number" ? choice.index : 0
+        });
+      }
+      if (typeof finishReason === "string" && finishReason !== "") {
+        events.push({
+          type: "content_stop",
+          index: typeof choice.index === "number" ? choice.index : 0
+        });
+        let usage;
+        const rawUsage = data.usage;
+        if (rawUsage) {
+          usage = {
+            inputTokens: typeof rawUsage.prompt_tokens === "number" ? rawUsage.prompt_tokens : 0,
+            outputTokens: typeof rawUsage.completion_tokens === "number" ? rawUsage.completion_tokens : 0
+          };
+        }
+        events.push({ type: "message_stop", usage });
+      }
+    }
+    return events;
+  }
+  buildStreamChunk(event) {
+    switch (event.type) {
+      case "message_start":
+        return `data: ${JSON.stringify({
+          id: event.id,
+          object: "chat.completion.chunk",
+          model: event.model,
+          choices: [
+            {
+              index: 0,
+              delta: { role: "assistant" },
+              finish_reason: null
+            }
+          ]
+        })}
+
+`;
+      case "content_delta":
+        return `data: ${JSON.stringify({
+          id: "",
+          object: "chat.completion.chunk",
+          choices: [
+            {
+              index: event.index,
+              delta: { content: event.text },
+              finish_reason: null
+            }
+          ]
+        })}
+
+`;
+      case "content_stop":
+        return `data: ${JSON.stringify({
+          id: "",
+          object: "chat.completion.chunk",
+          choices: [
+            {
+              index: event.index,
+              delta: {},
+              finish_reason: "stop"
+            }
+          ]
+        })}
+
+`;
+      case "message_stop":
+        return `data: [DONE]
+
+`;
+      case "error":
+        return `data: ${JSON.stringify({
+          error: { message: event.message }
+        })}
+
+`;
+      default:
+        return "";
+    }
+  }
+}
+var openaiCompletionsAdapter = new OpenAICompletionsAdapter;
+registerAdapter(openaiCompletionsAdapter);
+
+// src/adapters/openai-responses.ts
+class OpenAIResponsesAdapter {
+  apiType = "openai-responses";
+  parseRequest(body) {
+    return parseOpenAIBody(body);
+  }
+  buildUpstreamRequest(parsed, targetModel, baseUrl, auth) {
+    const input = [];
+    if (parsed.system !== undefined) {
+      input.push({ role: "system", content: parsed.system });
+    }
+    input.push(...parsed.messages);
+    const OPENAI_RESPONSES_SAMPLING_KEYS = [
+      "temperature",
+      "top_p",
+      "truncation",
+      "reasoning",
+      "reasoning_effort",
+      "text",
+      "metadata",
+      "store",
+      "include"
+    ];
+    const samplingParams = {};
+    for (const key of OPENAI_RESPONSES_SAMPLING_KEYS) {
+      if (key in parsed.rawBody) {
+        samplingParams[key] = parsed.rawBody[key];
+      }
+    }
+    const upstreamBody = {
+      model: targetModel,
+      input,
+      stream: parsed.stream,
+      ...samplingParams
+    };
+    if (parsed.maxTokens !== undefined) {
+      upstreamBody.max_output_tokens = parsed.maxTokens;
+    }
+    if (parsed.rawBody.tools) {
+      upstreamBody.tools = toOpenAITools(parsed.rawBody.tools);
+    }
+    return {
+      url: `${baseUrl}/v1/responses`,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${auth.apiKey}`
+      },
+      body: JSON.stringify(upstreamBody)
+    };
+  }
+  modifyMessages(rawBody, compressedMessages) {
+    const hasInput = "input" in rawBody;
+    const fieldName = hasInput ? "input" : "messages";
+    return {
+      ...rawBody,
+      [fieldName]: compressedMessages
+    };
+  }
+  parseResponse(body) {
+    const raw = body;
+    const id = String(raw.id ?? "");
+    const model = String(raw.model ?? "");
+    let content = "";
+    let stopReason = null;
+    const output = raw.output;
+    if (Array.isArray(output)) {
+      const textParts = [];
+      for (const item of output) {
+        if (item.type === "message") {
+          const msgContent = item.content;
+          if (Array.isArray(msgContent)) {
+            for (const part of msgContent) {
+              if (part.type === "output_text" && typeof part.text === "string") {
+                textParts.push(part.text);
+              }
+            }
+          }
+        }
+      }
+      content = textParts.join("");
+    }
+    if (typeof raw.status === "string") {
+      stopReason = raw.status;
+    }
+    let usage;
+    const rawUsage = raw.usage;
+    if (rawUsage) {
+      usage = {
+        inputTokens: typeof rawUsage.input_tokens === "number" ? rawUsage.input_tokens : 0,
+        outputTokens: typeof rawUsage.output_tokens === "number" ? rawUsage.output_tokens : 0
+      };
+    }
+    return { id, model, content, role: "assistant", stopReason, usage };
+  }
+  buildResponse(parsed) {
+    const result = {
+      id: parsed.id,
+      object: "response",
+      model: parsed.model,
+      status: parsed.stopReason ?? "completed",
+      output: [
+        {
+          type: "message",
+          role: "assistant",
+          content: [
+            { type: "output_text", text: parsed.content }
+          ]
+        }
+      ]
+    };
+    if (parsed.usage) {
+      result.usage = {
+        input_tokens: parsed.usage.inputTokens,
+        output_tokens: parsed.usage.outputTokens,
+        total_tokens: parsed.usage.inputTokens + parsed.usage.outputTokens
+      };
+    }
+    return result;
+  }
+  parseStreamChunk(chunk) {
+    const events = [];
+    for (const line of chunk.split(`
+`)) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("data: "))
+        continue;
+      const payload = trimmed.slice(6);
+      if (payload === "[DONE]") {
+        events.push({ type: "message_stop" });
+        continue;
+      }
+      let data;
+      try {
+        data = JSON.parse(payload);
+      } catch {
+        continue;
+      }
+      const eventType = String(data.type ?? "");
+      switch (eventType) {
+        case "response.created": {
+          const response = data.response;
+          events.push({
+            type: "message_start",
+            id: String(response?.id ?? data.id ?? ""),
+            model: String(response?.model ?? data.model ?? "")
+          });
+          break;
+        }
+        case "response.output_text.delta": {
+          events.push({
+            type: "content_delta",
+            text: typeof data.delta === "string" ? data.delta : "",
+            index: typeof data.output_index === "number" ? data.output_index : 0
+          });
+          break;
+        }
+        case "response.output_text.done": {
+          events.push({
+            type: "content_stop",
+            index: typeof data.output_index === "number" ? data.output_index : 0
+          });
+          break;
+        }
+        case "response.completed": {
+          let usage;
+          const response = data.response;
+          const rawUsage = response?.usage;
+          if (rawUsage) {
+            usage = {
+              inputTokens: typeof rawUsage.input_tokens === "number" ? rawUsage.input_tokens : 0,
+              outputTokens: typeof rawUsage.output_tokens === "number" ? rawUsage.output_tokens : 0
+            };
+          }
+          events.push({ type: "message_stop", usage });
+          break;
+        }
+      }
+    }
+    return events;
+  }
+  buildStreamChunk(event) {
+    switch (event.type) {
+      case "message_start":
+        return `data: ${JSON.stringify({
+          type: "response.created",
+          response: {
+            id: event.id,
+            object: "response",
+            model: event.model,
+            status: "in_progress"
+          }
+        })}
+
+`;
+      case "content_delta":
+        return `data: ${JSON.stringify({
+          type: "response.output_text.delta",
+          output_index: event.index,
+          delta: event.text
+        })}
+
+`;
+      case "content_stop":
+        return `data: ${JSON.stringify({
+          type: "response.output_text.done",
+          output_index: event.index
+        })}
+
+`;
+      case "message_stop":
+        if (event.usage) {
+          return `data: ${JSON.stringify({
+            type: "response.completed",
+            response: {
+              usage: {
+                input_tokens: event.usage.inputTokens,
+                output_tokens: event.usage.outputTokens
+              }
+            }
+          })}
+
+`;
+        }
+        return `data: ${JSON.stringify({
+          type: "response.completed"
+        })}
+
+`;
+      case "error":
+        return `data: ${JSON.stringify({
+          type: "error",
+          error: { message: event.message }
+        })}
+
+`;
+      default:
+        return "";
+    }
+  }
+}
+var openaiResponsesAdapter = new OpenAIResponsesAdapter;
+registerAdapter(openaiResponsesAdapter);
+
+// src/adapters/google.ts
+function googleRoleToStandard(role) {
+  if (role === "model")
+    return "assistant";
+  return role ?? "user";
+}
+function standardRoleToGoogle(role) {
+  if (role === "assistant")
+    return "model";
+  return "user";
+}
+function contentsToMessages(contents) {
+  return contents.map((c) => {
+    const text = c.parts.filter((p) => p.text !== undefined).map((p) => p.text).join("");
+    return {
+      role: googleRoleToStandard(c.role),
+      content: text || c.parts
+    };
+  });
+}
+function messagesToContents(messages) {
+  return messages.map((m) => ({
+    role: standardRoleToGoogle(m.role),
+    parts: typeof m.content === "string" ? [{ text: m.content }] : Array.isArray(m.content) ? m.content : [{ text: String(m.content) }]
+  }));
+}
+function mapGoogleFinishReason(reason) {
+  if (reason === null)
+    return null;
+  switch (reason) {
+    case "STOP":
+      return "stop";
+    case "MAX_TOKENS":
+      return "max_tokens";
+    case "SAFETY":
+      return "content_filter";
+    default:
+      return reason.toLowerCase();
+  }
+}
+function mapStopReasonToGoogle(reason) {
+  if (reason === null)
+    return "STOP";
+  switch (reason) {
+    case "stop":
+      return "STOP";
+    case "max_tokens":
+      return "MAX_TOKENS";
+    case "content_filter":
+      return "SAFETY";
+    default:
+      return reason.toUpperCase();
+  }
+}
+
+class GoogleGenerativeAIAdapter {
+  apiType = "google-generative-ai";
+  parseRequest(body) {
+    const raw = body;
+    const model = raw.model ?? "";
+    const contents = raw.contents ?? [];
+    const messages = contentsToMessages(contents);
+    let system;
+    if (raw.systemInstruction?.parts) {
+      system = raw.systemInstruction.parts.filter((p) => p.text !== undefined).map((p) => p.text).join("");
+    }
+    return {
+      model,
+      messages,
+      system,
+      stream: raw.stream !== false,
+      maxTokens: raw.generationConfig?.maxOutputTokens,
+      rawBody: raw
+    };
+  }
+  buildUpstreamRequest(parsed, targetModel, baseUrl, auth) {
+    const endpoint = parsed.stream ? `${baseUrl}/v1beta/models/${targetModel}:streamGenerateContent?alt=sse` : `${baseUrl}/v1beta/models/${targetModel}:generateContent`;
+    const contents = messagesToContents(parsed.messages);
+    const requestBody = {
+      ...parsed.rawBody,
+      contents
+    };
+    delete requestBody.model;
+    delete requestBody.stream;
+    if (parsed.system) {
+      requestBody.systemInstruction = {
+        parts: [{ text: parsed.system }]
+      };
+    }
+    if (parsed.maxTokens !== undefined) {
+      requestBody.generationConfig = {
+        ...requestBody.generationConfig,
+        maxOutputTokens: parsed.maxTokens
+      };
+    }
+    return {
+      url: endpoint,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        [auth.headerName || "x-goog-api-key"]: auth.headerValue || auth.apiKey
+      },
+      body: JSON.stringify(requestBody)
+    };
+  }
+  modifyMessages(rawBody, compressedMessages) {
+    return {
+      ...rawBody,
+      contents: messagesToContents(compressedMessages)
+    };
+  }
+  parseResponse(body) {
+    const raw = body;
+    const candidates = raw.candidates;
+    const candidate = candidates?.[0];
+    const content = candidate?.content;
+    const text = content?.parts?.filter((p) => p.text !== undefined).map((p) => p.text).join("") ?? "";
+    const finishReason = candidate?.finishReason;
+    const usageMeta = raw.usageMetadata;
+    return {
+      id: raw.id ?? `google-${Date.now()}`,
+      model: raw.modelVersion ?? "",
+      content: text,
+      role: "assistant",
+      stopReason: mapGoogleFinishReason(finishReason ?? null),
+      usage: usageMeta ? {
+        inputTokens: usageMeta.promptTokenCount ?? 0,
+        outputTokens: usageMeta.candidatesTokenCount ?? 0
+      } : undefined
+    };
+  }
+  buildResponse(parsed) {
+    const result = {
+      candidates: [
+        {
+          content: {
+            parts: [{ text: parsed.content }],
+            role: "model"
+          },
+          finishReason: mapStopReasonToGoogle(parsed.stopReason)
+        }
+      ]
+    };
+    if (parsed.usage) {
+      result.usageMetadata = {
+        promptTokenCount: parsed.usage.inputTokens,
+        candidatesTokenCount: parsed.usage.outputTokens
+      };
+    }
+    return result;
+  }
+  parseStreamChunk(chunk) {
+    const events = [];
+    const lines = chunk.split(`
+`);
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("data:"))
+        continue;
+      const jsonStr = trimmed.slice(5).trim();
+      if (jsonStr === "" || jsonStr === "[DONE]")
+        continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(jsonStr);
+      } catch {
+        continue;
+      }
+      const candidates = parsed.candidates;
+      const candidate = candidates?.[0];
+      if (!candidate)
+        continue;
+      const content = candidate.content;
+      const text = content?.parts?.filter((p) => p.text !== undefined).map((p) => p.text).join("") ?? "";
+      const finishReason = candidate.finishReason;
+      if (content?.role === "model" && text !== "") {
+        events.push({
+          type: "message_start",
+          id: parsed.id ?? `google-${Date.now()}`,
+          model: parsed.modelVersion ?? ""
+        });
+        events.push({ type: "content_delta", text, index: 0 });
+      } else if (text !== "") {
+        events.push({ type: "content_delta", text, index: 0 });
+      }
+      if (finishReason && finishReason !== "FINISH_REASON_UNSPECIFIED") {
+        const usageMeta = parsed.usageMetadata;
+        events.push({ type: "content_stop", index: 0 });
+        events.push({
+          type: "message_stop",
+          usage: usageMeta ? {
+            inputTokens: usageMeta.promptTokenCount ?? 0,
+            outputTokens: usageMeta.candidatesTokenCount ?? 0
+          } : undefined
+        });
+      }
+    }
+    return events;
+  }
+  buildStreamChunk(event) {
+    switch (event.type) {
+      case "message_start":
+        return `data: ${JSON.stringify({
+          candidates: [
+            {
+              content: { parts: [{ text: "" }], role: "model" }
+            }
+          ]
+        })}
+
+`;
+      case "content_delta":
+        return `data: ${JSON.stringify({
+          candidates: [
+            {
+              content: { parts: [{ text: event.text }], role: "model" }
+            }
+          ]
+        })}
+
+`;
+      case "content_stop":
+        return "";
+      case "message_stop":
+        return `data: ${JSON.stringify({
+          candidates: [
+            {
+              content: { parts: [{ text: "" }], role: "model" },
+              finishReason: "STOP"
+            }
+          ],
+          ...event.usage ? {
+            usageMetadata: {
+              promptTokenCount: event.usage.inputTokens,
+              candidatesTokenCount: event.usage.outputTokens
+            }
+          } : {}
+        })}
+
+`;
+      case "error":
+        return `data: ${JSON.stringify({
+          error: { message: event.message }
+        })}
+
+`;
+    }
+  }
+}
+var googleAdapter = new GoogleGenerativeAIAdapter;
+registerAdapter(googleAdapter);
+
+// src/adapters/ollama.ts
+class OllamaAdapter {
+  apiType = "ollama";
+  parseRequest(body) {
+    const raw = body;
+    const model = raw.model ?? "";
+    const messages = raw.messages ?? [];
+    const stream = raw.stream !== false;
+    let system;
+    const filteredMessages = [];
+    for (const msg of messages) {
+      if (msg.role === "system" && typeof msg.content === "string") {
+        system = msg.content;
+      } else {
+        filteredMessages.push(msg);
+      }
+    }
+    return {
+      model,
+      messages: filteredMessages,
+      system,
+      stream,
+      maxTokens: raw.options?.num_predict,
+      rawBody: raw
+    };
+  }
+  buildUpstreamRequest(parsed, targetModel, baseUrl, _auth) {
+    const messages = [];
+    if (parsed.system) {
+      messages.push({ role: "system", content: parsed.system });
+    }
+    messages.push(...parsed.messages);
+    const requestBody = {
+      ...parsed.rawBody,
+      model: targetModel,
+      messages,
+      stream: parsed.stream
+    };
+    if (parsed.maxTokens !== undefined) {
+      requestBody.options = {
+        ...requestBody.options,
+        num_predict: parsed.maxTokens
+      };
+    }
+    return {
+      url: `${baseUrl}/api/chat`,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(requestBody)
+    };
+  }
+  modifyMessages(rawBody, compressedMessages) {
+    return {
+      ...rawBody,
+      messages: compressedMessages
+    };
+  }
+  parseResponse(body) {
+    const raw = body;
+    const message = raw.message;
+    const model = raw.model ?? "";
+    return {
+      id: `ollama-${Date.now()}`,
+      model,
+      content: message?.content ?? "",
+      role: "assistant",
+      stopReason: raw.done === true ? "stop" : null,
+      usage: raw.prompt_eval_count !== undefined || raw.eval_count !== undefined ? {
+        inputTokens: raw.prompt_eval_count ?? 0,
+        outputTokens: raw.eval_count ?? 0
+      } : undefined
+    };
+  }
+  buildResponse(parsed) {
+    const result = {
+      model: parsed.model,
+      message: {
+        role: "assistant",
+        content: parsed.content
+      },
+      done: parsed.stopReason === "stop"
+    };
+    if (parsed.usage) {
+      result.prompt_eval_count = parsed.usage.inputTokens;
+      result.eval_count = parsed.usage.outputTokens;
+    }
+    return result;
+  }
+  parseStreamChunk(chunk) {
+    const events = [];
+    const lines = chunk.split(`
+`);
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed === "")
+        continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      const message = parsed.message;
+      const done = parsed.done === true;
+      if (message?.role === "assistant" && !done) {
+        if (events.length === 0 && message.content !== undefined) {
+          events.push({
+            type: "message_start",
+            id: `ollama-${Date.now()}`,
+            model: parsed.model ?? ""
+          });
+        }
+        if (message.content !== undefined) {
+          events.push({
+            type: "content_delta",
+            text: message.content,
+            index: 0
+          });
+        }
+      }
+      if (done) {
+        events.push({ type: "content_stop", index: 0 });
+        events.push({
+          type: "message_stop",
+          usage: parsed.prompt_eval_count !== undefined || parsed.eval_count !== undefined ? {
+            inputTokens: parsed.prompt_eval_count ?? 0,
+            outputTokens: parsed.eval_count ?? 0
+          } : undefined
+        });
+      }
+    }
+    return events;
+  }
+  buildStreamChunk(event) {
+    switch (event.type) {
+      case "message_start":
+        return `${JSON.stringify({
+          model: event.model,
+          message: { role: "assistant", content: "" },
+          done: false
+        })}
+`;
+      case "content_delta":
+        return `${JSON.stringify({
+          message: { role: "assistant", content: event.text },
+          done: false
+        })}
+`;
+      case "content_stop":
+        return "";
+      case "message_stop":
+        return `${JSON.stringify({
+          done: true,
+          ...event.usage ? {
+            prompt_eval_count: event.usage.inputTokens,
+            eval_count: event.usage.outputTokens
+          } : {}
+        })}
+`;
+      case "error":
+        return `${JSON.stringify({
+          error: event.message,
+          done: true
+        })}
+`;
+    }
+  }
+}
+var ollamaAdapter = new OllamaAdapter;
+registerAdapter(ollamaAdapter);
+
+// src/utils/aws-sigv4.ts
+var import_node_crypto = require("node:crypto");
+var SERVICE = "bedrock";
+function sha256(data) {
+  return import_node_crypto.createHash("sha256").update(data).digest("hex");
+}
+function hmacSha256(key, data) {
+  return import_node_crypto.createHmac("sha256", key).update(data).digest();
+}
+function hmacSha256Hex(key, data) {
+  return import_node_crypto.createHmac("sha256", key).update(data).digest("hex");
+}
+function awsUriEncode(str) {
+  return encodeURIComponent(str).replace(/!/g, "%21").replace(/'/g, "%27").replace(/\(/g, "%28").replace(/\)/g, "%29").replace(/\*/g, "%2A");
+}
+function buildCanonicalUri(pathname) {
+  if (pathname === "" || pathname === "/")
+    return "/";
+  const segments = pathname.split("/");
+  return segments.map((segment) => segment === "" ? "" : awsUriEncode(awsUriEncode(segment))).join("/");
+}
+function formatDateStamp(date) {
+  return date.toISOString().slice(0, 10).replace(/-/g, "");
+}
+function formatAmzDate(date) {
+  return date.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}/, "");
+}
+function deriveSigningKey(secretKey, dateStamp, region, service) {
+  const kDate = hmacSha256(`AWS4${secretKey}`, dateStamp);
+  const kRegion = hmacSha256(kDate, region);
+  const kService = hmacSha256(kRegion, service);
+  return hmacSha256(kService, "aws4_request");
+}
+function signRequest(request, credentials, now) {
+  const date = now ?? new Date;
+  const dateStamp = formatDateStamp(date);
+  const amzDate = formatAmzDate(date);
+  const url = new URL(request.url);
+  const canonicalUri = buildCanonicalUri(url.pathname);
+  const sortedParams = [...url.searchParams.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+  const canonicalQueryString = sortedParams.map(([k, v]) => `${awsUriEncode(k)}=${awsUriEncode(v)}`).join("&");
+  const payloadHash = sha256(request.body);
+  const headersToSign = {};
+  for (const [k, v] of Object.entries(request.headers)) {
+    headersToSign[k.toLowerCase()] = v.trim();
+  }
+  headersToSign["host"] = url.host;
+  headersToSign["x-amz-date"] = amzDate;
+  headersToSign["x-amz-content-sha256"] = payloadHash;
+  if (credentials.sessionToken) {
+    headersToSign["x-amz-security-token"] = credentials.sessionToken;
+  }
+  const sortedHeaderKeys = Object.keys(headersToSign).sort();
+  const canonicalHeaders = sortedHeaderKeys.map((k) => `${k}:${headersToSign[k]}`).join(`
+`) + `
+`;
+  const signedHeaders = sortedHeaderKeys.join(";");
+  const canonicalRequest = [
+    request.method,
+    canonicalUri,
+    canonicalQueryString,
+    canonicalHeaders,
+    signedHeaders,
+    payloadHash
+  ].join(`
+`);
+  const credentialScope = `${dateStamp}/${credentials.region}/${SERVICE}/aws4_request`;
+  const stringToSign = [
+    "AWS4-HMAC-SHA256",
+    amzDate,
+    credentialScope,
+    sha256(canonicalRequest)
+  ].join(`
+`);
+  const signingKey = deriveSigningKey(credentials.secretAccessKey, dateStamp, credentials.region, SERVICE);
+  const signature = hmacSha256Hex(signingKey, stringToSign);
+  const authorization = `AWS4-HMAC-SHA256 Credential=${credentials.accessKeyId}/${credentialScope}, ` + `SignedHeaders=${signedHeaders}, Signature=${signature}`;
+  const result = {
+    Authorization: authorization,
+    "x-amz-date": amzDate,
+    "x-amz-content-sha256": payloadHash
+  };
+  if (credentials.sessionToken) {
+    result["x-amz-security-token"] = credentials.sessionToken;
+  }
+  return result;
+}
+function extractRegionFromUrl(url) {
+  const match = url.match(/\.([a-z0-9-]+)\.amazonaws\.com/);
+  return match?.[1];
+}
+
+// src/adapters/bedrock.ts
+function bedrockMessagesToStandard(messages) {
+  return messages.map((m) => {
+    if (typeof m.content === "string") {
+      return { role: m.role, content: m.content };
+    }
+    const textParts = m.content.filter((b) => b.text !== undefined);
+    if (textParts.length === 1) {
+      return { role: m.role, content: textParts[0].text };
+    }
+    return { role: m.role, content: m.content };
+  });
+}
+function standardMessagesToBedrock(messages) {
+  return messages.map((m) => {
+    if (typeof m.content === "string") {
+      return { role: m.role, content: [{ text: m.content }] };
+    }
+    if (Array.isArray(m.content)) {
+      return { role: m.role, content: m.content };
+    }
+    return { role: m.role, content: [{ text: String(m.content) }] };
+  });
+}
+function mapBedrockStopReason(reason) {
+  if (reason === null)
+    return null;
+  switch (reason) {
+    case "end_turn":
+      return "stop";
+    case "max_tokens":
+      return "max_tokens";
+    case "content_filtered":
+      return "content_filter";
+    default:
+      return reason;
+  }
+}
+function mapStopReasonToBedrock(reason) {
+  if (reason === null)
+    return "end_turn";
+  switch (reason) {
+    case "stop":
+      return "end_turn";
+    case "max_tokens":
+      return "max_tokens";
+    case "content_filter":
+      return "content_filtered";
+    default:
+      return reason;
+  }
+}
+
+class BedrockAdapter {
+  apiType = "bedrock-converse-stream";
+  parseRequest(body) {
+    const raw = body;
+    const model = raw.modelId ?? "";
+    const messages = raw.messages ? bedrockMessagesToStandard(raw.messages) : [];
+    let system;
+    if (raw.system && raw.system.length > 0) {
+      if (raw.system.length === 1) {
+        system = raw.system[0].text;
+      } else {
+        system = raw.system.map((s) => ({ type: "text", text: s.text }));
+      }
+    }
+    return {
+      model,
+      messages,
+      system,
+      stream: true,
+      maxTokens: raw.inferenceConfig?.maxTokens,
+      rawBody: raw
+    };
+  }
+  buildUpstreamRequest(parsed, targetModel, baseUrl, auth) {
+    const bedrockMessages = standardMessagesToBedrock(parsed.messages);
+    const requestBody = {
+      ...parsed.rawBody,
+      messages: bedrockMessages
+    };
+    delete requestBody.modelId;
+    if (parsed.system) {
+      if (typeof parsed.system === "string") {
+        requestBody.system = [{ text: parsed.system }];
+      } else {
+        requestBody.system = parsed.system.map((s) => ({ text: s.text }));
+      }
+    }
+    if (parsed.maxTokens !== undefined) {
+      requestBody.inferenceConfig = {
+        ...requestBody.inferenceConfig,
+        maxTokens: parsed.maxTokens
+      };
+    }
+    const url = `${baseUrl}/model/${targetModel}/converse-stream`;
+    const body = JSON.stringify(requestBody);
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (auth.awsAccessKeyId && auth.awsSecretKey && auth.awsRegion) {
+      const sigv4Headers = signRequest({ method: "POST", url, headers, body }, {
+        accessKeyId: auth.awsAccessKeyId,
+        secretAccessKey: auth.awsSecretKey,
+        sessionToken: auth.awsSessionToken,
+        region: auth.awsRegion
+      });
+      Object.assign(headers, sigv4Headers);
+    } else if (auth.apiKey) {
+      headers[auth.headerName || "Authorization"] = auth.headerValue || auth.apiKey;
+    }
+    return { url, method: "POST", headers, body };
+  }
+  modifyMessages(rawBody, compressedMessages) {
+    return {
+      ...rawBody,
+      messages: standardMessagesToBedrock(compressedMessages)
+    };
+  }
+  parseResponse(body) {
+    const raw = body;
+    const output = raw.output;
+    const message = output?.message;
+    const text = message?.content?.filter((b) => b.text !== undefined).map((b) => b.text).join("") ?? "";
+    const stopReason = raw.stopReason;
+    const usage = raw.usage;
+    return {
+      id: raw.requestId ?? `bedrock-${Date.now()}`,
+      model: raw.modelId ?? "",
+      content: text,
+      role: "assistant",
+      stopReason: mapBedrockStopReason(stopReason ?? null),
+      usage: usage ? {
+        inputTokens: usage.inputTokens ?? 0,
+        outputTokens: usage.outputTokens ?? 0
+      } : undefined
+    };
+  }
+  buildResponse(parsed) {
+    const result = {
+      output: {
+        message: {
+          role: "assistant",
+          content: [{ text: parsed.content }]
+        }
+      },
+      stopReason: mapStopReasonToBedrock(parsed.stopReason)
+    };
+    if (parsed.usage) {
+      result.usage = {
+        inputTokens: parsed.usage.inputTokens,
+        outputTokens: parsed.usage.outputTokens
+      };
+    }
+    return result;
+  }
+  parseStreamChunk(chunk) {
+    const events = [];
+    const lines = chunk.split(`
+`);
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed === "")
+        continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (parsed.messageStart !== undefined) {
+        const start = parsed.messageStart;
+        events.push({
+          type: "message_start",
+          id: `bedrock-${Date.now()}`,
+          model: ""
+        });
+      }
+      if (parsed.contentBlockDelta !== undefined) {
+        const delta = parsed.contentBlockDelta;
+        events.push({
+          type: "content_delta",
+          text: delta.delta?.text ?? "",
+          index: delta.contentBlockIndex ?? 0
+        });
+      }
+      if (parsed.contentBlockStop !== undefined) {
+        const stop = parsed.contentBlockStop;
+        events.push({
+          type: "content_stop",
+          index: stop.contentBlockIndex ?? 0
+        });
+      }
+      if (parsed.messageStop !== undefined) {
+        const stop = parsed.messageStop;
+        events.push({
+          type: "message_stop",
+          usage: undefined
+        });
+      }
+      if (parsed.metadata !== undefined) {
+        const meta = parsed.metadata;
+        if (meta.usage) {
+          events.push({
+            type: "message_stop",
+            usage: {
+              inputTokens: meta.usage.inputTokens ?? 0,
+              outputTokens: meta.usage.outputTokens ?? 0
+            }
+          });
+        }
+      }
+    }
+    return events;
+  }
+  buildStreamChunk(event) {
+    switch (event.type) {
+      case "message_start":
+        return `${JSON.stringify({
+          messageStart: { role: "assistant" }
+        })}
+`;
+      case "content_delta":
+        return `${JSON.stringify({
+          contentBlockDelta: {
+            delta: { text: event.text },
+            contentBlockIndex: event.index
+          }
+        })}
+`;
+      case "content_stop":
+        return `${JSON.stringify({
+          contentBlockStop: { contentBlockIndex: event.index }
+        })}
+`;
+      case "message_stop":
+        if (event.usage) {
+          return `${JSON.stringify({
+            messageStop: { stopReason: "end_turn" }
+          })}
+${JSON.stringify({
+            metadata: {
+              usage: {
+                inputTokens: event.usage.inputTokens,
+                outputTokens: event.usage.outputTokens
+              }
+            }
+          })}
+`;
+        }
+        return `${JSON.stringify({
+          messageStop: { stopReason: "end_turn" }
+        })}
+`;
+      case "error":
+        return `${JSON.stringify({
+          error: { message: event.message }
+        })}
+`;
+    }
+  }
+}
+var bedrockAdapter = new BedrockAdapter;
+registerAdapter(bedrockAdapter);
+
+// src/adapters/openai-codex.ts
+class OpenAICodexAdapter {
+  apiType = "openai-codex-responses";
+  parseRequest(body) {
+    return parseOpenAIBody(body);
+  }
+  buildUpstreamRequest(parsed, targetModel, baseUrl, auth) {
+    const { rawBody } = parsed;
+    const upstreamBody = { ...rawBody };
+    upstreamBody.model = targetModel;
+    upstreamBody.stream = true;
+    upstreamBody.store = false;
+    if (!upstreamBody.instructions) {
+      upstreamBody.instructions = upstreamBody.system ?? "You are a helpful assistant.";
+    }
+    delete upstreamBody.system;
+    if (!upstreamBody.input && upstreamBody.messages) {
+      upstreamBody.input = upstreamBody.messages;
+      delete upstreamBody.messages;
+    }
+    delete upstreamBody.max_tokens;
+    delete upstreamBody.max_output_tokens;
+    if (upstreamBody.tools) {
+      upstreamBody.tools = toOpenAITools(upstreamBody.tools);
+    }
+    return {
+      url: `${baseUrl}/codex/responses`,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${auth.apiKey}`
+      },
+      body: JSON.stringify(upstreamBody)
+    };
+  }
+  modifyMessages(rawBody, compressedMessages) {
+    return openaiResponsesAdapter.modifyMessages(rawBody, compressedMessages);
+  }
+  parseResponse(body) {
+    return openaiResponsesAdapter.parseResponse(body);
+  }
+  buildResponse(parsed) {
+    return openaiResponsesAdapter.buildResponse(parsed);
+  }
+  parseStreamChunk(chunk) {
+    return openaiResponsesAdapter.parseStreamChunk(chunk);
+  }
+  buildStreamChunk(event) {
+    return openaiResponsesAdapter.buildStreamChunk(event);
+  }
+}
+var openaiCodexAdapter = new OpenAICodexAdapter;
+registerAdapter(openaiCodexAdapter);
+
+// src/compression/compaction-detector.ts
+var COMPACTION_PATTERNS = [
+  "merge these partial summaries into a single cohesive summary",
+  "preserve all opaque identifiers exactly as written",
+  "your task is to create a detailed summary of the conversation so far",
+  "do not use any tools. you must respond with only the <summary>",
+  "important: do not use any tools",
+  "summarize the conversation",
+  "create a summary of our conversation",
+  "compact the conversation"
+];
+function extractTextFromContent(content) {
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    return content.filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join(`
+`);
+  }
+  return "";
+}
+function detectCompaction(headers, messages) {
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === "x-request-compaction" && value === "true") {
+      return { isCompaction: true, detectedBy: "header", confidence: 1 };
+    }
+  }
+  let lastUserMessage;
+  for (let i = messages.length - 1;i >= 0; i--) {
+    if (messages[i].role === "user") {
+      lastUserMessage = messages[i];
+      break;
+    }
+  }
+  if (lastUserMessage) {
+    const text = extractTextFromContent(lastUserMessage.content).toLowerCase();
+    for (const pattern of COMPACTION_PATTERNS) {
+      if (text.includes(pattern)) {
+        return { isCompaction: true, detectedBy: "prompt_pattern", confidence: 0.95 };
+      }
+    }
+  }
+  return { isCompaction: false, detectedBy: "none", confidence: 0 };
+}
+
+// src/utils/token-estimator.ts
+var TOKENS_PER_CJK = 2.5;
+var CHARS_PER_ASCII_TOKEN = 4;
+var MESSAGE_OVERHEAD = 4;
+function isCJK(charCode) {
+  return charCode >= 12288 && charCode <= 40959 || charCode >= 44032 && charCode <= 55215 || charCode >= 63744 && charCode <= 64255;
+}
+function estimateTokens(text) {
+  if (text.length === 0)
+    return 0;
+  let asciiSegmentLength = 0;
+  let tokenCount = 0;
+  for (let i = 0;i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    if (isCJK(code)) {
+      tokenCount += asciiSegmentLength / CHARS_PER_ASCII_TOKEN;
+      asciiSegmentLength = 0;
+      tokenCount += TOKENS_PER_CJK;
+    } else {
+      asciiSegmentLength++;
+    }
+  }
+  tokenCount += asciiSegmentLength / CHARS_PER_ASCII_TOKEN;
+  return Math.ceil(tokenCount);
+}
+function estimateMessagesTokens(messages) {
+  let total = 0;
+  for (const message of messages) {
+    total += MESSAGE_OVERHEAD;
+    if (typeof message.content === "string") {
+      total += estimateTokens(message.content);
+    } else if (Array.isArray(message.content)) {
+      for (const block of message.content) {
+        if (block.type === "text" && block.text !== undefined) {
+          total += estimateTokens(block.text);
+        }
+      }
+    }
+  }
+  return total;
+}
+
+// src/compression/synthetic-response.ts
+function messageContentToString(content) {
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    return content.filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join(`
+`);
+  }
+  return JSON.stringify(content);
+}
+function formatRecentMessages(messages) {
+  return messages.map((m) => `[${m.role}]: ${messageContentToString(m.content)}`).join(`
+
+`);
+}
+function buildSyntheticSummaryResponse(summary, recentMessages, model) {
+  const recentText = formatRecentMessages(recentMessages);
+  const content = `<summary>
+${summary}
+</summary>
+
+<recent_messages>
+${recentText}
+</recent_messages>`;
+  return {
+    id: `msg_precomputed_${Date.now()}`,
+    model,
+    content,
+    role: "assistant",
+    stopReason: "end_turn",
+    usage: { inputTokens: 0, outputTokens: estimateTokens(content) }
+  };
+}
+function buildSyntheticHttpResponse(parsed, adapter) {
+  const body = adapter.buildResponse ? adapter.buildResponse(parsed) : {
+    id: parsed.id,
+    type: "message",
+    role: "assistant",
+    model: parsed.model,
+    content: [{ type: "text", text: parsed.content }],
+    stop_reason: parsed.stopReason,
+    usage: parsed.usage ? {
+      input_tokens: parsed.usage.inputTokens,
+      output_tokens: parsed.usage.outputTokens
+    } : undefined
+  };
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: {
+      "content-type": "application/json",
+      "x-synthetic-response": "true"
+    }
+  });
+}
+
+// src/routing/local-classifier.ts
+var import_transformers = require("@huggingface/transformers");
+var CAT_L = "L";
+var CAT_M = "M";
+var CAT_H = "H";
+var CAT_Q = "Q";
+var TIER_MAP = {
+  L: "LIGHT",
+  M: "MEDIUM",
+  H: "HEAVY"
+};
+var MODEL_ID = "Xenova/multilingual-e5-small";
+var E5_PREFIX = "query: ";
+var BATCH_SIZE = 32;
+var TRAINING_LIGHT = [
+  "안녕하세요",
+  "안녕",
+  "안녕히 가세요",
+  "안녕히 계세요",
+  "반갑습니다",
+  "잘 지내시죠",
+  "오랜만이에요",
+  "고마워",
+  "감사합니다",
+  "고맙습니다",
+  "네 고마워요",
+  "정말 감사합니다",
+  "도와줘서 고마워",
+  "네",
+  "예",
+  "아니요",
+  "좋아요",
+  "알겠습니다",
+  "확인했습니다",
+  "그래요",
+  "맞아요",
+  "아 네",
+  "Python이 뭐야?",
+  "JavaScript가 뭐야?",
+  "오늘 날씨 어때?",
+  "지금 몇 시야?",
+  "이거 뭐야?",
+  "TypeScript가 뭐예요?",
+  "API가 뭐야?",
+  "HTML이 뭐야?",
+  "CSS가 뭐야?",
+  "Hello",
+  "Hi",
+  "Hey there",
+  "Good morning",
+  "Good afternoon",
+  "How are you",
+  "What's up",
+  "Thanks",
+  "Thank you",
+  "Got it",
+  "OK",
+  "Sounds good",
+  "I see",
+  "Understood",
+  "Great thanks",
+  "What is Python?",
+  "What time is it?",
+  "What's the weather?",
+  "Who is Einstein?",
+  "Where is Seoul?",
+  "How old are you?",
+  "yes",
+  "no",
+  "maybe",
+  "sure",
+  "please",
+  "done",
+  "ok",
+  "cool",
+  "nice",
+  "awesome"
+];
+var TRAINING_MEDIUM = [
+  "Write a quicksort function in TypeScript",
+  "Implement a binary search tree with insert and delete",
+  "Create a REST API endpoint for user authentication",
+  "Write a function to merge two sorted arrays",
+  "Implement a linked list in Python",
+  "Write a unit test for the calculator module",
+  "Create a simple Express.js middleware for logging",
+  "Write a regex to validate email addresses",
+  "Implement a LRU cache with get and put operations",
+  "Create a React component for a todo list",
+  "Write a SQL query to join two tables",
+  "Implement a basic JWT authentication flow",
+  "Write a function to parse CSV files",
+  "Create a simple WebSocket server",
+  "Implement bubble sort in Java",
+  "Write a Python script to read a JSON file",
+  "Create a Docker compose file for a web app",
+  "Write a Git pre-commit hook",
+  "REST API에 로그인 엔드포인트 추가해줘",
+  "이 함수에 에러 핸들링 추가해줘",
+  "TypeScript로 이벤트 이미터 만들어줘",
+  "데이터베이스 마이그레이션 스크립트 작성해줘",
+  "React 컴포넌트에 상태 관리 추가해줘",
+  "Express 라우터에 CORS 미들웨어 추가해줘",
+  "테스트 코드 작성해줘",
+  "이 코드 리팩토링해줘",
+  "Explain the difference between let and const in JavaScript",
+  "What's the difference between SQL and NoSQL databases",
+  "Explain how async await works in Python",
+  "Describe the MVC architecture pattern",
+  "Explain what Docker containers are",
+  "REST와 GraphQL의 차이점을 설명해줘",
+  "이벤트 루프가 어떻게 동작하는지 설명해줘",
+  "클로저가 뭐야? 설명해줘",
+  "Set up a Node.js project with TypeScript and ESLint",
+  "Create a basic CI/CD pipeline using GitHub Actions",
+  "Configure Nginx as a reverse proxy for a Node.js app",
+  `이 함수를 리팩토링해줘:
+function processUsers(data) {
+  var result = [];
+  for (var i = 0; i < data.length; i++) {
+    if (data[i].active == true && data[i].age > 18) {
+      var name = data[i].firstName + ' ' + data[i].lastName;
+      var obj = { name: name, email: data[i].email, role: data[i].isAdmin ? 'admin' : 'user' };
+      if (data[i].department !== null && data[i].department !== undefined) {
+        obj.department = data[i].department.name;
+        obj.manager = data[i].department.manager ? data[i].department.manager.name : 'N/A';
+      }
+      result.push(obj);
+    }
+  }
+  result.sort(function(a, b) { return a.name > b.name ? 1 : -1; });
+  return result;
+}`,
+  `Refactor this code to use modern JavaScript:
+function getItems(list) {
+  var items = [];
+  for (var i = 0; i < list.length; i++) {
+    if (list[i].active === true) {
+      items.push(list[i].name);
+    }
+  }
+  return items;
+}`
+];
+var TRAINING_HEAVY = [
+  "Design a distributed consensus algorithm for a multi-region database with strong consistency and Byzantine fault tolerance",
+  "Explain the theoretical foundations of quantum computing and how quantum entanglement can be used for cryptographic key distribution",
+  "Analyze the trade-offs between eventual consistency and strong consistency in distributed systems, including CAP theorem implications",
+  "Design a fault-tolerant microservices architecture for a real-time trading platform handling millions of transactions per second",
+  "Propose a novel approach to solving the traveling salesman problem that improves upon current approximation algorithms",
+  "Design a machine learning pipeline for real-time fraud detection in financial transactions with sub-millisecond latency requirements",
+  "Compare and contrast different consensus protocols (Paxos, Raft, PBFT) and recommend the best one for a blockchain-based supply chain system",
+  "Architect a system that can handle 10 million concurrent WebSocket connections with horizontal scaling",
+  "Design a real-time data streaming architecture combining Kafka, Flink, and a time-series database for IoT sensor data",
+  "메모리 릭이 발생하는데 프로파일러에서 이벤트 루프 블로킹과 GC 지연이 동시에 나타나. 마이크로서비스 간 gRPC 연결 풀링도 의심되는 상황인데 원인 분석 방법을 단계별로 설명해줘",
+  "대규모 분산 시스템에서 파티션 톨런스와 일관성을 동시에 보장하는 방법을 설계해줘",
+  "실시간 추천 시스템을 위한 아키텍처를 설계해줘. 1초 이내에 개인화된 추천을 제공해야 해",
+  "카프카 기반 이벤트 드리븐 아키텍처에서 순서 보장과 정확히 한 번 처리를 어떻게 보장할 수 있을까?",
+  "마이크로서비스 간의 분산 트랜잭션을 사가 패턴으로 구현하는 방법을 단계별로 설명해줘",
+  "Debug a memory leak in a production Node.js application where the heap grows indefinitely but garbage collection logs show normal behavior",
+  "Investigate why our Kubernetes pods are being OOMKilled despite having memory limits set to 4GB and actual usage reported as 2GB",
+  "Find the root cause of intermittent 500ms latency spikes in our PostgreSQL queries that happen every 15 minutes",
+  "Design a multi-tenant SaaS platform with shared infrastructure but isolated data, supporting custom domains and white-labeling",
+  "Implement a distributed task scheduler that guarantees at-least-once execution with idempotency support across multiple data centers"
+];
+var TRAINING_Q = [
+  "아까 그거 다시 해줘",
+  "그거 좀 더 자세히 설명해줘",
+  "아까 말한 거 그대로 해줘",
+  "이거 수정해줘",
+  "저거 어디 있지",
+  "그거 어떻게 됐어",
+  "위에꺼 다시 한번",
+  "그거 그대로 해줘",
+  "아까 한 거 다시",
+  "그 코드 다시 보여줘",
+  "저번에 한 거 기억나?",
+  "그 부분 수정해줘",
+  "Do that again",
+  "What about the thing we discussed earlier",
+  "Show me that again",
+  "Can you fix that",
+  "Change it like I said before",
+  "Continue from where we left off",
+  "That thing from earlier, do it again",
+  "Remember what we were working on",
+  "Go back to the previous one",
+  "Make it like the other one",
+  "The same thing but different",
+  "Update the one from before",
+  "그거 해줘",
+  "이거 해줘",
+  "저거 어때",
+  "How about this one",
+  "What about that",
+  "Try the other approach",
+  "Use the one I mentioned",
+  "Fix the issue",
+  "그냥 그거",
+  "이건 어때",
+  "Make it better",
+  "Change it",
+  "이거 수정해"
+];
+var Q_PATTERNS = [
+  /^(아까|그거|저거|이거|그|위에|아래|저번|이전|전에).*(다시|해줘|해|보여|설명|수정|변경|삭제|추가|해봐)/,
+  /^(그거|저거|이거|그|이|저)(만|만큼|대로|처럼|같이)?\s*(해줘|해|놔|둬|봐|어때|어떻게)/,
+  /^(그거|저거|이거)\s*$/,
+  /(아까|저번에|전에|위에서|앞에서|이전에).*(그|그거|그것|그때|했던|말한)/,
+  /^(이거|저거|그거)(\s*.*)?$/
+];
+var DEICTIC_WORDS = new Set(["그거", "저거", "이거", "그것", "이것", "저것", "아까", "저번"]);
+function matchesQPattern(text) {
+  const trimmed = text.trim();
+  for (const pattern of Q_PATTERNS) {
+    if (pattern.test(trimmed))
+      return true;
+  }
+  if (trimmed.length < 20) {
+    for (const word of DEICTIC_WORDS) {
+      if (trimmed.includes(word))
+        return true;
+    }
+  }
+  return false;
+}
+var CODE_PATTERN = /[{}();]|function |const |let |var |class |import |export |=>|\bdef \b|\bfn\b/;
+var TECH_TERMS = /\b(implement|create|design|architect|debug|refactor|migrate|deploy|build|write|develop)\b/i;
+function isLikelyLight(text) {
+  const trimmed = text.trim();
+  if (trimmed.length <= 20 && !CODE_PATTERN.test(trimmed) && !TECH_TERMS.test(trimmed)) {
+    return true;
+  }
+  return false;
+}
+var extractorPromise = null;
+function getExtractor() {
+  if (!extractorPromise) {
+    console.log("[clawmux] Loading embedding model...");
+    extractorPromise = import_transformers.pipeline("feature-extraction", MODEL_ID).then((pipe) => {
+      console.log("[clawmux] Embedding model loaded");
+      return pipe;
+    });
+  }
+  return extractorPromise;
+}
+var centroidsPromise = null;
+async function computeMeanEmbedding(texts) {
+  const extractor = await getExtractor();
+  const allEmbeddings = [];
+  for (let i = 0;i < texts.length; i += BATCH_SIZE) {
+    const batch = texts.slice(i, i + BATCH_SIZE).map((t) => E5_PREFIX + t);
+    const output = await extractor(batch, { pooling: "mean", normalize: true });
+    const list = output.tolist();
+    for (const emb of list) {
+      allEmbeddings.push(emb);
+    }
+  }
+  if (allEmbeddings.length === 0)
+    return [];
+  const dim = allEmbeddings[0].length;
+  const mean = new Array(dim).fill(0);
+  for (const emb of allEmbeddings) {
+    for (let j = 0;j < dim; j++) {
+      mean[j] += emb[j] / allEmbeddings.length;
+    }
+  }
+  const magnitude = Math.sqrt(mean.reduce((sum, v) => sum + v * v, 0));
+  if (magnitude > 0) {
+    for (let j = 0;j < dim; j++)
+      mean[j] /= magnitude;
+  }
+  return mean;
+}
+function getCentroids() {
+  if (!centroidsPromise) {
+    centroidsPromise = (async () => {
+      console.log("[clawmux] Computing category centroids...");
+      const [cL, cM, cH, cQ] = await Promise.all([
+        computeMeanEmbedding(TRAINING_LIGHT),
+        computeMeanEmbedding(TRAINING_MEDIUM),
+        computeMeanEmbedding(TRAINING_HEAVY),
+        computeMeanEmbedding(TRAINING_Q)
+      ]);
+      console.log(`[clawmux] Centroids ready: L=${TRAINING_LIGHT.length} M=${TRAINING_MEDIUM.length} ` + `H=${TRAINING_HEAVY.length} Q=${TRAINING_Q.length} samples`);
+      return { [CAT_L]: cL, [CAT_M]: cM, [CAT_H]: cH, [CAT_Q]: cQ };
+    })();
+  }
+  return centroidsPromise;
+}
+function cosineSimilarity(a, b) {
+  let dot = 0;
+  let magA = 0;
+  let magB = 0;
+  for (let i = 0;i < a.length; i++) {
+    dot += a[i] * b[i];
+    magA += a[i] * a[i];
+    magB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(magA) * Math.sqrt(magB);
+  return denom > 0 ? dot / denom : 0;
+}
+async function classifyLocal(messages, config) {
+  const userText = extractLastUserText(messages);
+  if (!userText) {
+    return {
+      tier: "MEDIUM",
+      confidence: 0,
+      reasoning: "No user message found",
+      error: "No user message found in request"
+    };
+  }
+  const centroids = await getCentroids();
+  const extractor = await getExtractor();
+  const output = await extractor([E5_PREFIX + userText], { pooling: "mean", normalize: true });
+  const inputEmb = output.tolist()[0];
+  let bestCat = CAT_M;
+  let bestSim = -Infinity;
+  for (const [cat, centroid] of Object.entries(centroids)) {
+    const sim = cosineSimilarity(inputEmb, centroid);
+    if (sim > bestSim) {
+      bestSim = sim;
+      bestCat = cat;
+    }
+  }
+  if (isLikelyLight(userText) && bestCat !== CAT_Q) {
+    bestCat = CAT_L;
+    bestSim = Math.max(bestSim, 0.7);
+  }
+  const heuristicQ = matchesQPattern(userText);
+  if (bestCat === CAT_Q || heuristicQ) {
+    const contextText = buildContextText(messages, userText, config?.contextMessages ?? 10);
+    const ctxOutput = await extractor([E5_PREFIX + contextText], { pooling: "mean", normalize: true });
+    const contextEmb = ctxOutput.tolist()[0];
+    let reBestCat = CAT_M;
+    let reBestSim = -Infinity;
+    for (const [cat, centroid] of Object.entries(centroids)) {
+      if (cat === CAT_Q)
+        continue;
+      const sim = cosineSimilarity(contextEmb, centroid);
+      if (sim > reBestSim) {
+        reBestSim = sim;
+        reBestCat = cat;
+      }
+    }
+    const tier2 = TIER_MAP[reBestCat] ?? "MEDIUM";
+    return {
+      tier: tier2,
+      confidence: reBestSim,
+      reasoning: `Re-classified with context (initial: Q, heuristic: ${heuristicQ})`
+    };
+  }
+  const tier = TIER_MAP[bestCat] ?? "MEDIUM";
+  return { tier, confidence: bestSim };
+}
+function extractLastUserText(messages) {
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role !== "user")
+      continue;
+    if (typeof msg.content === "string") {
+      return msg.content;
+    }
+    if (Array.isArray(msg.content)) {
+      const parts = [];
+      for (const block of msg.content) {
+        if (block.type === "text" && block.text) {
+          parts.push(block.text);
+        }
+      }
+      if (parts.length > 0)
+        return parts.join(" ");
+    }
+  }
+  return;
+}
+function buildContextText(allMessages, currentText, contextCount) {
+  const relevantMessages = allMessages.filter((m) => m.role === "user" || m.role === "assistant");
+  const lastN = relevantMessages.slice(-contextCount);
+  const parts = [];
+  for (const msg of lastN) {
+    let text;
+    if (typeof msg.content === "string") {
+      text = msg.content;
+    } else if (Array.isArray(msg.content)) {
+      text = msg.content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join(" ");
+    } else {
+      continue;
+    }
+    parts.push(`[${msg.role}]: ${text}`);
+  }
+  const lastPart = parts[parts.length - 1];
+  if (!lastPart || !lastPart.includes(currentText)) {
+    parts.push(`[user]: ${currentText}`);
+  }
+  return parts.join(`
+`);
+}
+
+// src/openclaw/auth-resolver.ts
+var PROVIDER_ENV_VARS = {
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  google: "GEMINI_API_KEY",
+  gemini: "GEMINI_API_KEY",
+  zai: "ZAI_API_KEY",
+  aws: "AWS_ACCESS_KEY_ID",
+  bedrock: "AWS_ACCESS_KEY_ID"
+};
+function getEnvFallback(provider) {
+  const exact = PROVIDER_ENV_VARS[provider];
+  if (exact)
+    return process.env[exact];
+  for (const [key, envVar] of Object.entries(PROVIDER_ENV_VARS)) {
+    if (provider.startsWith(key)) {
+      return process.env[envVar];
+    }
+  }
+  return;
+}
+function formatAuth(apiKey, providerConfig) {
+  const api = providerConfig?.api ?? "";
+  if (api === "anthropic-messages") {
+    return { apiKey, headerName: "x-api-key", headerValue: apiKey };
+  }
+  if (api === "openai-completions" || api === "openai-responses") {
+    return { apiKey, headerName: "Authorization", headerValue: `Bearer ${apiKey}` };
+  }
+  if (api === "google-generative-ai") {
+    return { apiKey, headerName: "x-goog-api-key", headerValue: apiKey };
+  }
+  if (api === "bedrock-converse-stream") {
+    const secretKey = process.env.AWS_SECRET_ACCESS_KEY ?? "";
+    const sessionToken = process.env.AWS_SESSION_TOKEN;
+    const region = process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? extractRegionFromUrl(providerConfig?.baseUrl ?? "") ?? "us-east-1";
+    return {
+      apiKey,
+      headerName: "Authorization",
+      headerValue: "",
+      awsAccessKeyId: apiKey,
+      awsSecretKey: secretKey,
+      awsSessionToken: sessionToken,
+      awsRegion: region
     };
   }
+  return { apiKey, headerName: "Authorization", headerValue: `Bearer ${apiKey}` };
 }
-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);
+var NO_AUTH_APIS = new Set(["ollama"]);
+function resolveApiKey(provider, openclawConfig, authProfiles) {
+  const providerConfig = getProviderConfig(provider, openclawConfig);
+  const api = providerConfig?.api ?? "";
+  if (NO_AUTH_APIS.has(api)) {
+    return { apiKey: "ollama-local", headerName: "", headerValue: "" };
+  }
+  for (const profile of authProfiles) {
+    if (profile.provider === provider) {
+      const key = profile.apiKey ?? profile.token;
+      if (key) {
+        const resolved = resolveEnvVar(key);
+        if (resolved) {
+          return formatAuth(resolved, providerConfig);
+        }
       }
-      return handler(req, null);
     }
   }
-  return jsonResponse({ error: "not found" }, 404);
+  if (providerConfig?.apiKey) {
+    const resolved = resolveEnvVar(providerConfig.apiKey);
+    if (resolved) {
+      return formatAuth(resolved, providerConfig);
+    }
+  }
+  const envKey = getEnvFallback(provider);
+  if (envKey) {
+    return formatAuth(envKey, providerConfig);
+  }
+  return;
 }
 
-// src/utils/runtime.ts
-var isBun = typeof globalThis.Bun !== "undefined";
+// src/adapters/stream-transformer.ts
+var encoder = new TextEncoder;
+var decoder = new TextDecoder;
+function createStreamTranslator(sourceAdapter, targetAdapter) {
+  if (sourceAdapter.apiType === targetAdapter.apiType) {
+    return new TransformStream;
+  }
+  let buffer = "";
+  let messageStarted = false;
+  return new TransformStream({
+    transform(chunk, controller) {
+      if (!sourceAdapter.parseStreamChunk || !targetAdapter.buildStreamChunk) {
+        controller.enqueue(chunk);
+        return;
+      }
+      buffer += decoder.decode(chunk, { stream: true });
+      let delimiterIndex;
+      while ((delimiterIndex = buffer.indexOf(`
 
-// src/proxy/server.ts
-function createServer(config) {
-  if (isBun) {
-    return createBunServer(config);
+`)) !== -1) {
+        const frame = buffer.slice(0, delimiterIndex);
+        buffer = buffer.slice(delimiterIndex + 2);
+        if (frame.trim() === "")
+          continue;
+        const events = sourceAdapter.parseStreamChunk(frame);
+        for (const event of events) {
+          if (event.type === "message_start") {
+            messageStarted = true;
+          } else if (!messageStarted && (event.type === "content_delta" || event.type === "content_stop")) {
+            messageStarted = true;
+            const synthetic = targetAdapter.buildStreamChunk({
+              type: "message_start",
+              id: "",
+              model: ""
+            });
+            if (synthetic)
+              controller.enqueue(encoder.encode(synthetic));
+          }
+          const translated = targetAdapter.buildStreamChunk(event);
+          controller.enqueue(encoder.encode(translated));
+        }
+      }
+    },
+    flush(controller) {
+      if (buffer.trim() !== "" && sourceAdapter.parseStreamChunk && targetAdapter.buildStreamChunk) {
+        const events = sourceAdapter.parseStreamChunk(buffer);
+        for (const event of events) {
+          if (event.type === "message_start") {
+            messageStarted = true;
+          } else if (!messageStarted && (event.type === "content_delta" || event.type === "content_stop")) {
+            messageStarted = true;
+            const synthetic = targetAdapter.buildStreamChunk({
+              type: "message_start",
+              id: "",
+              model: ""
+            });
+            if (synthetic)
+              controller.enqueue(encoder.encode(synthetic));
+          }
+          const translated = targetAdapter.buildStreamChunk(event);
+          controller.enqueue(encoder.encode(translated));
+        }
+      }
+    }
+  });
+}
+function getStreamContentType(adapter) {
+  switch (adapter.apiType) {
+    case "anthropic-messages":
+    case "openai-completions":
+    case "openai-responses":
+      return "text/event-stream";
+    case "google-generative-ai":
+      return "application/json";
+    case "ollama":
+      return "application/x-ndjson";
+    case "bedrock-converse-stream":
+      return "application/vnd.amazon.eventstream";
+    default:
+      return "text/event-stream";
   }
-  return createNodeServer(config);
 }
-function createBunServer(config) {
-  let server = null;
+async function translateResponse(sourceAdapter, targetAdapter, upstreamResponse, streaming) {
+  if (sourceAdapter.apiType === targetAdapter.apiType) {
+    return upstreamResponse;
+  }
+  if (!streaming) {
+    return translateNonStreamingResponse(sourceAdapter, targetAdapter, upstreamResponse);
+  }
+  return translateStreamingResponse(sourceAdapter, targetAdapter, upstreamResponse);
+}
+async function translateNonStreamingResponse(sourceAdapter, targetAdapter, upstreamResponse) {
+  if (!sourceAdapter.parseResponse || !targetAdapter.buildResponse) {
+    return upstreamResponse;
+  }
+  const body = await upstreamResponse.json();
+  const parsed = sourceAdapter.parseResponse(body);
+  const translated = targetAdapter.buildResponse(parsed);
+  const headers = copyRelevantHeaders(upstreamResponse.headers);
+  headers.set("content-type", "application/json");
+  return new Response(JSON.stringify(translated), {
+    status: upstreamResponse.status,
+    headers
+  });
+}
+function translateStreamingResponse(sourceAdapter, targetAdapter, upstreamResponse) {
+  if (!upstreamResponse.body) {
+    return upstreamResponse;
+  }
+  if (!sourceAdapter.parseStreamChunk || !targetAdapter.buildStreamChunk) {
+    return upstreamResponse;
+  }
+  const translator = createStreamTranslator(sourceAdapter, targetAdapter);
+  const translatedBody = upstreamResponse.body.pipeThrough(translator);
+  const headers = copyRelevantHeaders(upstreamResponse.headers);
+  headers.set("content-type", getStreamContentType(targetAdapter));
+  return new Response(translatedBody, {
+    status: upstreamResponse.status,
+    headers
+  });
+}
+function copyRelevantHeaders(source) {
+  const headers = new Headers;
+  const passthrough = [
+    "cache-control",
+    "x-request-id",
+    "x-ratelimit-limit",
+    "x-ratelimit-remaining",
+    "x-ratelimit-reset"
+  ];
+  for (const name of passthrough) {
+    const value = source.get(name);
+    if (value !== null) {
+      headers.set(name, value);
+    }
+  }
+  return headers;
+}
+
+// src/compression/session-store.ts
+function djb2Hash(str) {
+  let hash = 5381;
+  for (let i = 0;i < str.length; i++) {
+    hash = (hash << 5) + hash + str.charCodeAt(i) | 0;
+  }
+  return hash >>> 0;
+}
+function generateSessionId(messages) {
+  const firstUserMessage = messages.find((m) => m.role === "user");
+  if (!firstUserMessage)
+    return "empty-session";
+  const content = typeof firstUserMessage.content === "string" ? firstUserMessage.content : JSON.stringify(firstUserMessage.content);
+  return `session-${djb2Hash(content)}`;
+}
+function createSessionStore(maxSessions = 500) {
+  const store = new Map;
+  function evictLru() {
+    if (store.size < maxSessions)
+      return;
+    let oldestId = "";
+    let oldestAccess = Infinity;
+    for (const [id, session] of store) {
+      if (session.lastAccess < oldestAccess) {
+        oldestAccess = session.lastAccess;
+        oldestId = id;
+      }
+    }
+    if (oldestId)
+      store.delete(oldestId);
+  }
   return {
-    start() {
-      if (server)
-        return;
-      const bun = globalThis.Bun;
-      server = bun.serve({
-        port: config.port,
-        hostname: config.host,
-        fetch: dispatch
-      });
+    get(id) {
+      const session = store.get(id);
+      if (session) {
+        session.lastAccess = Date.now();
+      }
+      return session;
     },
-    stop() {
-      if (!server)
+    getOrCreate(id, messages) {
+      const existing = store.get(id);
+      if (existing) {
+        existing.lastAccess = Date.now();
+        return existing;
+      }
+      evictLru();
+      const session = {
+        id,
+        messages,
+        tokenCount: 0,
+        compressionState: "idle",
+        lastAccess: Date.now()
+      };
+      store.set(id, session);
+      return session;
+    },
+    set(id, session) {
+      if (!store.has(id)) {
+        evictLru();
+      }
+      if (session.lastAccess === 0) {
+        session.lastAccess = Date.now();
+      }
+      store.set(id, session);
+    },
+    update(id, updates) {
+      const session = store.get(id);
+      if (!session)
         return;
-      server.stop(true);
-      server = null;
+      Object.assign(session, updates);
+      session.lastAccess = Date.now();
+      return session;
+    },
+    delete(id) {
+      return store.delete(id);
+    },
+    size() {
+      return store.size;
+    },
+    has(id) {
+      return store.has(id);
     }
   };
 }
-function createNodeServer(config) {
-  let server = null;
+
+// src/compression/worker.ts
+var SUMMARY_PREFIX = "[Summary of previous conversation]";
+function messageContentToString2(content) {
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    return content.filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join(`
+`);
+  }
+  return JSON.stringify(content);
+}
+function estimateMessageTokens(msg) {
+  const MESSAGE_OVERHEAD2 = 4;
+  return MESSAGE_OVERHEAD2 + estimateTokens(messageContentToString2(msg.content));
+}
+function buildCompressionPrompt(messages, targetTokens) {
+  const conversationText = messages.map((m) => `${m.role}: ${messageContentToString2(m.content)}`).join(`
+
+`);
+  return [
+    {
+      role: "system",
+      content: [
+        "You are a conversation summarizer. Produce a concise summary of the conversation below.",
+        `Target length: approximately ${targetTokens} tokens.`,
+        "Preserve: key decisions, code snippets, technical details, and action items.",
+        "Format: plain text paragraphs. Start with the most important context."
+      ].join(`
+`)
+    },
+    {
+      role: "user",
+      content: conversationText
+    }
+  ];
+}
+function buildCompressedMessages(summary) {
+  return [
+    {
+      role: "user",
+      content: `${SUMMARY_PREFIX}
+${summary}`
+    },
+    {
+      role: "assistant",
+      content: "Understood. I have the context from our previous conversation. How can I help you continue?"
+    }
+  ];
+}
+function truncateToFit(messages, targetTokens) {
+  const result = [];
+  let usedTokens = 0;
+  const firstMsg = messages[0];
+  const firstContent = firstMsg ? messageContentToString2(firstMsg.content) : "";
+  const hasSystemPrefix = firstMsg?.role === "user" && firstContent.startsWith(SUMMARY_PREFIX);
+  if (hasSystemPrefix && firstMsg) {
+    const tokens = estimateMessageTokens(firstMsg);
+    result.push(firstMsg);
+    usedTokens += tokens;
+  }
+  const tail = [];
+  const startIdx = hasSystemPrefix ? 1 : 0;
+  for (let i = messages.length - 1;i >= startIdx; i--) {
+    const msg = messages[i];
+    const tokens = estimateMessageTokens(msg);
+    if (usedTokens + tokens > targetTokens)
+      break;
+    tail.unshift(msg);
+    usedTokens += tokens;
+  }
+  return [...result, ...tail];
+}
+function createCompressionWorker(config) {
+  let activeJobs = 0;
+  let completedJobs = 0;
+  let failedJobs = 0;
+  function shouldCompress(session) {
+    const thresholdTokens = config.threshold * config.contextWindow;
+    return session.tokenCount >= thresholdTokens && session.compressionState === "idle";
+  }
+  function triggerCompression(session, sessionStore, makeApiCall) {
+    if (activeJobs >= config.maxConcurrent)
+      return;
+    session.compressionState = "computing";
+    session.snapshotIndex = session.messages.length;
+    sessionStore.update(session.id, {
+      compressionState: "computing",
+      snapshotIndex: session.messages.length
+    });
+    activeJobs++;
+    const targetTokens = config.targetRatio * config.contextWindow;
+    const promptMessages = buildCompressionPrompt(session.messages, targetTokens);
+    const sessionId = session.id;
+    const originalMessages = [...session.messages];
+    const jobPromise = Promise.race([
+      makeApiCall(config.compressionModel, promptMessages),
+      new Promise((_resolve, reject) => {
+        setTimeout(() => reject(new Error("compression_timeout")), config.timeoutMs);
+      })
+    ]);
+    jobPromise.then((summaryText) => {
+      const compressed = buildCompressedMessages(summaryText);
+      sessionStore.update(sessionId, {
+        compressionState: "ready",
+        compressedSummary: summaryText,
+        compressedMessages: compressed
+      });
+      const current = sessionStore.get(sessionId);
+      if (current) {
+        session.compressionState = current.compressionState;
+        session.compressedSummary = current.compressedSummary;
+        session.compressedMessages = current.compressedMessages;
+      }
+      activeJobs--;
+      completedJobs++;
+    }).catch((error) => {
+      if (error.message === "compression_timeout") {
+        const truncated = truncateToFit(originalMessages, targetTokens);
+        sessionStore.update(sessionId, {
+          compressionState: "ready",
+          compressedMessages: truncated
+        });
+        const current = sessionStore.get(sessionId);
+        if (current) {
+          session.compressionState = current.compressionState;
+          session.compressedMessages = current.compressedMessages;
+        }
+        activeJobs--;
+        completedJobs++;
+      } else {
+        sessionStore.update(sessionId, { compressionState: "idle" });
+        session.compressionState = "idle";
+        activeJobs--;
+        failedJobs++;
+        console.error(`[CompressionWorker] Job failed for session ${sessionId}:`, error.message);
+      }
+    });
+  }
+  function applyCompression(session) {
+    if (session.compressionState !== "ready" || !session.compressedMessages) {
+      return;
+    }
+    const compressed = session.compressedMessages;
+    const snapshotIdx = session.snapshotIndex ?? session.messages.length - 3;
+    const postSnapshotMessages = session.messages.slice(snapshotIdx);
+    const combined = [...compressed, ...postSnapshotMessages];
+    session.compressionState = "idle";
+    session.compressedMessages = undefined;
+    session.compressedSummary = undefined;
+    session.snapshotIndex = undefined;
+    return combined;
+  }
+  function getStats() {
+    return { activeJobs, completedJobs, failedJobs };
+  }
   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 }));
+    shouldCompress,
+    triggerCompression,
+    applyCompression,
+    getStats
+  };
+}
+
+// src/proxy/compression-integration.ts
+var HARD_CEILING_RATIO = 0.9;
+function messagesToTokenMessages(messages) {
+  return messages.map((m) => ({
+    role: m.role,
+    content: m.content
+  }));
+}
+function extractResponseText(responseBody) {
+  try {
+    const parsed = JSON.parse(responseBody);
+    if (Array.isArray(parsed.content)) {
+      const textBlocks = parsed.content.filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text);
+      if (textBlocks.length > 0)
+        return textBlocks.join(`
+`);
+    }
+    if (Array.isArray(parsed.choices)) {
+      const choices = parsed.choices;
+      const first = choices[0];
+      if (first) {
+        const message = first.message;
+        if (message && typeof message.content === "string") {
+          return message.content;
         }
+      }
+    }
+    return JSON.stringify(parsed);
+  } catch {
+    return responseBody;
+  }
+}
+function createMakeApiCall(adapter, compressionModel, baseUrl, auth) {
+  const actualModelId = compressionModel.includes("/") ? compressionModel.split("/").slice(1).join("/") : compressionModel;
+  return async (model, messages) => {
+    const syntheticParsed = {
+      model,
+      messages: messages.map((m) => ({ role: m.role, content: m.content })),
+      stream: false,
+      maxTokens: 4096,
+      rawBody: {
+        model,
+        messages,
+        stream: false,
+        max_tokens: 4096
+      }
+    };
+    const upstream = adapter.buildUpstreamRequest(syntheticParsed, actualModelId, baseUrl, auth);
+    const response = await fetch(upstream.url, {
+      method: upstream.method,
+      headers: upstream.headers,
+      body: upstream.body
+    });
+    const body = await response.text();
+    if (!response.ok) {
+      throw new Error(`Compression API call failed: ${response.status} ${body}`);
+    }
+    return extractResponseText(body);
+  };
+}
+function createCompressionMiddleware(config) {
+  const contextWindow = config.resolvedContextWindow;
+  const sessionStore = createSessionStore(config.maxSessions ?? 500);
+  const worker = createCompressionWorker({
+    threshold: config.threshold,
+    targetRatio: config.targetRatio,
+    compressionModel: config.compressionModel,
+    contextWindow,
+    maxConcurrent: 2,
+    timeoutMs: 60000
+  });
+  function beforeForward(parsed, adapter) {
+    const messages = parsed.messages;
+    if (messages.length <= 1) {
+      return { messages, wasCompressed: false };
+    }
+    const sessionId = generateSessionId(messages);
+    const session = sessionStore.getOrCreate(sessionId, messages);
+    const compressed = worker.applyCompression(session);
+    if (compressed) {
+      sessionStore.update(sessionId, {
+        messages: compressed,
+        compressionState: "idle",
+        compressedMessages: undefined,
+        compressedSummary: undefined,
+        snapshotIndex: undefined
       });
-      await new Promise((resolve) => {
-        httpServer.listen(config.port, config.host, resolve);
+      const originalTokens = estimateMessagesTokens(messagesToTokenMessages(messages));
+      const compressedTokens = estimateMessagesTokens(messagesToTokenMessages(compressed));
+      if (config.statsTracker) {
+        config.statsTracker.recordCompression(originalTokens, compressedTokens);
+      }
+      console.log(`[compression] Applied compression: ${originalTokens} → ${compressedTokens} tokens (${((1 - compressedTokens / originalTokens) * 100).toFixed(0)}% reduction)`);
+      return { messages: compressed, wasCompressed: true };
+    }
+    const tokenCount = estimateMessagesTokens(messagesToTokenMessages(messages));
+    const hardCeilingTokens = HARD_CEILING_RATIO * contextWindow;
+    if (tokenCount >= hardCeilingTokens) {
+      const targetTokens = config.targetRatio * contextWindow;
+      const truncated = truncateToFit(messages, targetTokens);
+      console.log(`[compression] Hard ceiling hit (${tokenCount} tokens >= ${Math.round(hardCeilingTokens)}), truncating to ${Math.round(targetTokens)} tokens`);
+      return { messages: truncated, wasCompressed: true };
+    }
+    return { messages, wasCompressed: false };
+  }
+  function afterResponse(parsed, adapter, baseUrl, auth) {
+    const messages = parsed.messages;
+    if (messages.length <= 1)
+      return;
+    const sessionId = generateSessionId(messages);
+    const session = sessionStore.getOrCreate(sessionId, messages);
+    const tokenCount = estimateMessagesTokens(messagesToTokenMessages(messages));
+    sessionStore.update(sessionId, {
+      messages: [...messages],
+      tokenCount
+    });
+    const updatedSession = sessionStore.get(sessionId);
+    if (!updatedSession)
+      return;
+    if (worker.shouldCompress(updatedSession)) {
+      const makeApiCall = createMakeApiCall(adapter, config.compressionModel, baseUrl, auth);
+      worker.triggerCompression(updatedSession, sessionStore, makeApiCall);
+      console.log(`[compression] Triggered background compression for session ${sessionId} (${tokenCount} tokens)`);
+    }
+  }
+  function getSummaryForSession(messages) {
+    if (messages.length <= 1)
+      return;
+    const sessionId = generateSessionId(messages);
+    const session = sessionStore.get(sessionId);
+    if (!session)
+      return;
+    if (session.compressionState === "ready" && session.compressedSummary) {
+      const recentMessages = session.messages.slice(-3);
+      const summary = session.compressedSummary;
+      sessionStore.update(sessionId, {
+        compressionState: "idle",
+        compressedMessages: undefined,
+        compressedSummary: undefined
       });
-      server = httpServer;
-    },
-    stop() {
-      if (!server)
-        return;
-      server.close();
-      server = null;
+      return { summary, recentMessages };
+    }
+    return;
+  }
+  return {
+    beforeForward,
+    afterResponse,
+    getSessionStore: () => sessionStore,
+    getWorker: () => worker,
+    getSummaryForSession
+  };
+}
+
+// src/proxy/pipeline.ts
+registerAdapter(new AnthropicAdapter);
+async function collectCodexStream(sourceAdapter, response) {
+  const reader = response.body.getReader();
+  const decoder2 = new TextDecoder;
+  let buffer = "";
+  let id = "";
+  let model = "";
+  const textParts = [];
+  let usage;
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    buffer += decoder2.decode(value, { stream: true });
+    let idx;
+    while ((idx = buffer.indexOf(`
+
+`)) !== -1) {
+      const frame = buffer.slice(0, idx);
+      buffer = buffer.slice(idx + 2);
+      if (!frame.trim() || !sourceAdapter.parseStreamChunk)
+        continue;
+      for (const event of sourceAdapter.parseStreamChunk(frame)) {
+        if (event.type === "message_start") {
+          id = event.id ?? "";
+          model = event.model ?? "";
+        } else if (event.type === "content_delta") {
+          textParts.push(event.text ?? "");
+        } else if (event.type === "message_stop" && event.usage) {
+          usage = event.usage;
+        }
+      }
+    }
+  }
+  return {
+    id,
+    model,
+    content: textParts.join(""),
+    role: "assistant",
+    stopReason: "completed",
+    usage
+  };
+}
+function findProviderForModel(modelString, openclawConfig) {
+  const providers = openclawConfig.models?.providers;
+  if (!providers)
+    return;
+  const [providerName, modelId] = modelString.split("/", 2);
+  if (!providerName || !modelId)
+    return;
+  const providerConfig = providers[providerName];
+  if (!providerConfig)
+    return;
+  return {
+    providerName,
+    baseUrl: providerConfig.baseUrl ?? "",
+    apiType: providerConfig.api ?? ""
+  };
+}
+function jsonErrorResponse(message, status) {
+  return new Response(JSON.stringify({ error: message }), {
+    status,
+    headers: { "content-type": "application/json" }
+  });
+}
+async function handleApiRequest(req, body, apiType, config, openclawConfig, authProfiles, compressionMiddleware) {
+  const adapter = getAdapter(apiType);
+  if (!adapter) {
+    return jsonErrorResponse(`Unknown API type: ${apiType}`, 500);
+  }
+  const parsed = adapter.parseRequest(body);
+  const compactionHeaders = {};
+  req.headers.forEach((value, key) => {
+    compactionHeaders[key] = value;
+  });
+  const compaction = detectCompaction(compactionHeaders, parsed.messages);
+  if (compaction.isCompaction && compressionMiddleware) {
+    const summaryData = compressionMiddleware.getSummaryForSession(parsed.messages);
+    if (summaryData) {
+      const syntheticParsed = buildSyntheticSummaryResponse(summaryData.summary, summaryData.recentMessages, parsed.model);
+      console.log(`[clawmux] Compaction detected (${compaction.detectedBy}) → returning synthetic response`);
+      return buildSyntheticHttpResponse(syntheticParsed, adapter);
+    }
+    console.log(`[clawmux] Compaction detected but no summary available, forwarding to upstream`);
+  }
+  let effectiveParsed = parsed;
+  if (compressionMiddleware) {
+    const { messages: compressedMessages, wasCompressed } = compressionMiddleware.beforeForward(parsed, adapter);
+    if (wasCompressed) {
+      const modifiedRawBody = adapter.modifyMessages(parsed.rawBody, compressedMessages);
+      effectiveParsed = {
+        ...parsed,
+        messages: compressedMessages,
+        rawBody: modifiedRawBody
+      };
     }
+  }
+  const messages = effectiveParsed.messages;
+  const classification = await classifyLocal(messages);
+  const decision = {
+    tier: classification.tier,
+    model: config.routing.models[classification.tier],
+    confidence: classification.confidence,
+    overrideReason: classification.reasoning
+  };
+  const lookup = findProviderForModel(decision.model, openclawConfig);
+  let providerName;
+  let baseUrl;
+  let targetApiType;
+  if (lookup) {
+    providerName = lookup.providerName;
+    baseUrl = lookup.baseUrl;
+    targetApiType = lookup.apiType;
+  } else {
+    const reqUrl = new URL(req.url);
+    baseUrl = `${reqUrl.protocol}//${reqUrl.host}`;
+    providerName = apiType.split("-")[0];
+    targetApiType = apiType;
+  }
+  const auth = resolveApiKey(providerName, openclawConfig, authProfiles);
+  if (!auth) {
+    return jsonErrorResponse(`No auth credentials found for provider: ${providerName}`, 502);
+  }
+  const authInfo = {
+    apiKey: auth.apiKey,
+    headerName: auth.headerName,
+    headerValue: auth.headerValue,
+    awsAccessKeyId: auth.awsAccessKeyId,
+    awsSecretKey: auth.awsSecretKey,
+    awsSessionToken: auth.awsSessionToken,
+    awsRegion: auth.awsRegion
   };
+  const actualModelId = decision.model.split("/").slice(1).join("/");
+  const isCrossProvider = targetApiType !== "" && targetApiType !== apiType;
+  const targetAdapter = isCrossProvider ? getAdapter(targetApiType) : undefined;
+  const requestAdapter = targetAdapter ?? adapter;
+  const upstream = requestAdapter.buildUpstreamRequest(effectiveParsed, actualModelId, baseUrl, authInfo);
+  let upstreamResponse;
+  try {
+    upstreamResponse = await fetch(upstream.url, {
+      method: upstream.method,
+      headers: upstream.headers,
+      body: upstream.body
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return jsonErrorResponse(`Upstream request failed: ${message}`, 502);
+  }
+  console.log(`[clawmux] [llm] ${decision.tier} → ${decision.model} | conf=${classification.confidence.toFixed(2)}${classification.reasoning ? ` | ${classification.reasoning}` : ""}`);
+  if (compressionMiddleware && upstreamResponse.ok) {
+    compressionMiddleware.afterResponse(parsed, adapter, baseUrl, authInfo);
+  }
+  const isCodexUpstream = targetApiType === "openai-codex-responses";
+  if (isCodexUpstream && upstreamResponse.ok && upstreamResponse.body) {
+    if (effectiveParsed.stream) {
+      return translateResponse(requestAdapter, adapter, upstreamResponse, true);
+    }
+    const collected = await collectCodexStream(requestAdapter, upstreamResponse);
+    const translated = adapter.buildResponse(collected);
+    return new Response(JSON.stringify(translated), {
+      status: 200,
+      headers: { "content-type": "application/json" }
+    });
+  }
+  if (targetAdapter && upstreamResponse.ok) {
+    return translateResponse(targetAdapter, adapter, upstreamResponse, effectiveParsed.stream);
+  }
+  return new Response(upstreamResponse.body, {
+    status: upstreamResponse.status,
+    statusText: upstreamResponse.statusText,
+    headers: upstreamResponse.headers
+  });
+}
+function createResolvedCompressionMiddleware(config, openclawConfig, piAiCatalog, statsTracker) {
+  const contextWindows = config.routing.contextWindows ?? {};
+  const resolvedContextWindow = resolveCompressionContextWindow(config.routing.models, contextWindows, openclawConfig, piAiCatalog);
+  const tiers = ["LIGHT", "MEDIUM", "HEAVY"];
+  for (const tier of tiers) {
+    const modelKey = config.routing.models[tier];
+    if (modelKey) {
+      const window = resolveContextWindow(modelKey, contextWindows, openclawConfig, piAiCatalog);
+      console.log(`[clawmux] ${tier} → ${modelKey} contextWindow=${window}`);
+    }
+  }
+  console.log(`[clawmux] Compression contextWindow=${resolvedContextWindow} (minimum across tiers)`);
+  return createCompressionMiddleware({
+    threshold: config.compression.threshold,
+    targetRatio: config.compression.targetRatio ?? 0.6,
+    compressionModel: config.compression.model,
+    resolvedContextWindow,
+    statsTracker
+  });
+}
+var ROUTE_MAPPINGS = [
+  { apiType: "anthropic-messages", key: "/v1/messages" },
+  { apiType: "openai-completions", key: "/v1/chat/completions" },
+  { apiType: "openai-responses", key: "/v1/responses" },
+  { apiType: "google-generative-ai", key: "/v1beta/models/*" },
+  { apiType: "ollama", key: "/api/chat" },
+  { apiType: "bedrock-converse-stream", key: "/model/*/converse-stream" }
+];
+function setupPipelineRoutes(config, openclawConfig, authProfiles, compressionMiddleware) {
+  for (const mapping of ROUTE_MAPPINGS) {
+    setRouteHandler(mapping.key, (req, body) => handleApiRequest(req, body, mapping.apiType, config, openclawConfig, authProfiles, compressionMiddleware));
+  }
+}
+
+// src/index.ts
+var import_node_path4 = require("node:path");
+async function bootstrap(portOverride) {
+  const configPath = process.env.CLAWMUX_CONFIG ? import_node_path4.resolve(process.env.CLAWMUX_CONFIG) : import_node_path4.resolve(process.cwd(), "clawmux.json");
+  const result = await loadConfig(configPath);
+  if (!result.valid) {
+    console.error("[clawmux] Config errors:");
+    for (const err of result.errors)
+      console.error(`  - ${err}`);
+    process.exit(1);
+  }
+  const config = result.config;
+  const openclawConfig = await readOpenClawConfig();
+  const authProfiles = await readAuthProfiles();
+  const piAiCatalog = await loadPiAiCatalog();
+  const compressionMiddleware = createResolvedCompressionMiddleware(config, openclawConfig, piAiCatalog);
+  setupPipelineRoutes(config, openclawConfig, authProfiles, compressionMiddleware);
+  const port = portOverride ?? parseInt(process.env.CLAWMUX_PORT ?? "3456", 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}`);
+  const watcher = createConfigWatcher(configPath, (newConfig) => {
+    console.log("[clawmux] Config reloaded, updating routes...");
+    clearCustomHandlers();
+    const newCompression = createResolvedCompressionMiddleware(newConfig, openclawConfig, piAiCatalog);
+    setupPipelineRoutes(newConfig, openclawConfig, authProfiles, newCompression);
+  });
+  watcher.start();
+}
+if (typeof Bun !== "undefined" && Bun.main === "/home/runner/work/ClawMux/ClawMux/src/index.ts") {
+  bootstrap().catch((err) => {
+    console.error(`[clawmux] Fatal: ${err.message}`);
+    process.exit(1);
+  });
 }
 
 // src/utils/logger.ts
-var import_node_fs = require("node:fs");
-var import_node_path = require("node:path");
-var LOG_DIR = import_node_path.join(process.env.HOME ?? "/root", ".openclaw", "clawmux");
+var import_node_fs2 = require("node:fs");
+var import_node_path5 = require("node:path");
+var LOG_DIR = import_node_path5.join(process.env.HOME ?? "/root", ".openclaw", "clawmux");
 var MAX_DAYS = 7;
 var fileStream = null;
 var currentDate = "";
@@ -259,7 +3880,7 @@ function todayString() {
   return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
 }
 function logPath(date) {
-  return import_node_path.join(LOG_DIR, `${date}.log`);
+  return import_node_path5.join(LOG_DIR, `${date}.log`);
 }
 function rotateIfNeeded() {
   const today = todayString();
@@ -269,15 +3890,15 @@ function rotateIfNeeded() {
     fileStream.end();
   }
   currentDate = today;
-  fileStream = import_node_fs.createWriteStream(logPath(today), { flags: "a" });
+  fileStream = import_node_fs2.createWriteStream(logPath(today), { flags: "a" });
   purgeOldLogs();
 }
 function purgeOldLogs() {
   try {
-    const files = import_node_fs.readdirSync(LOG_DIR).filter((f) => f.endsWith(".log")).sort();
+    const files = import_node_fs2.readdirSync(LOG_DIR).filter((f) => f.endsWith(".log")).sort();
     while (files.length > MAX_DAYS) {
       const oldest = files.shift();
-      import_node_fs.unlinkSync(import_node_path.join(LOG_DIR, oldest));
+      import_node_fs2.unlinkSync(import_node_path5.join(LOG_DIR, oldest));
     }
   } catch (_) {}
 }
@@ -294,7 +3915,7 @@ function writeLine(level, args) {
   }
 }
 function initLogger() {
-  import_node_fs.mkdirSync(LOG_DIR, { recursive: true });
+  import_node_fs2.mkdirSync(LOG_DIR, { recursive: true });
   rotateIfNeeded();
   const origLog = console.log.bind(console);
   const origError = console.error.bind(console);
@@ -317,7 +3938,7 @@ function getLogDir() {
 }
 
 // src/cli.ts
-var VERSION2 = process.env.npm_package_version ?? "0.3.0";
+var VERSION2 = process.env.npm_package_version ?? "0.3.2";
 var SERVICE_NAME = "clawmux";
 var HELP = `Usage: clawmux <command>
 
@@ -339,10 +3960,20 @@ Environment:
   CLAWMUX_PORT            Server port override
   OPENCLAW_CONFIG_PATH    Path to openclaw.json`;
 var PROVIDER_KEY = "clawmux";
-var PROVIDER_API = "anthropic-messages";
+var PROVIDER_API_FALLBACK = "openai-responses";
+function resolveProviderApi(mediumModel, openclawProviders) {
+  const providerName = mediumModel.split("/")[0];
+  if (!providerName)
+    return PROVIDER_API_FALLBACK;
+  const providerConfig = openclawProviders[providerName];
+  const api = providerConfig?.["api"];
+  if (typeof api === "string" && api.length > 0)
+    return api;
+  return PROVIDER_API_FALLBACK;
+}
 async function fileExistsLocal(path) {
   try {
-    await import_promises.access(path);
+    await import_promises6.access(path);
     return true;
   } catch {
     return false;
@@ -367,13 +3998,13 @@ function resolveClawmuxBin() {
     return detectPackageManager() === "bunx" ? "bunx clawmux" : "npx clawmux";
   }
 }
-function getHomeDir() {
+function getHomeDir2() {
   return process.env.HOME ?? "/root";
 }
-var SYSTEMD_DIR = import_node_path2.join(getHomeDir(), ".config", "systemd", "user");
-var SYSTEMD_PATH = import_node_path2.join(SYSTEMD_DIR, `${SERVICE_NAME}.service`);
-var LAUNCHD_DIR = import_node_path2.join(getHomeDir(), "Library", "LaunchAgents");
-var LAUNCHD_PATH = import_node_path2.join(LAUNCHD_DIR, `com.${SERVICE_NAME}.plist`);
+var SYSTEMD_DIR = import_node_path6.join(getHomeDir2(), ".config", "systemd", "user");
+var SYSTEMD_PATH = import_node_path6.join(SYSTEMD_DIR, `${SERVICE_NAME}.service`);
+var LAUNCHD_DIR = import_node_path6.join(getHomeDir2(), "Library", "LaunchAgents");
+var LAUNCHD_PATH = import_node_path6.join(LAUNCHD_DIR, `com.${SERVICE_NAME}.plist`);
 function buildSystemdUnit(bin, port, workDir) {
   return `[Unit]
 Description=ClawMux - Smart model routing proxy
@@ -392,7 +4023,7 @@ WantedBy=default.target
 `;
 }
 function buildLaunchdPlist(bin, port, workDir) {
-  const logDir = import_node_path2.join(getHomeDir(), ".openclaw", "clawmux");
+  const logDir = import_node_path6.join(getHomeDir2(), ".openclaw", "clawmux");
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -431,8 +4062,8 @@ async function installService(port, workDir) {
   const bin = resolveClawmuxBin();
   const os = import_node_os.platform();
   if (os === "linux") {
-    await import_promises.mkdir(SYSTEMD_DIR, { recursive: true });
-    await import_promises.writeFile(SYSTEMD_PATH, buildSystemdUnit(bin, port, workDir));
+    await import_promises6.mkdir(SYSTEMD_DIR, { recursive: true });
+    await import_promises6.writeFile(SYSTEMD_PATH, buildSystemdUnit(bin, port, workDir));
     try {
       import_node_child_process.execSync("systemctl --user daemon-reload", { stdio: "pipe" });
       import_node_child_process.execSync(`systemctl --user enable ${SERVICE_NAME}`, { stdio: "pipe" });
@@ -446,10 +4077,10 @@ async function installService(port, workDir) {
       console.warn("       You can start manually: clawmux start");
     }
   } else if (os === "darwin") {
-    await import_promises.mkdir(LAUNCHD_DIR, { recursive: true });
-    const logDir = import_node_path2.join(getHomeDir(), ".openclaw", "clawmux");
-    await import_promises.mkdir(logDir, { recursive: true });
-    await import_promises.writeFile(LAUNCHD_PATH, buildLaunchdPlist(bin, port, workDir));
+    await import_promises6.mkdir(LAUNCHD_DIR, { recursive: true });
+    const logDir = import_node_path6.join(getHomeDir2(), ".openclaw", "clawmux");
+    await import_promises6.mkdir(logDir, { recursive: true });
+    await import_promises6.writeFile(LAUNCHD_PATH, buildLaunchdPlist(bin, port, workDir));
     try {
       import_node_child_process.execSync(`launchctl load -w ${LAUNCHD_PATH}`, { stdio: "pipe" });
       console.log("[info] launchd service installed and started");
@@ -512,7 +4143,7 @@ async function removeService() {
       import_node_child_process.execSync(`systemctl --user disable ${SERVICE_NAME}`, { stdio: "pipe" });
     } catch (_) {}
     if (await fileExistsLocal(SYSTEMD_PATH)) {
-      await import_promises.unlink(SYSTEMD_PATH);
+      await import_promises6.unlink(SYSTEMD_PATH);
       import_node_child_process.execSync("systemctl --user daemon-reload", { stdio: "pipe" });
       console.log("[info] systemd service removed");
     }
@@ -521,7 +4152,7 @@ async function removeService() {
       import_node_child_process.execSync(`launchctl unload ${LAUNCHD_PATH}`, { stdio: "pipe" });
     } catch (_) {}
     if (await fileExistsLocal(LAUNCHD_PATH)) {
-      await import_promises.unlink(LAUNCHD_PATH);
+      await import_promises6.unlink(LAUNCHD_PATH);
       console.log("[info] launchd plist removed");
     }
   }
@@ -596,8 +4227,8 @@ async function update() {
 async function init() {
   const args = process.argv.slice(2);
   const noService = args.includes("--no-service");
-  const homeDir = getHomeDir();
-  const openclawConfigPath = process.env.OPENCLAW_CONFIG_PATH ?? import_node_path2.join(homeDir, ".openclaw", "openclaw.json");
+  const homeDir = getHomeDir2();
+  const openclawConfigPath = process.env.OPENCLAW_CONFIG_PATH ?? import_node_path6.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");
@@ -605,25 +4236,25 @@ async function init() {
   }
   console.log(`[info] Using OpenClaw config: ${openclawConfigPath}`);
   const backupPath = `${openclawConfigPath}.bak.${Date.now()}`;
-  await import_promises.copyFile(openclawConfigPath, backupPath);
+  await import_promises6.copyFile(openclawConfigPath, backupPath);
   console.log(`[info] Backup created: ${backupPath}`);
-  const clawmuxJsonPath = import_node_path2.join(process.cwd(), "clawmux.json");
-  const examplePath = import_node_path2.join(process.cwd(), "clawmux.example.json");
+  const clawmuxJsonPath = import_node_path6.join(process.cwd(), "clawmux.json");
+  const examplePath = import_node_path6.join(process.cwd(), "clawmux.example.json");
   if (!await fileExistsLocal(clawmuxJsonPath)) {
     if (await fileExistsLocal(examplePath)) {
-      await import_promises.copyFile(examplePath, clawmuxJsonPath);
+      await import_promises6.copyFile(examplePath, clawmuxJsonPath);
       console.log("[info] Created clawmux.json from clawmux.example.json");
     } else {
       const defaultConfig = {
         compression: { threshold: 0.75, model: "" },
         routing: { models: { LIGHT: "", MEDIUM: "", HEAVY: "" } }
       };
-      await import_promises.writeFile(clawmuxJsonPath, JSON.stringify(defaultConfig, null, 2) + `
+      await import_promises6.writeFile(clawmuxJsonPath, JSON.stringify(defaultConfig, null, 2) + `
 `);
       console.log("[info] Created default clawmux.json (configure models before use)");
     }
   }
-  const raw = await import_promises.readFile(openclawConfigPath, "utf-8");
+  const raw = await import_promises6.readFile(openclawConfigPath, "utf-8");
   const config = JSON.parse(raw);
   if (!config.models)
     config.models = {};
@@ -631,17 +4262,41 @@ async function init() {
   if (!models.providers)
     models.providers = {};
   const providers = models.providers;
+  let providerApi = PROVIDER_API_FALLBACK;
+  try {
+    const clawmuxRaw = await import_promises6.readFile(clawmuxJsonPath, "utf-8");
+    const clawmuxConfig = JSON.parse(clawmuxRaw);
+    const routing = clawmuxConfig["routing"];
+    const routingModels = routing?.["models"];
+    const mediumModel = routingModels?.["MEDIUM"];
+    if (typeof mediumModel === "string" && mediumModel.length > 0) {
+      providerApi = resolveProviderApi(mediumModel, providers);
+      console.log(`[info] MEDIUM model: ${mediumModel} → provider api: ${providerApi}`);
+    } else {
+      console.log(`[info] MEDIUM model not configured yet, using default api: ${providerApi}`);
+    }
+  } catch {
+    console.log(`[info] clawmux.json not readable, using default api: ${providerApi}`);
+  }
   if (providers[PROVIDER_KEY]) {
-    console.log(`  skip  ${PROVIDER_KEY} (already exists)`);
+    const existing = providers[PROVIDER_KEY];
+    if (existing["api"] !== providerApi) {
+      existing["api"] = providerApi;
+      await import_promises6.writeFile(openclawConfigPath, JSON.stringify(config, null, 2) + `
+`);
+      console.log(`  updated ${PROVIDER_KEY} provider api → ${providerApi}`);
+    } else {
+      console.log(`  skip  ${PROVIDER_KEY} (already exists, api=${providerApi})`);
+    }
   } else {
     providers[PROVIDER_KEY] = {
       baseUrl: "http://localhost:3456",
-      api: PROVIDER_API,
+      api: providerApi,
       models: [{ id: "auto", name: "ClawMux Auto Router" }]
     };
-    await import_promises.writeFile(openclawConfigPath, JSON.stringify(config, null, 2) + `
+    await import_promises6.writeFile(openclawConfigPath, JSON.stringify(config, null, 2) + `
 `);
-    console.log(`  added ${PROVIDER_KEY} provider to openclaw.json`);
+    console.log(`  added ${PROVIDER_KEY} provider to openclaw.json (api=${providerApi})`);
   }
   const port = process.env.CLAWMUX_PORT ?? "3456";
   if (!noService) {
@@ -662,7 +4317,7 @@ Next steps:`);
   console.log("  3. Select a provider: openclaw provider clawmux-openai");
   console.log("  4. Start chatting: openclaw chat");
 }
-function start() {
+async 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");
@@ -670,20 +4325,18 @@ function start() {
     port = parseInt(args[portIdx + 1], 10);
   }
   initLogger();
-  const server = createServer({ port, host: "127.0.0.1" });
-  server.start();
-  console.log(`[clawmux] Proxy server running on http://127.0.0.1:${port}`);
+  await bootstrap(port);
   console.log(`[clawmux] Logs: ${getLogDir()}`);
   checkForUpdate();
 }
 async function uninstall() {
   await removeService();
-  const homeDir = getHomeDir();
-  const openclawConfigPath = process.env.OPENCLAW_CONFIG_PATH ?? import_node_path2.join(homeDir, ".openclaw", "openclaw.json");
+  const homeDir = getHomeDir2();
+  const openclawConfigPath = process.env.OPENCLAW_CONFIG_PATH ?? import_node_path6.join(homeDir, ".openclaw", "openclaw.json");
   if (await fileExistsLocal(openclawConfigPath)) {
     const backupPath = `${openclawConfigPath}.bak.${Date.now()}`;
-    await import_promises.copyFile(openclawConfigPath, backupPath);
-    const raw = await import_promises.readFile(openclawConfigPath, "utf-8");
+    await import_promises6.copyFile(openclawConfigPath, backupPath);
+    const raw = await import_promises6.readFile(openclawConfigPath, "utf-8");
     const config = JSON.parse(raw);
     const models = config.models ?? {};
     const providers = models.providers ?? {};
@@ -695,7 +4348,7 @@ async function uninstall() {
       }
     }
     if (removed > 0) {
-      await import_promises.writeFile(openclawConfigPath, JSON.stringify(config, null, 2) + `
+      await import_promises6.writeFile(openclawConfigPath, JSON.stringify(config, null, 2) + `
 `);
       console.log(`[info] Removed ${removed} ClawMux provider(s) from openclaw.json`);
     }
@@ -711,7 +4364,10 @@ switch (command) {
     });
     break;
   case "start":
-    start();
+    start().catch((err) => {
+      console.error(`[error] ${err.message}`);
+      process.exit(1);
+    });
     break;
   case "stop":
     stopService();