headroom-openclaw 0.1.0 → 0.36.1

package/dist/index.js

@@ -3,14 +3,11 @@ import { compress } from "headroom-ai";
 
 // src/proxy-manager.ts
 import { spawn } from "child_process";
-import { createWriteStream } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-var DEFAULT_PORT = 8787;
-var HEALTH_CHECK_INTERVAL_MS = 3e4;
-var STARTUP_TIMEOUT_MS = 15e3;
-var RESTART_DELAY_MS = 2e3;
-var MAX_RESTART_ATTEMPTS = 3;
+import { spawnSync } from "child_process";
+import { existsSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import os from "os";
 var defaultLogger = {
   info: (m) => console.log(`[headroom] ${m}`),
   warn: (m) => console.warn(`[headroom] ${m}`),
@@ -18,249 +15,412 @@ var defaultLogger = {
   debug: () => {
   }
 };
+var HEADROOM_MODULE_DISCOVERY_SNIPPET = "import importlib.util, sys; sys.exit(0 if importlib.util.find_spec('headroom') else 1)";
 var ProxyManager = class {
   config;
   logger;
-  process = null;
   proxyUrl = null;
-  weStartedIt = false;
-  restartCount = 0;
-  healthInterval = null;
-  disposed = false;
   constructor(config = {}, logger) {
     this.config = config;
     this.logger = logger ?? defaultLogger;
   }
   /**
-   * Ensure a proxy is available. Returns the URL.
-   *
-   * 1. If proxyUrl is configured, use it
-   * 2. Check if proxy is already running on default port
-   * 3. If autoStart, spawn one
+   * Ensure a proxy is available. Returns the normalized URL origin.
    */
   async start() {
-    if (this.config.proxyUrl) {
-      const url = this.config.proxyUrl.replace(/\/+$/, "");
-      if (await this.healthCheck(url)) {
+    const port = this.getProxyPort();
+    const rawExplicitUrl = typeof this.config.proxyUrl === "string" && this.config.proxyUrl.trim().length > 0 ? normalizeAndValidateProxyUrl(this.config.proxyUrl) : null;
+    const explicitUrl = rawExplicitUrl ? isLocalProxyUrl(rawExplicitUrl) ? withDefaultPort(rawExplicitUrl, port) : rawExplicitUrl : null;
+    const defaultCandidates = this.getDefaultProxyCandidates(port);
+    const candidateUrls = explicitUrl ? [explicitUrl] : [...defaultCandidates];
+    const probeByUrl = /* @__PURE__ */ new Map();
+    for (const url of candidateUrls) {
+      const probe = await probeHeadroomProxy(url);
+      probeByUrl.set(url, probe);
+      if (probe.reachable && probe.isHeadroom) {
         this.proxyUrl = url;
-        this.logger.info(`Connected to proxy at ${url}`);
+        this.logger.info(`Headroom proxy already running at ${url}`);
         return url;
       }
-      throw new Error(`Headroom proxy not reachable at ${url}`);
-    }
-    const defaultUrl = `http://127.0.0.1:${DEFAULT_PORT}`;
-    if (await this.healthCheck(defaultUrl)) {
-      this.proxyUrl = defaultUrl;
-      this.logger.info(`Found running proxy at ${defaultUrl}`);
-      this.startHealthMonitor();
-      return defaultUrl;
     }
-    if (this.config.autoStart !== false) {
-      return this.spawnProxy();
+    if (explicitUrl) {
+      const explicitProbe = probeByUrl.get(explicitUrl);
+      if (explicitProbe?.reachable && !explicitProbe.isHeadroom) {
+        throw new Error(
+          `Service reachable at ${explicitUrl}, but it does not appear to be a Headroom proxy (${explicitProbe.reason ?? "unknown service"}).`
+        );
+      }
     }
-    throw new Error(
-      "Headroom proxy not running. Start with: headroom proxy --port 8787\nOr install: pip install 'headroom-ai[proxy]'"
-    );
-  }
-  /**
-   * Spawn the headroom proxy as a child process.
-   */
-  async spawnProxy() {
-    const pythonPath = await this.findPython();
-    if (!pythonPath) {
+    if (explicitUrl && !isLocalProxyUrl(explicitUrl)) {
       throw new Error(
-        "Python not found. Install Python 3.10+ and run: pip install 'headroom-ai[proxy]'"
+        `Remote Headroom proxy not reachable at ${explicitUrl}. Ensure the proxy is running at that address.`
       );
     }
-    const installed = await this.checkHeadroomInstalled(pythonPath);
-    if (!installed) {
+    if (this.config.autoStart === true) {
+      const startupUrl = explicitUrl ?? defaultCandidates[0];
+      const startupProbe = probeByUrl.get(startupUrl);
+      if (startupProbe?.reachable && !startupProbe.isHeadroom) {
+        throw new Error(
+          `Cannot auto-start Headroom at ${startupUrl}: port is in use by a non-Headroom service (${startupProbe.reason ?? "unknown service"}).`
+        );
+      }
+      this.logger.info(
+        `No Headroom proxy detected${explicitUrl ? ` at ${startupUrl}` : " on default local endpoints"}; attempting to auto-start...`
+      );
+      await this.startHeadroomProxy(startupUrl, port);
+      const startedProbe = await waitForHeadroomProxy(
+        startupUrl,
+        this.config.startupTimeoutMs ?? 2e4
+      );
+      if (startedProbe.reachable && startedProbe.isHeadroom) {
+        this.proxyUrl = startupUrl;
+        this.logger.info(`Headroom proxy started and reachable at ${startupUrl}`);
+        return startupUrl;
+      }
       throw new Error(
-        "headroom-ai Python package not found.\nInstall with: pip install 'headroom-ai[proxy]'"
+        `Attempted to start Headroom proxy, but it was not reachable at ${startupUrl} (${startedProbe.reason ?? "unknown"}).`
       );
     }
-    const port = this.config.proxyPort ?? 0;
-    const actualPort = port === 0 ? await this.findFreePort() : port;
-    const url = `http://127.0.0.1:${actualPort}`;
-    this.logger.info(`Starting proxy on port ${actualPort}...`);
-    const logDir = join(homedir(), ".headroom", "logs");
-    const logPath = join(logDir, "openclaw-proxy.log");
-    let logStream = null;
-    try {
-      const { mkdirSync } = await import("fs");
-      mkdirSync(logDir, { recursive: true });
-      logStream = createWriteStream(logPath, { flags: "a" });
-    } catch {
-    }
-    const proc = spawn(
-      pythonPath,
-      ["-m", "headroom.cli", "proxy", "--port", String(actualPort)],
-      {
-        env: { ...process.env, PYTHONIOENCODING: "utf-8" },
-        stdio: ["ignore", logStream ? "pipe" : "ignore", logStream ? "pipe" : "ignore"],
-        detached: false
-      }
-    );
-    if (logStream) {
-      proc.stdout?.pipe(logStream);
-      proc.stderr?.pipe(logStream);
-    }
-    proc.on("exit", (code) => {
-      if (!this.disposed && this.weStartedIt) {
-        this.logger.warn(`Proxy exited with code ${code}`);
-        this.handleCrash();
-      }
-    });
-    this.process = proc;
-    this.weStartedIt = true;
-    const healthy = await this.waitForHealthy(url, STARTUP_TIMEOUT_MS);
-    if (!healthy) {
-      proc.kill();
-      this.process = null;
+    if (explicitUrl) {
       throw new Error(
-        `Proxy failed to start within ${STARTUP_TIMEOUT_MS / 1e3}s. Check ${logPath}`
+        `Headroom proxy not reachable at ${explicitUrl}. Ensure the proxy is running first.`
       );
     }
-    this.proxyUrl = url;
-    this.logger.info(`Proxy started on port ${actualPort} (PID: ${proc.pid})`);
-    this.startHealthMonitor();
-    return url;
+    throw new Error(
+      `Headroom proxy not detected on default endpoints (${defaultCandidates.join(", ")}). Set proxyUrl explicitly or enable autoStart.`
+    );
+  }
+  getProxyPort() {
+    const rawPort = this.config.proxyPort;
+    if (!Number.isInteger(rawPort) || rawPort === void 0) return 8787;
+    if (rawPort < 1 || rawPort > 65535) {
+      throw new Error("proxyPort must be an integer between 1 and 65535");
+    }
+    return rawPort;
+  }
+  getDefaultProxyCandidates(port) {
+    return [`http://127.0.0.1:${port}`, `http://localhost:${port}`];
   }
   /**
-   * Stop the proxy if we started it.
+   * Stop manager state. Spawned proxy processes are detached and externally managed.
    */
   async stop() {
-    this.disposed = true;
-    if (this.healthInterval) {
-      clearInterval(this.healthInterval);
-      this.healthInterval = null;
-    }
-    if (this.process && this.weStartedIt) {
-      this.logger.info("Stopping proxy...");
-      this.process.kill("SIGTERM");
-      await new Promise((resolve) => {
-        const timeout = setTimeout(() => {
-          this.process?.kill("SIGKILL");
-          resolve();
-        }, 3e3);
-        this.process?.on("exit", () => {
-          clearTimeout(timeout);
-          resolve();
-        });
-      });
-      this.process = null;
-    }
+    this.proxyUrl = null;
   }
   getUrl() {
     return this.proxyUrl;
   }
   // --- Internal ---
-  async healthCheck(url) {
-    try {
-      const resp = await fetch(`${url}/health`, {
-        signal: AbortSignal.timeout(3e3)
-      });
-      return resp.ok;
-    } catch {
-      return false;
+  async startHeadroomProxy(proxyUrl, defaultPort) {
+    const parsed = new URL(proxyUrl);
+    const host = parsed.hostname;
+    const port = parsed.port || String(defaultPort);
+    const specs = this.buildLaunchSpecs(host, port);
+    const errors = [];
+    for (const spec of specs) {
+      if (!this.canExecute(spec.checkCommand, spec.checkArgs, spec.checkUseShell ?? spec.useShell)) {
+        this.logger.debug(`Launcher unavailable: ${spec.label}`);
+        continue;
+      }
+      try {
+        const child = spawn(spec.command, spec.args, {
+          detached: true,
+          shell: spec.useShell === true,
+          stdio: "ignore"
+        });
+        child.unref();
+        this.logger.info(`Auto-start launcher selected: ${spec.label}`);
+        return;
+      } catch (error) {
+        errors.push(`${spec.label}: ${String(error)}`);
+      }
     }
+    throw new Error(
+      "No usable Headroom launcher found. Tried PATH, local npm, global npm, and Python. Install headroom-ai (npm or pip) and ensure one launcher is available.\n" + (errors.length > 0 ? `Launch errors: ${errors.join("; ")}` : "")
+    );
   }
-  async waitForHealthy(url, timeoutMs) {
-    const start = Date.now();
-    while (Date.now() - start < timeoutMs) {
-      if (await this.healthCheck(url)) return true;
-      await new Promise((r) => setTimeout(r, 500));
+  buildLaunchSpecs(host, port) {
+    const commonArgs = ["proxy", "--host", host, "--port", port];
+    const retryMaxAttempts = this.config.retryMaxAttempts;
+    if (Number.isInteger(retryMaxAttempts)) {
+      commonArgs.push("--retry-max-attempts", String(retryMaxAttempts));
     }
-    return false;
-  }
-  startHealthMonitor() {
-    if (this.healthInterval) return;
-    this.healthInterval = setInterval(async () => {
-      if (this.proxyUrl && !await this.healthCheck(this.proxyUrl)) {
-        this.logger.warn("Proxy health check failed");
-        if (this.weStartedIt) this.handleCrash();
+    const connectTimeoutSeconds = this.config.connectTimeoutSeconds;
+    if (Number.isInteger(connectTimeoutSeconds)) {
+      commonArgs.push("--connect-timeout-seconds", String(connectTimeoutSeconds));
+    }
+    const specs = [];
+    const configuredPython = this.getConfiguredPythonCommand();
+    if (configuredPython) {
+      specs.push({
+        label: `Configured Python: ${configuredPython} -m headroom.cli`,
+        command: configuredPython,
+        args: ["-m", "headroom.cli", ...commonArgs],
+        checkCommand: configuredPython,
+        checkArgs: ["-c", HEADROOM_MODULE_DISCOVERY_SNIPPET]
+      });
+    }
+    if (process.platform === "win32") {
+      const pyenvHeadroom = this.getPyenvResolvedHeadroom();
+      if (pyenvHeadroom) {
+        specs.push({
+          label: `pyenv: ${pyenvHeadroom}`,
+          command: pyenvHeadroom,
+          args: commonArgs,
+          checkCommand: pyenvHeadroom,
+          checkArgs: ["--version"],
+          useShell: false
+        });
+      }
+    }
+    specs.push({
+      label: "PATH: headroom",
+      command: "headroom",
+      args: commonArgs,
+      checkCommand: process.platform === "win32" ? "where.exe" : "sh",
+      checkArgs: process.platform === "win32" ? ["headroom"] : ["-c", "command -v headroom >/dev/null 2>&1"],
+      useShell: process.platform === "win32",
+      checkUseShell: false
+    });
+    const uvBin = join(
+      os.homedir(),
+      ".local",
+      "bin",
+      "headroom"
+    );
+    if (existsSync(uvBin)) {
+      specs.push({
+        label: `uv tool: ${uvBin}`,
+        command: uvBin,
+        args: commonArgs,
+        checkCommand: uvBin,
+        checkArgs: ["--version"]
+      });
+    }
+    const moduleDir = dirname(fileURLToPath(import.meta.url));
+    const packageRoot = dirname(moduleDir);
+    const localBinDir = join(packageRoot, "node_modules", ".bin");
+    const localBins = process.platform === "win32" ? [join(localBinDir, "headroom.cmd"), join(localBinDir, "headroom")] : [join(localBinDir, "headroom")];
+    for (const localBin of localBins) {
+      if (!existsSync(localBin)) continue;
+      specs.push({
+        label: `Local npm: ${localBin}`,
+        command: localBin,
+        args: commonArgs,
+        checkCommand: localBin,
+        checkArgs: ["--version"],
+        useShell: process.platform === "win32"
+      });
+    }
+    const npmPrefix = this.getNpmGlobalPrefix();
+    if (npmPrefix) {
+      const globalBins = process.platform === "win32" ? [join(npmPrefix, "headroom.cmd"), join(npmPrefix, "headroom")] : [join(npmPrefix, "bin", "headroom"), join(npmPrefix, "headroom")];
+      for (const globalBin of globalBins) {
+        if (!existsSync(globalBin)) continue;
+        specs.push({
+          label: `Global npm: ${globalBin}`,
+          command: globalBin,
+          args: commonArgs,
+          checkCommand: globalBin,
+          checkArgs: ["--version"],
+          useShell: process.platform === "win32"
+        });
       }
-    }, HEALTH_CHECK_INTERVAL_MS);
-  }
-  async handleCrash() {
-    if (this.disposed) return;
-    if (this.restartCount >= MAX_RESTART_ATTEMPTS) {
-      this.logger.error(`Proxy crashed ${MAX_RESTART_ATTEMPTS} times. Giving up.`);
-      return;
     }
-    this.restartCount++;
-    this.logger.info(`Restarting proxy (attempt ${this.restartCount}/${MAX_RESTART_ATTEMPTS})...`);
-    await new Promise((r) => setTimeout(r, RESTART_DELAY_MS));
+    const pythonCommands = this.getPythonCommands();
+    for (const pyCmd of pythonCommands) {
+      if (configuredPython && pyCmd === configuredPython) continue;
+      specs.push({
+        label: `Python: ${pyCmd} -m headroom.cli`,
+        command: pyCmd,
+        args: ["-m", "headroom.cli", ...commonArgs],
+        checkCommand: pyCmd,
+        checkArgs: ["-c", HEADROOM_MODULE_DISCOVERY_SNIPPET]
+      });
+    }
+    return specs;
+  }
+  getConfiguredPythonCommand() {
+    const configured = typeof this.config.pythonPath === "string" ? this.config.pythonPath.trim() : "";
+    return configured.length > 0 ? configured : null;
+  }
+  getPyenvResolvedHeadroom() {
+    if (process.platform !== "win32") return null;
     try {
-      await this.spawnProxy();
-    } catch (e) {
-      this.logger.error(`Restart failed: ${e}`);
+      const result = spawnSync("pyenv", ["which", "headroom"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 5e3
+      });
+      if (result.error || result.status !== 0) return null;
+      const resolved = (result.stdout ?? "").trim().split(/\r?\n/, 1)[0];
+      if (!resolved || !existsSync(resolved)) return null;
+      return resolved;
+    } catch {
+      return null;
     }
   }
-  async findPython() {
-    if (this.config.pythonPath) return this.config.pythonPath;
-    for (const cmd of ["python3", "python"]) {
-      try {
-        const { execSync } = await import("child_process");
-        const version = execSync(`${cmd} --version 2>&1`, { encoding: "utf-8" }).trim();
-        if (version.includes("Python 3.")) return cmd;
-      } catch {
-        continue;
-      }
+  getPythonCommands() {
+    const commands = [];
+    const configured = this.getConfiguredPythonCommand() ?? "";
+    if (configured.length > 0) {
+      commands.push(configured);
+    }
+    for (const fallback of ["python", "python3", "py"]) {
+      if (!commands.includes(fallback)) commands.push(fallback);
     }
-    return null;
+    return commands;
   }
-  async checkHeadroomInstalled(pythonPath) {
+  canExecute(command, args, useShell = false) {
     try {
-      const { execSync } = await import("child_process");
-      execSync(`${pythonPath} -c "import headroom"`, {
-        encoding: "utf-8",
-        stdio: "pipe"
+      const result = spawnSync(command, args, {
+        shell: useShell,
+        stdio: "ignore",
+        timeout: 5e3
       });
-      return true;
+      if (result.error) return false;
+      return result.status === 0;
     } catch {
       return false;
     }
   }
-  async findFreePort() {
-    const { createServer } = await import("net");
-    return new Promise((resolve, reject) => {
-      const server = createServer();
-      server.listen(0, () => {
-        const addr = server.address();
-        if (addr && typeof addr === "object") {
-          const port = addr.port;
-          server.close(() => resolve(port));
-        } else {
-          reject(new Error("Could not find free port"));
-        }
+  getNpmGlobalPrefix() {
+    try {
+      const result = spawnSync("npm", ["prefix", "-g"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 5e3
       });
-    });
+      if (result.error || result.status !== 0) return null;
+      const prefix = (result.stdout ?? "").trim();
+      return prefix.length > 0 ? prefix : null;
+    } catch {
+      return null;
+    }
   }
 };
+function parseProxyUrl(proxyUrl) {
+  try {
+    return new URL(proxyUrl);
+  } catch {
+    throw new Error(`Invalid proxyUrl: "${proxyUrl}"`);
+  }
+}
+function normalizeAndValidateProxyUrl(proxyUrl) {
+  const parsed = parseProxyUrl(proxyUrl);
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error("proxyUrl must use http:// or https://");
+  }
+  if (parsed.pathname !== "/" || parsed.search || parsed.hash) {
+    throw new Error("proxyUrl must not include a path, query, or hash");
+  }
+  return parsed.origin;
+}
+function isLocalProxyUrl(proxyUrl) {
+  try {
+    const parsed = new URL(proxyUrl);
+    return parsed.hostname === "127.0.0.1" || parsed.hostname === "localhost";
+  } catch {
+    return false;
+  }
+}
+function withDefaultPort(proxyUrl, defaultPort) {
+  const parsed = parseProxyUrl(proxyUrl);
+  if (!parsed.port) {
+    parsed.port = String(defaultPort);
+  }
+  return parsed.origin;
+}
+async function probeHeadroomProxy(proxyUrl) {
+  const origin = normalizeAndValidateProxyUrl(proxyUrl);
+  const probeEndpoint = async (path, options = {}) => {
+    try {
+      const response = await fetch(`${origin}${path}`, {
+        signal: AbortSignal.timeout(3e3)
+      });
+      const body = response.ok && options.readBody ? await response.text().catch(() => void 0) : void 0;
+      return { reachable: true, ok: response.ok, status: response.status, body };
+    } catch {
+      return { reachable: false, ok: false };
+    }
+  };
+  const ready = await probeEndpoint("/readyz");
+  const retrieveStats = await probeEndpoint("/v1/retrieve/stats", { readBody: true });
+  if (retrieveStats.ok && hasHeadroomStatsShape(retrieveStats.body)) {
+    return { reachable: true, isHeadroom: true };
+  }
+  const stats = await probeEndpoint("/stats", { readBody: true });
+  if (stats.ok && hasHeadroomStatsShape(stats.body)) {
+    return { reachable: true, isHeadroom: true };
+  }
+  const health = await probeEndpoint("/health");
+  const anyReachable = ready.reachable || retrieveStats.reachable || stats.reachable || health.reachable;
+  if (!anyReachable) {
+    return { reachable: false, isHeadroom: false, reason: "proxy probe failed" };
+  }
+  const reasons = [
+    ready.reachable ? `readyz HTTP ${ready.status}` : "readyz unavailable",
+    retrieveStats.reachable ? `retrieve stats HTTP ${retrieveStats.status}` : "retrieve stats endpoint unavailable",
+    stats.reachable ? `stats HTTP ${stats.status}` : "stats endpoint unavailable",
+    health.reachable ? `health HTTP ${health.status}` : "health check failed"
+  ];
+  return { reachable: true, isHeadroom: false, reason: reasons.join("; ") };
+}
+function hasHeadroomStatsShape(body) {
+  if (!body) {
+    return false;
+  }
+  try {
+    const parsed = JSON.parse(body);
+    return parsed !== null && typeof parsed === "object" && (Object.hasOwn(parsed, "proxy_inbound") || Object.hasOwn(parsed, "api_requests") || Object.hasOwn(parsed, "provider_tokens") || Object.hasOwn(parsed, "proxy_compression_saved") || Object.hasOwn(parsed, "store") || Object.hasOwn(parsed, "recent_retrievals"));
+  } catch {
+    return false;
+  }
+}
+async function waitForHeadroomProxy(proxyUrl, timeoutMs) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const result = await probeHeadroomProxy(proxyUrl);
+    if (result.reachable && result.isHeadroom) {
+      return result;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 500));
+  }
+  return probeHeadroomProxy(proxyUrl);
+}
 
 // src/convert.ts
 function agentToOpenAI(messages) {
   const result = [];
   for (const msg of messages) {
-    const role = msg.role;
+    const normalized = normalizeAgentMessage(msg);
+    const role = normalized.role;
+    const buildMeta = () => {
+      const meta = { ...normalized };
+      delete meta.role;
+      delete meta.content;
+      return meta;
+    };
     if (role === "system") {
       result.push({
         role: "system",
-        content: typeof msg.content === "string" ? msg.content : extractText(msg.content)
+        content: typeof normalized.content === "string" ? normalized.content : extractText(normalized.content),
+        _headroomMeta: buildMeta()
       });
       continue;
     }
     if (role === "user") {
       result.push({
         role: "user",
-        content: typeof msg.content === "string" ? msg.content : extractText(msg.content)
+        content: typeof normalized.content === "string" ? normalized.content : extractText(normalized.content),
+        _headroomMeta: buildMeta()
       });
       continue;
     }
     if (role === "assistant") {
-      const content = msg.content;
+      const content = normalized.content;
       if (typeof content === "string") {
-        result.push({ role: "assistant", content });
+        result.push({ role: "assistant", content, _headroomMeta: buildMeta() });
         continue;
       }
       if (Array.isArray(content)) {
@@ -271,20 +431,22 @@ function agentToOpenAI(messages) {
             textParts.push(block);
           } else if (block.type === "text") {
             textParts.push(block.text);
-          } else if (block.type === "tool_use") {
+          } else if (block.type === "tool_use" || block.type === "toolCall") {
+            const args = block.type === "toolCall" ? block.arguments : block.input;
             toolCalls.push({
               id: block.id,
               type: "function",
               function: {
                 name: block.name,
-                arguments: typeof block.input === "string" ? block.input : JSON.stringify(block.input ?? {})
+                arguments: typeof args === "string" ? args : JSON.stringify(args ?? {})
               }
             });
           }
         }
         const openaiMsg = {
           role: "assistant",
-          content: textParts.length > 0 ? textParts.join("") : null
+          content: textParts.length > 0 ? textParts.join("") : null,
+          _headroomMeta: buildMeta()
         };
         if (toolCalls.length > 0) {
           openaiMsg.tool_calls = toolCalls;
@@ -294,17 +456,19 @@ function agentToOpenAI(messages) {
       continue;
     }
     if (role === "toolResult" || role === "tool_result") {
-      const content = typeof msg.content === "string" ? msg.content : Array.isArray(msg.content) ? extractText(msg.content) : JSON.stringify(msg.content);
+      const content = typeof normalized.content === "string" ? normalized.content : Array.isArray(normalized.content) ? extractText(normalized.content) : JSON.stringify(normalized.content);
       result.push({
         role: "tool",
         content,
-        tool_call_id: msg.tool_use_id ?? msg.toolCallId ?? msg.id ?? "unknown"
+        tool_call_id: normalized.toolCallId ?? normalized.tool_use_id ?? normalized.id ?? "unknown",
+        _headroomMeta: buildMeta()
       });
       continue;
     }
     result.push({
       role: "user",
-      content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+      content: typeof normalized.content === "string" ? normalized.content : JSON.stringify(normalized.content),
+      _headroomMeta: buildMeta()
     });
   }
   return result;
@@ -312,11 +476,13 @@ function agentToOpenAI(messages) {
 function openAIToAgent(messages) {
   const result = [];
   for (const msg of messages) {
+    const meta = msg._headroomMeta ?? {};
+    const timestamp = typeof meta.timestamp === "number" ? meta.timestamp : Date.now();
     if (msg.role === "system") {
       result.push({
         role: "system",
         content: msg.content ?? "",
-        timestamp: Date.now()
+        timestamp
       });
       continue;
     }
@@ -324,7 +490,7 @@ function openAIToAgent(messages) {
       result.push({
         role: "user",
         content: msg.content ?? "",
-        timestamp: Date.now()
+        timestamp
       });
       continue;
     }
@@ -342,32 +508,55 @@ function openAIToAgent(messages) {
             input = tc.function.arguments ?? {};
           }
           blocks.push({
-            type: "tool_use",
+            type: "toolCall",
             id: tc.id,
             name: tc.function.name,
-            input
+            arguments: input
           });
         }
       }
       result.push({
+        ...meta,
         role: "assistant",
         content: blocks,
-        timestamp: Date.now()
+        api: typeof meta.api === "string" ? meta.api : "headroom",
+        provider: typeof meta.provider === "string" ? meta.provider : "headroom",
+        model: typeof meta.model === "string" ? meta.model : "headroom",
+        usage: isRecord(meta.usage) ? meta.usage : {
+          input: 0,
+          output: 0,
+          cacheRead: 0,
+          cacheWrite: 0,
+          totalTokens: 0,
+          cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+        },
+        stopReason: typeof meta.stopReason === "string" ? meta.stopReason : "stop",
+        timestamp
       });
       continue;
     }
     if (msg.role === "tool") {
+      const textContent = typeof msg.content === "string" ? msg.content : msg.content == null ? "" : JSON.stringify(msg.content);
+      const toolCallId = msg.tool_call_id ?? "unknown";
       result.push({
+        ...meta,
         role: "toolResult",
-        content: msg.content ?? "",
-        tool_use_id: msg.tool_call_id ?? "unknown",
-        timestamp: Date.now()
+        // OpenClaw transport layers expect toolResult content blocks, not a raw string.
+        content: [{ type: "text", text: textContent }],
+        toolCallId: typeof meta.toolCallId === "string" ? meta.toolCallId : toolCallId,
+        tool_use_id: typeof meta.tool_use_id === "string" ? meta.tool_use_id : toolCallId,
+        toolName: typeof meta.toolName === "string" ? meta.toolName : "headroom",
+        isError: typeof meta.isError === "boolean" ? meta.isError : false,
+        timestamp
       });
       continue;
     }
   }
   return result;
 }
+function normalizeAgentMessages(messages) {
+  return messages.map((message) => normalizeAgentMessage(message));
+}
 function extractText(content) {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return JSON.stringify(content);
@@ -380,8 +569,115 @@ function extractText(content) {
     return "";
   }).filter(Boolean).join("\n");
 }
+function normalizeAgentMessage(message) {
+  if (!isRecord(message)) return message;
+  if (message.role === "assistant") {
+    return normalizeAssistantMessage(message);
+  }
+  if (message.role === "toolResult" || message.role === "tool_result") {
+    return normalizeToolResultMessage(message);
+  }
+  return message;
+}
+function normalizeAssistantMessage(message) {
+  const normalizedContent = normalizeAssistantContent(message.content);
+  return {
+    ...message,
+    content: normalizedContent,
+    api: typeof message.api === "string" ? message.api : "headroom",
+    provider: typeof message.provider === "string" ? message.provider : "headroom",
+    model: typeof message.model === "string" ? message.model : "headroom",
+    usage: isRecord(message.usage) ? message.usage : {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      totalTokens: 0,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+    },
+    stopReason: typeof message.stopReason === "string" ? message.stopReason : "stop",
+    timestamp: typeof message.timestamp === "number" ? message.timestamp : Date.now()
+  };
+}
+function normalizeToolResultMessage(message) {
+  const normalizedContent = normalizeToolResultContent(message.content);
+  const toolCallId = typeof message.toolCallId === "string" ? message.toolCallId : typeof message.tool_use_id === "string" ? message.tool_use_id : typeof message.id === "string" ? message.id : "unknown";
+  return {
+    ...message,
+    role: "toolResult",
+    content: normalizedContent,
+    toolCallId,
+    tool_use_id: typeof message.tool_use_id === "string" ? message.tool_use_id : toolCallId,
+    toolName: typeof message.toolName === "string" ? message.toolName : "headroom",
+    isError: typeof message.isError === "boolean" ? message.isError : false,
+    timestamp: typeof message.timestamp === "number" ? message.timestamp : Date.now()
+  };
+}
+function normalizeAssistantContent(content) {
+  if (Array.isArray(content)) {
+    return content.flatMap((block) => {
+      if (typeof block === "string") return [{ type: "text", text: block }];
+      if (!isRecord(block) || typeof block.type !== "string") return [];
+      if (block.type === "text" && typeof block.text === "string") return [block];
+      if (block.type === "thinking" && typeof block.thinking === "string") return [block];
+      if ((block.type === "toolCall" || block.type === "tool_use") && typeof block.name === "string") {
+        return [
+          {
+            type: "toolCall",
+            id: typeof block.id === "string" ? block.id : "unknown",
+            name: block.name,
+            arguments: "arguments" in block ? block.arguments : "input" in block ? block.input : {}
+          }
+        ];
+      }
+      return [];
+    });
+  }
+  if (typeof content === "string" && content.length > 0) {
+    return [{ type: "text", text: content }];
+  }
+  if (content == null) {
+    return [];
+  }
+  return [{ type: "text", text: JSON.stringify(content) }];
+}
+function normalizeToolResultContent(content) {
+  if (Array.isArray(content)) {
+    return content.flatMap((block) => {
+      if (typeof block === "string") return [{ type: "text", text: block }];
+      if (!isRecord(block) || typeof block.type !== "string") return [];
+      if (block.type === "text" && typeof block.text === "string") return [block];
+      if (block.type === "image" && typeof block.data === "string" && typeof block.mimeType === "string") {
+        return [block];
+      }
+      if (block.type === "tool_result" && "content" in block) {
+        return normalizeToolResultContent(block.content);
+      }
+      return [];
+    });
+  }
+  if (typeof content === "string" && content.length > 0) {
+    return [{ type: "text", text: content }];
+  }
+  if (content == null) {
+    return [];
+  }
+  return [{ type: "text", text: JSON.stringify(content) }];
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 
 // src/engine.ts
+function withTimeout(promise, ms) {
+  let timerId;
+  const timer = new Promise((_, reject) => {
+    timerId = setTimeout(() => reject(new Error(`headroom compress() timed out after ${ms}ms`)), ms);
+  });
+  return Promise.race([promise, timer]).finally(() => {
+    if (timerId !== void 0) clearTimeout(timerId);
+  });
+}
 var HeadroomContextEngine = class {
   info = {
     id: "headroom",
@@ -393,21 +689,19 @@ var HeadroomContextEngine = class {
   proxyUrl = null;
   config;
   logger;
+  proxyReadyListeners = /* @__PURE__ */ new Set();
+  proxyStartupPromise = null;
+  proxyStartupError = null;
   stats = {
     totalCompressions: 0,
     totalTokensSaved: 0,
     totalTokensBefore: 0,
     compactions: 0
   };
+  circuit = { errors: 0, openUntilMs: 0 };
   constructor(config = {}, logger) {
     this.config = config;
-    this.logger = logger ?? {
-      info: (m) => console.log(`[headroom] ${m}`),
-      warn: (m) => console.warn(`[headroom] ${m}`),
-      error: (m) => console.error(`[headroom] ${m}`),
-      debug: () => {
-      }
-    };
+    this.logger = logger ?? defaultLogger;
     this.proxyManager = new ProxyManager(config, this.logger);
   }
   // === ContextEngine Lifecycle ===
@@ -415,14 +709,8 @@ var HeadroomContextEngine = class {
     if (this.config.enabled === false) {
       return { bootstrapped: false, reason: "disabled" };
     }
-    try {
-      this.proxyUrl = await this.proxyManager.start();
-      this.logger.info(`Engine bootstrapped (proxy: ${this.proxyUrl})`);
-      return { bootstrapped: true };
-    } catch (error) {
-      this.logger.error(`Bootstrap failed: ${error}`);
-      return { bootstrapped: false, reason: String(error) };
-    }
+    this.ensureProxyStarted();
+    return { bootstrapped: true, reason: "proxy startup scheduled" };
   }
   async ingest(params) {
     return { ingested: true };
@@ -437,20 +725,33 @@ var HeadroomContextEngine = class {
    */
   async assemble(params) {
     if (!this.proxyUrl || this.config.enabled === false) {
-      return { messages: params.messages, estimatedTokens: 0 };
+      this.ensureProxyStarted();
+      return { messages: normalizeAgentMessages(params.messages), estimatedTokens: 0 };
+    }
+    if (this.isCircuitOpen()) {
+      this.logger.warn("[headroom] Circuit open \u2014 using uncompressed messages");
+      return { messages: normalizeAgentMessages(params.messages), estimatedTokens: 0 };
     }
     try {
       const openaiMessages = agentToOpenAI(params.messages);
-      const result = await compress(openaiMessages, {
-        model: params.model ?? "claude-sonnet-4-5",
-        baseUrl: this.proxyUrl,
-        fallback: true,
-        tokenBudget: params.tokenBudget
-      });
+      const result = await withTimeout(
+        compress(openaiMessages, {
+          model: params.model ?? "claude-sonnet-4-5",
+          baseUrl: this.proxyUrl,
+          fallback: true,
+          tokenBudget: params.tokenBudget
+        }),
+        this.config.requestTimeoutMs ?? 3e4
+      );
       if (!result.compressed || result.tokensSaved === 0) {
-        return { messages: params.messages, estimatedTokens: result.tokensBefore };
+        this.resetCircuit();
+        return {
+          messages: normalizeAgentMessages(params.messages),
+          estimatedTokens: result.tokensBefore
+        };
       }
       const compressedAgentMessages = openAIToAgent(result.messages);
+      this.resetCircuit();
       this.stats.totalCompressions++;
       this.stats.totalTokensSaved += result.tokensSaved;
       this.stats.totalTokensBefore += result.tokensBefore;
@@ -464,7 +765,8 @@ var HeadroomContextEngine = class {
       };
     } catch (error) {
       this.logger.error(`Assemble failed: ${error}`);
-      return { messages: params.messages, estimatedTokens: 0 };
+      this.tripCircuit(error);
+      return { messages: normalizeAgentMessages(params.messages), estimatedTokens: 0 };
     }
   }
   /**
@@ -512,36 +814,201 @@ var HeadroomContextEngine = class {
   getProxyUrl() {
     return this.proxyUrl;
   }
+  getProxyStartupError() {
+    return this.proxyStartupError;
+  }
+  isCircuitOpen() {
+    const threshold = this.config.circuitBreakerThreshold ?? 3;
+    if (this.circuit.errors < threshold) return false;
+    if (Date.now() < this.circuit.openUntilMs) return true;
+    this.circuit = { errors: 0, openUntilMs: 0 };
+    return false;
+  }
+  tripCircuit(error) {
+    this.circuit.errors += 1;
+    const threshold = this.config.circuitBreakerThreshold ?? 3;
+    if (this.circuit.errors < threshold) return;
+    const cooldownMs = this.config.circuitBreakerCooldownMs ?? 6e4;
+    this.circuit.openUntilMs = Date.now() + cooldownMs;
+    this.logger.warn(
+      `[headroom] Circuit breaker opened after ${this.circuit.errors} errors (last: ${String(error)}); bypassing compression for ${cooldownMs}ms`
+    );
+  }
+  resetCircuit() {
+    this.circuit = { errors: 0, openUntilMs: 0 };
+  }
+  ensureProxyStarted() {
+    if (this.config.enabled === false || this.proxyUrl || this.proxyStartupPromise) {
+      return;
+    }
+    this.proxyStartupError = null;
+    this.proxyStartupPromise = this.proxyManager.start().then(async (proxyUrl) => {
+      this.proxyUrl = proxyUrl;
+      this.proxyStartupError = null;
+      await this.notifyProxyReady(proxyUrl);
+      this.logger.info(`Headroom proxy ready at ${proxyUrl}`);
+      return proxyUrl;
+    }).catch((error) => {
+      this.proxyStartupError = error;
+      this.logger.warn(`Headroom proxy unavailable: ${error}`);
+      throw error;
+    }).finally(() => {
+      this.proxyStartupPromise = null;
+    });
+    void this.proxyStartupPromise.catch(() => {
+    });
+  }
+  onProxyReady(listener) {
+    this.proxyReadyListeners.add(listener);
+    return () => {
+      this.proxyReadyListeners.delete(listener);
+    };
+  }
+  async ensureProxyUrl() {
+    if (this.proxyUrl) {
+      return this.proxyUrl;
+    }
+    this.ensureProxyStarted();
+    if (!this.proxyStartupPromise) {
+      throw new Error("Headroom proxy startup is disabled");
+    }
+    return this.proxyStartupPromise;
+  }
+  async notifyProxyReady(proxyUrl) {
+    for (const listener of this.proxyReadyListeners) {
+      try {
+        await listener(proxyUrl);
+      } catch (error) {
+        this.logger.warn(`Headroom proxy ready listener failed: ${error}`);
+      }
+    }
+  }
 };
 
+// src/gateway-config.ts
+var DEFAULT_GATEWAY_PROVIDER_IDS = ["openai-codex"];
+var DEFAULT_PROVIDER_BASE_URLS = {
+  "openai-codex": "https://chatgpt.com/backend-api"
+};
+var GATEWAY_PROVIDER_ID_ALIASES = {
+  codex: "openai-codex",
+  claude: "anthropic",
+  copilot: "github-copilot",
+  gemini: "google"
+};
+var EXPLICIT_BASE_URL_REQUIRED_PROVIDER_IDS = /* @__PURE__ */ new Set(["github-copilot"]);
+function resolveGatewayProviderIds(config) {
+  const configuredProviderIds = normalizeGatewayProviderIds(config?.gatewayProviderIds);
+  if (configuredProviderIds.length > 0) {
+    return configuredProviderIds;
+  }
+  if (config?.routeCodexViaProxy === false) {
+    return [];
+  }
+  return [...DEFAULT_GATEWAY_PROVIDER_IDS];
+}
+function normalizeGatewayProviderIds(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const normalized = [];
+  for (const entry of value) {
+    if (typeof entry !== "string") {
+      continue;
+    }
+    const rawProviderId = entry.trim();
+    const providerId = GATEWAY_PROVIDER_ID_ALIASES[rawProviderId.toLowerCase()] ?? rawProviderId;
+    if (!providerId || seen.has(providerId)) {
+      continue;
+    }
+    seen.add(providerId);
+    normalized.push(providerId);
+  }
+  return normalized;
+}
+function applyGatewayProviderBaseUrls(cfg, proxyUrl, providerIds) {
+  const next = structuredClone(cfg ?? {});
+  const changed = applyGatewayProviderBaseUrlsInPlace(next, proxyUrl, providerIds);
+  return { changed, config: next };
+}
+function applyGatewayProviderBaseUrlsInPlace(cfg, proxyUrl, providerIds) {
+  if (!cfg || typeof cfg !== "object" || providerIds.length === 0) {
+    return false;
+  }
+  const models = cfg.models ??= {};
+  const providers = models.providers ??= {};
+  let changed = false;
+  for (const providerId of providerIds) {
+    const currentValue = providers[providerId];
+    const currentConfig = currentValue && typeof currentValue === "object" && !Array.isArray(currentValue) ? currentValue : {};
+    const nextConfig = { ...currentConfig };
+    const currentBaseUrl = typeof nextConfig.baseUrl === "string" && nextConfig.baseUrl.trim().length > 0 ? nextConfig.baseUrl : void 0;
+    const defaultBaseUrl = DEFAULT_PROVIDER_BASE_URLS[providerId];
+    if (!currentBaseUrl && !defaultBaseUrl && EXPLICIT_BASE_URL_REQUIRED_PROVIDER_IDS.has(providerId)) {
+      continue;
+    }
+    const nextBaseUrl = routeBaseUrlThroughProxy({
+      providerId,
+      proxyUrl,
+      currentBaseUrl
+    });
+    if (!Array.isArray(nextConfig.models)) {
+      nextConfig.models = [];
+      changed = true;
+    }
+    if (nextConfig.baseUrl === nextBaseUrl) {
+      providers[providerId] = nextConfig;
+      continue;
+    }
+    nextConfig.baseUrl = nextBaseUrl;
+    providers[providerId] = nextConfig;
+    changed = true;
+  }
+  return changed;
+}
+function routeBaseUrlThroughProxy(params) {
+  const upstreamBaseUrl = params.currentBaseUrl ?? DEFAULT_PROVIDER_BASE_URLS[params.providerId];
+  if (!upstreamBaseUrl) {
+    return params.proxyUrl;
+  }
+  try {
+    const proxy = new URL(params.proxyUrl);
+    const upstream = new URL(upstreamBaseUrl);
+    proxy.pathname = upstream.pathname;
+    proxy.search = upstream.search;
+    proxy.hash = "";
+    return proxy.toString().replace(/\/$/, "");
+  } catch {
+    return params.proxyUrl;
+  }
+}
+
 // src/tools/headroom-retrieve.ts
 function createHeadroomRetrieveTool(config) {
+  const proxyOrigin = normalizeAndValidateProxyUrl(config.proxyUrl);
   return {
     name: "headroom_retrieve",
-    description: "Retrieve original uncompressed content from Headroom's compression store. Use when compressed context mentions a hash and you need the full details. Pass the hash from the compression marker (24 hex characters). Optionally pass a query to search within the original content.",
+    description: "Retrieve original uncompressed content from Headroom's compression store. Use when compressed context mentions a hash and you need the full details. Pass the hash from the compression marker (24 hex characters). Retrieval is by hash and always returns the full original content.",
     parameters: {
       type: "object",
       properties: {
         hash: {
           type: "string",
           description: "The 24-character hex hash from the compression marker"
-        },
-        query: {
-          type: "string",
-          description: "Optional search query to filter results within the original content"
         }
       },
       required: ["hash"]
     },
     execute: async (args) => {
-      const { hash, query } = args;
+      const { hash } = args;
       if (!/^[a-f0-9]{24}$/i.test(hash)) {
         return JSON.stringify({
           error: "Invalid hash format. Expected 24 hex characters."
         });
       }
       try {
-        const url = query ? `${config.proxyUrl}/v1/retrieve/${hash}?query=${encodeURIComponent(query)}` : `${config.proxyUrl}/v1/retrieve/${hash}`;
+        const url = `${proxyOrigin}/v1/retrieve/${hash}`;
         const resp = await fetch(url, {
           signal: AbortSignal.timeout(1e4)
         });
@@ -557,7 +1024,7 @@ function createHeadroomRetrieveTool(config) {
       } catch (error) {
         return JSON.stringify({
           error: `Retrieval failed: ${error}`,
-          hint: "The compressed content may have expired (default TTL: 5 minutes)"
+          hint: "The compressed content may have expired (default TTL: 30 minutes)"
         });
       }
     }
@@ -565,29 +1032,112 @@ function createHeadroomRetrieveTool(config) {
 }
 
 // src/plugin/index.ts
-function headroomPlugin(api) {
+var plugin_default = {
+  register: registerHeadroomPlugin
+};
+function registerHeadroomPlugin(api) {
   const config = api.config?.plugins?.entries?.headroom?.config ?? {};
   const logger = api.logger ?? console;
-  const engine = new HeadroomContextEngine(config, {
+  const rawProxyUrl = config.proxyUrl;
+  const proxyUrl = typeof rawProxyUrl === "string" && rawProxyUrl.trim().length > 0 ? normalizeAndValidateProxyUrl(rawProxyUrl) : void 0;
+  const engine = new HeadroomContextEngine({ ...config, proxyUrl }, {
     info: (m) => logger.info(m),
     warn: (m) => logger.warn(m),
     error: (m) => logger.error(m),
     debug: (m) => logger.debug?.(m)
   });
+  const gatewayProviderIds = resolveGatewayProviderIds(config);
+  let validatedConfiguredProxyUrl = null;
+  let configuredProxyProbePromise = null;
+  const applyGatewayRouting = async (activeProxyUrl) => {
+    if (gatewayProviderIds.length === 0) {
+      return;
+    }
+    try {
+      const changed = applyGatewayProviderBaseUrlsInPlace(api.config, activeProxyUrl, gatewayProviderIds);
+      if (changed) {
+        logger.info(
+          `[headroom] Routed ${gatewayProviderIds.join(", ")} through Headroom proxy in memory at ${activeProxyUrl}`
+        );
+      } else {
+        logger.info(
+          `[headroom] Upstream gateway already routed in memory for ${gatewayProviderIds.join(", ")} at ${activeProxyUrl}`
+        );
+      }
+    } catch (error) {
+      logger.warn(`[headroom] Failed to configure upstream gateway routing: ${error}`);
+    }
+  };
+  const getConfiguredRoutingProxyUrl = async () => {
+    if (!proxyUrl) {
+      return null;
+    }
+    if (validatedConfiguredProxyUrl === proxyUrl) {
+      return validatedConfiguredProxyUrl;
+    }
+    if (!configuredProxyProbePromise) {
+      configuredProxyProbePromise = probeHeadroomProxy(proxyUrl).then((probe) => {
+        if (probe.reachable && probe.isHeadroom) {
+          validatedConfiguredProxyUrl = proxyUrl;
+          return proxyUrl;
+        }
+        logger.warn(
+          `[headroom] Skipping upstream gateway routing: configured proxyUrl is not a ready Headroom proxy at ${proxyUrl}` + (probe.reason ? ` (${probe.reason})` : "")
+        );
+        return null;
+      }).catch((error) => {
+        logger.warn(
+          `[headroom] Skipping upstream gateway routing: failed to probe configured proxyUrl ${proxyUrl}: ${error}`
+        );
+        return null;
+      }).finally(() => {
+        configuredProxyProbePromise = null;
+      });
+    }
+    return configuredProxyProbePromise;
+  };
+  const ensureGatewayRouting = async () => {
+    if (gatewayProviderIds.length === 0) {
+      return;
+    }
+    const activeProxyUrl = engine.getProxyUrl() ?? await getConfiguredRoutingProxyUrl();
+    if (!activeProxyUrl) {
+      logger.debug?.("[headroom] Deferring upstream gateway routing until proxy is available");
+      return;
+    }
+    await applyGatewayRouting(activeProxyUrl);
+  };
+  engine.onProxyReady(async (activeProxyUrl) => {
+    await applyGatewayRouting(activeProxyUrl);
+  });
   api.registerContextEngine("headroom", () => engine);
   api.registerTool((ctx) => {
-    const proxyUrl = engine.getProxyUrl();
-    if (!proxyUrl) return null;
-    return createHeadroomRetrieveTool({ proxyUrl });
+    const activeProxyUrl = engine.getProxyUrl() ?? proxyUrl;
+    if (!activeProxyUrl) return null;
+    return createHeadroomRetrieveTool({ proxyUrl: activeProxyUrl });
+  }, { names: ["headroom_retrieve"] });
+  api.on("gateway_start", async () => {
+    await ensureGatewayRouting();
   });
+  void ensureGatewayRouting();
   logger.info("[headroom] Plugin registered");
 }
 export {
+  DEFAULT_GATEWAY_PROVIDER_IDS,
   HeadroomContextEngine,
   ProxyManager,
   agentToOpenAI,
+  applyGatewayProviderBaseUrls,
+  applyGatewayProviderBaseUrlsInPlace,
   createHeadroomRetrieveTool,
-  headroomPlugin as default,
-  openAIToAgent
+  plugin_default as default,
+  defaultLogger,
+  isLocalProxyUrl,
+  normalizeAgentMessages,
+  normalizeAndValidateProxyUrl,
+  openAIToAgent,
+  probeHeadroomProxy,
+  registerHeadroomPlugin,
+  resolveGatewayProviderIds
 };
 //# sourceMappingURL=index.js.map