open-agents-ai 0.65.0 → 0.67.0

package/dist/index.js

@@ -19129,14 +19129,14 @@ var require_extension = __commonJS({
 var require_websocket = __commonJS({
   "node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/websocket.js"(exports, module) {
     "use strict";
-    var EventEmitter4 = __require("events");
+    var EventEmitter5 = __require("events");
     var https = __require("https");
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes5, createHash: createHash2 } = __require("crypto");
+    var { randomBytes: randomBytes6, createHash: createHash2 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
-    var { URL: URL2 } = __require("url");
+    var { URL: URL3 } = __require("url");
     var PerMessageDeflate = require_permessage_deflate();
     var Receiver2 = require_receiver();
     var Sender2 = require_sender();
@@ -19161,7 +19161,7 @@ var require_websocket = __commonJS({
     var protocolVersions = [8, 13];
     var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
     var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
-    var WebSocket2 = class _WebSocket extends EventEmitter4 {
+    var WebSocket2 = class _WebSocket extends EventEmitter5 {
       /**
        * Create a new `WebSocket`.
        *
@@ -19629,11 +19629,11 @@ var require_websocket = __commonJS({
         );
       }
       let parsedUrl;
-      if (address instanceof URL2) {
+      if (address instanceof URL3) {
         parsedUrl = address;
       } else {
         try {
-          parsedUrl = new URL2(address);
+          parsedUrl = new URL3(address);
         } catch (e) {
           throw new SyntaxError(`Invalid URL: ${address}`);
         }
@@ -19664,7 +19664,7 @@ var require_websocket = __commonJS({
         }
       }
       const defaultPort = isSecure ? 443 : 80;
-      const key = randomBytes5(16).toString("base64");
+      const key = randomBytes6(16).toString("base64");
       const request = isSecure ? https.request : http.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
@@ -19770,7 +19770,7 @@ var require_websocket = __commonJS({
           req.abort();
           let addr;
           try {
-            addr = new URL2(location, address);
+            addr = new URL3(location, address);
           } catch (e) {
             const err = new SyntaxError(`Invalid URL: ${location}`);
             emitErrorAndClose(websocket, err);
@@ -20158,7 +20158,7 @@ var require_subprotocol = __commonJS({
 var require_websocket_server = __commonJS({
   "node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/websocket-server.js"(exports, module) {
     "use strict";
-    var EventEmitter4 = __require("events");
+    var EventEmitter5 = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
     var { createHash: createHash2 } = __require("crypto");
@@ -20171,7 +20171,7 @@ var require_websocket_server = __commonJS({
     var RUNNING = 0;
     var CLOSING = 1;
     var CLOSED = 2;
-    var WebSocketServer2 = class extends EventEmitter4 {
+    var WebSocketServer2 = class extends EventEmitter5 {
       /**
        * Create a `WebSocketServer` instance.
        *
@@ -22173,8 +22173,278 @@ var init_voice_session = __esm({
   }
 });
 
-// packages/cli/dist/tui/call-agent.js
+// packages/cli/dist/tui/expose.js
+import { createServer as createServer2, request as httpRequest } from "node:http";
+import { spawn as spawn11 } from "node:child_process";
 import { EventEmitter as EventEmitter3 } from "node:events";
+import { randomBytes as randomBytes5 } from "node:crypto";
+import { URL as URL2 } from "node:url";
+var DEFAULT_TARGETS, ExposeGateway;
+var init_expose = __esm({
+  "packages/cli/dist/tui/expose.js"() {
+    "use strict";
+    init_render();
+    DEFAULT_TARGETS = {
+      ollama: "http://127.0.0.1:11434",
+      vllm: "http://127.0.0.1:8000",
+      llvm: "http://127.0.0.1:8080",
+      custom: "http://127.0.0.1:11434"
+    };
+    ExposeGateway = class extends EventEmitter3 {
+      options;
+      server = null;
+      cloudflaredProcess = null;
+      _tunnelUrl = null;
+      _authKey;
+      _targetUrl;
+      _kind;
+      _stats = {
+        status: "standby",
+        totalRequests: 0,
+        activeConnections: 0,
+        errors: 0,
+        modelUsage: /* @__PURE__ */ new Map()
+      };
+      get tunnelUrl() {
+        return this._tunnelUrl;
+      }
+      get authKey() {
+        return this._authKey;
+      }
+      get stats() {
+        return this._stats;
+      }
+      get kind() {
+        return this._kind;
+      }
+      get isActive() {
+        return this._stats.status === "active";
+      }
+      constructor(options) {
+        super();
+        this.options = options;
+        this._kind = options.kind;
+        this._targetUrl = options.targetUrl ?? DEFAULT_TARGETS[options.kind];
+        if (options.authKey === void 0 || options.authKey === "") {
+          this._authKey = randomBytes5(24).toString("base64url");
+        } else {
+          this._authKey = options.authKey;
+        }
+      }
+      // ── Lifecycle ───────────────────────────────────────────────────────────
+      async start() {
+        if (this.server)
+          throw new Error("Gateway already running");
+        const port = await this.findFreePort();
+        this.server = this.createProxyServer(port);
+        await new Promise((resolve28, reject) => {
+          this.server.listen(port, "127.0.0.1", () => resolve28());
+          this.server.on("error", reject);
+        });
+        this._tunnelUrl = await this.startCloudflared(port);
+        this._stats.status = "active";
+        this.emitStats();
+        return this._tunnelUrl;
+      }
+      async stop() {
+        if (this.cloudflaredProcess) {
+          this.cloudflaredProcess.kill("SIGTERM");
+          this.cloudflaredProcess = null;
+        }
+        if (this.server) {
+          await new Promise((resolve28) => {
+            this.server.close(() => resolve28());
+          });
+          this.server = null;
+        }
+        this._tunnelUrl = null;
+        this._stats.status = "standby";
+        this._stats.activeConnections = 0;
+        this.emitStats();
+      }
+      // ── Proxy server ────────────────────────────────────────────────────────
+      createProxyServer(localPort) {
+        const target = new URL2(this._targetUrl);
+        return createServer2((req, res) => {
+          const authHeader = req.headers.authorization;
+          const url = new URL2(req.url ?? "/", `http://127.0.0.1:${localPort}`);
+          const queryKey = url.searchParams.get("key");
+          const providedKey = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : queryKey;
+          if (providedKey !== this._authKey) {
+            this._stats.errors++;
+            res.writeHead(401, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Unauthorized \u2014 provide Bearer token or ?key= parameter" }));
+            this.emitStats();
+            return;
+          }
+          this._stats.totalRequests++;
+          this._stats.activeConnections++;
+          this.emitStats();
+          this.extractModelFromRequest(req);
+          url.searchParams.delete("key");
+          const forwardPath = url.pathname + url.search;
+          const proxyReq = httpRequest({
+            hostname: target.hostname,
+            port: target.port || (target.protocol === "https:" ? 443 : 80),
+            path: forwardPath,
+            method: req.method,
+            headers: {
+              ...req.headers,
+              host: target.host,
+              // Remove auth header — the backend doesn't need it
+              authorization: void 0
+            }
+          }, (proxyRes) => {
+            res.writeHead(proxyRes.statusCode ?? 502, proxyRes.headers);
+            proxyRes.pipe(res);
+            proxyRes.on("end", () => {
+              this._stats.activeConnections = Math.max(0, this._stats.activeConnections - 1);
+              this.emitStats();
+            });
+          });
+          proxyReq.on("error", (err) => {
+            this._stats.errors++;
+            this._stats.activeConnections = Math.max(0, this._stats.activeConnections - 1);
+            if (!res.headersSent) {
+              res.writeHead(502, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ error: `Backend unreachable: ${err.message}` }));
+            }
+            this._stats.status = "error";
+            this.emitStats();
+            setTimeout(() => {
+              if (this.server && this._stats.status === "error") {
+                this._stats.status = "active";
+                this.emitStats();
+              }
+            }, 5e3);
+          });
+          req.pipe(proxyReq);
+        });
+      }
+      /** Best-effort model name extraction from JSON body for usage tracking */
+      extractModelFromRequest(req) {
+        if (req.method !== "POST")
+          return;
+        const chunks = [];
+        const origEmit = req.emit.bind(req);
+        let peeked = false;
+        const stats = this._stats;
+        req.emit = function(event, ...args) {
+          if (event === "data" && !peeked) {
+            peeked = true;
+            try {
+              const chunk = args[0];
+              chunks.push(chunk);
+              const text = Buffer.concat(chunks).toString();
+              const modelMatch = text.match(/"model"\s*:\s*"([^"]+)"/);
+              if (modelMatch) {
+                const model = modelMatch[1];
+                const count = stats.modelUsage.get(model) ?? 0;
+                stats.modelUsage.set(model, count + 1);
+              }
+            } catch {
+            }
+          }
+          return origEmit(event, ...args);
+        };
+      }
+      // ── Cloudflared ─────────────────────────────────────────────────────────
+      startCloudflared(port) {
+        return new Promise((resolve28, reject) => {
+          const timeout = setTimeout(() => {
+            reject(new Error("Cloudflared tunnel start timeout (30s)"));
+          }, 3e4);
+          this.cloudflaredProcess = spawn11("cloudflared", [
+            "tunnel",
+            "--url",
+            `http://127.0.0.1:${port}`
+          ], {
+            stdio: ["ignore", "pipe", "pipe"]
+          });
+          let urlFound = false;
+          const handleOutput = (data) => {
+            const text = data.toString();
+            const urlMatch = text.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/);
+            if (urlMatch && !urlFound) {
+              urlFound = true;
+              clearTimeout(timeout);
+              resolve28(urlMatch[0]);
+            }
+          };
+          this.cloudflaredProcess.stdout?.on("data", handleOutput);
+          this.cloudflaredProcess.stderr?.on("data", handleOutput);
+          this.cloudflaredProcess.on("error", (err) => {
+            clearTimeout(timeout);
+            reject(new Error(`Failed to start cloudflared: ${err.message}`));
+          });
+          this.cloudflaredProcess.on("close", (code) => {
+            if (!urlFound) {
+              clearTimeout(timeout);
+              reject(new Error(`Cloudflared exited with code ${code} before providing URL`));
+            }
+            if (this._stats.status === "active") {
+              this._stats.status = "error";
+              this.emitStats();
+            }
+          });
+        });
+      }
+      // ── Helpers ─────────────────────────────────────────────────────────────
+      findFreePort() {
+        return new Promise((resolve28, reject) => {
+          const srv = createServer2();
+          srv.listen(0, "127.0.0.1", () => {
+            const addr = srv.address();
+            if (addr && typeof addr === "object") {
+              const port = addr.port;
+              srv.close(() => resolve28(port));
+            } else {
+              srv.close(() => reject(new Error("Could not find free port")));
+            }
+          });
+          srv.on("error", reject);
+        });
+      }
+      emitStats() {
+        this.emit("stats", { ...this._stats, modelUsage: new Map(this._stats.modelUsage) });
+      }
+      /** Format connection info for display */
+      formatConnectionInfo() {
+        const lines = [];
+        lines.push(`  ${c2.green("\u25CF")} Expose gateway active`);
+        lines.push(`  ${c2.cyan("Backend".padEnd(12))} ${this._kind} (${this._targetUrl})`);
+        lines.push(`  ${c2.cyan("Tunnel".padEnd(12))} ${c2.bold(this._tunnelUrl ?? "starting...")}`);
+        lines.push(`  ${c2.cyan("Auth Key".padEnd(12))} ${c2.bold(this._authKey)}`);
+        lines.push("");
+        lines.push(`  ${c2.dim("Remote users connect with:")}`);
+        lines.push(`  ${c2.bold(`/endpoint ${this._tunnelUrl ?? "<tunnel-url>"} --auth ${this._authKey}`)}`);
+        lines.push("");
+        lines.push(`  ${c2.yellow("!")} ${c2.dim("Keep this key secure \u2014 it grants full access to your models.")}`);
+        return lines.join("\n");
+      }
+      /** Format usage stats for display */
+      formatStats() {
+        const s = this._stats;
+        const lines = [];
+        lines.push(`  ${c2.bold("Expose Gateway Stats")}`);
+        lines.push(`  ${c2.cyan("Status".padEnd(16))} ${s.status === "active" ? c2.green("active") : s.status === "error" ? c2.red("error") : c2.yellow("standby")}`);
+        lines.push(`  ${c2.cyan("Total requests".padEnd(16))} ${s.totalRequests}`);
+        lines.push(`  ${c2.cyan("Active conns".padEnd(16))} ${s.activeConnections}`);
+        lines.push(`  ${c2.cyan("Errors".padEnd(16))} ${s.errors}`);
+        if (s.modelUsage.size > 0) {
+          lines.push(`  ${c2.cyan("Models used:")}`);
+          for (const [model, count] of s.modelUsage) {
+            lines.push(`    ${model}: ${count} requests`);
+          }
+        }
+        return lines.join("\n");
+      }
+    };
+  }
+});
+
+// packages/cli/dist/tui/call-agent.js
+import { EventEmitter as EventEmitter4 } from "node:events";
 import crypto2 from "node:crypto";
 function adaptTool(tool) {
   return {
@@ -22234,7 +22504,7 @@ var init_call_agent = __esm({
       }
     };
     _globalFeed = null;
-    CallSubAgent = class extends EventEmitter3 {
+    CallSubAgent = class extends EventEmitter4 {
       tier;
       clientId;
       runner = null;
@@ -23269,7 +23539,7 @@ var init_oa_directory = __esm({
 
 // packages/cli/dist/tui/setup.js
 import * as readline from "node:readline";
-import { execSync as execSync20, spawn as spawn11 } from "node:child_process";
+import { execSync as execSync20, spawn as spawn12 } from "node:child_process";
 import { existsSync as existsSync22, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8 } from "node:fs";
 import { join as join31 } from "node:path";
 import { homedir as homedir10, platform } from "node:os";
@@ -23755,7 +24025,7 @@ async function doSetup(config, rl) {
   ${c2.cyan("\u25CF")} Starting ollama serve in background...
 `);
         try {
-          const child = spawn11("ollama", ["serve"], { stdio: "ignore", detached: true });
+          const child = spawn12("ollama", ["serve"], { stdio: "ignore", detached: true });
           child.unref();
           await new Promise((resolve28) => setTimeout(resolve28, 3e3));
           try {
@@ -23783,7 +24053,7 @@ async function doSetup(config, rl) {
   ${c2.cyan("\u25CF")} Starting ollama serve...
 `);
           try {
-            const child = spawn11("ollama", ["serve"], { stdio: "ignore", detached: true });
+            const child = spawn12("ollama", ["serve"], { stdio: "ignore", detached: true });
             child.unref();
             await new Promise((resolve28) => setTimeout(resolve28, 3e3));
             try {
@@ -24897,6 +25167,71 @@ async function handleSlashCommand(input, ctx) {
       }
       return "handled";
     }
+    case "expose": {
+      if (!ctx.exposeStart) {
+        renderWarning("Expose gateway not available in this context.");
+        return "handled";
+      }
+      if (arg === "stop" || arg === "off") {
+        if (ctx.isExposeActive?.()) {
+          await ctx.exposeStop?.();
+          renderInfo("Expose gateway stopped.");
+        } else {
+          renderWarning("No active expose gateway.");
+        }
+        return "handled";
+      }
+      if (arg === "status") {
+        const info = ctx.getExposeInfo?.();
+        if (info) {
+          process.stdout.write("\n" + info.stats + "\n\n");
+        } else {
+          renderWarning("No active expose gateway.");
+        }
+        return "handled";
+      }
+      if (!arg) {
+        const info = ctx.getExposeInfo?.();
+        if (info && ctx.isExposeActive?.()) {
+          process.stdout.write("\n" + info.stats + "\n\n");
+        } else {
+          renderInfo("Usage: /expose <backend> [--key <auth-key>]");
+          renderInfo("  /expose ollama           Expose local Ollama (11434)");
+          renderInfo("  /expose vllm             Expose local vLLM (8000)");
+          renderInfo("  /expose llvm             Expose local LLVM (8080)");
+          renderInfo("  /expose host:port        Expose custom address");
+          renderInfo("  /expose stop             Stop the gateway");
+          renderInfo("  /expose status           Show usage stats");
+          renderInfo("  --key <key>              Use specific auth key");
+          renderInfo("  --key                    Auto-generate auth key");
+        }
+        return "handled";
+      }
+      if (ctx.isExposeActive?.()) {
+        await ctx.exposeStop?.();
+      }
+      const exposeParts = arg.split(/\s+/);
+      const kindOrUrl = exposeParts[0];
+      let exposeAuthKey;
+      const keyIdx = exposeParts.indexOf("--key");
+      if (keyIdx !== -1) {
+        exposeAuthKey = exposeParts[keyIdx + 1] ?? "";
+      }
+      try {
+        const tunnelUrl = await ctx.exposeStart(kindOrUrl, exposeAuthKey);
+        if (tunnelUrl) {
+          const info = ctx.getExposeInfo?.();
+          if (info) {
+            process.stdout.write("\n" + info.stats + "\n\n");
+          }
+        } else {
+          renderError("Failed to start expose gateway.");
+        }
+      } catch (err) {
+        renderError(`Expose error: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      return "handled";
+    }
     case "bruteforce":
     case "brute": {
       const isOn = ctx.bruteForceToggle();
@@ -25471,14 +25806,39 @@ async function handleUpdate(subcommand, ctx) {
 async function switchModel(query, ctx, local = false) {
   try {
     const models = await fetchModels(ctx.config.backendUrl, ctx.config.apiKey);
-    const match = findModel(models, query);
+    let match = findModel(models, query);
     if (!match) {
-      renderError(`Model not found: "${query}"`);
-      renderInfo("Available models:");
-      for (const m of models.slice(0, 10)) {
-        renderInfo(`  ${m.name}`);
+      if (ctx.config.backendType === "ollama") {
+        if (!/^[a-zA-Z0-9][a-zA-Z0-9._:/-]*$/.test(query)) {
+          renderError(`Invalid model name: "${query}"`);
+          return;
+        }
+        renderInfo(`Model "${query}" not found locally. Pulling from Ollama registry...`);
+        try {
+          pullModelWithAutoUpdate(query);
+          const refreshedModels = await fetchModels(ctx.config.backendUrl, ctx.config.apiKey);
+          match = findModel(refreshedModels, query);
+          if (!match) {
+            renderError(`Model "${query}" was pulled but could not be found.`);
+            return;
+          }
+        } catch {
+          renderError(`Model "${query}" could not be pulled from Ollama registry.`);
+          renderInfo("Check that the model name is correct: https://ollama.com/library");
+          renderInfo("Available local models:");
+          for (const m of models.slice(0, 10)) {
+            renderInfo(`  ${m.name}`);
+          }
+          return;
+        }
+      } else {
+        renderError(`Model not found: "${query}"`);
+        renderInfo("Available models:");
+        for (const m of models.slice(0, 10)) {
+          renderInfo(`  ${m.name}`);
+        }
+        return;
       }
-      return;
     }
     let finalModel = match.name;
     if (ctx.config.backendType === "ollama") {
@@ -25512,6 +25872,7 @@ async function switchModel(query, ctx, local = false) {
       const caps = await queryModelCapabilities(ctx.config.backendUrl, finalModel);
       ctx.setCapabilities(caps);
     }
+    ctx.refreshModelCache?.();
   } catch (err) {
     renderError(`Failed to switch model: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -33552,7 +33913,7 @@ var init_status_bar = __esm({
         return this.toolCalls > 0;
       }
     };
-    StatusBar = class {
+    StatusBar = class _StatusBar {
       metrics = {
         promptTokens: 0,
         completionTokens: 0,
@@ -33768,6 +34129,20 @@ var init_status_bar = __esm({
         if (this.active)
           this.renderFooterPreserveCursor();
       }
+      /** Expose gateway status — shown after capability emojis */
+      _expose = null;
+      /** Update expose gateway status */
+      setExposeStatus(status) {
+        this._expose = status;
+        if (this.active)
+          this.renderFooterPreserveCursor();
+      }
+      /** Clear expose gateway status */
+      clearExposeStatus() {
+        this._expose = null;
+        if (this.active)
+          this.renderFooterPreserveCursor();
+      }
       /** Update token metrics from a token_usage event */
       updateMetrics(update) {
         if (update.promptTokens !== void 0)
@@ -33937,68 +34312,239 @@ var init_status_bar = __esm({
         const pos = this.rowPositions(rows);
         process.stdout.write(`\x1B[${pos.inputStartRow};1H\x1B[2K`);
       }
-      /** Build the metrics line string */
+      /** Strip ANSI escape codes to measure visible character width */
+      static visWidth(s) {
+        const stripped = s.replace(/\x1B\[[0-9;]*m/g, "");
+        let w = 0;
+        for (const ch of stripped) {
+          const cp = ch.codePointAt(0) ?? 0;
+          if (cp >= 127744 && cp <= 129784)
+            w += 2;
+          else
+            w += 1;
+        }
+        return w;
+      }
+      /** Format number compactly: 1234 → "1.2K", 567 → "567" */
+      static compactNum(n) {
+        if (n < 0)
+          return "0";
+        if (n < 1e3)
+          return String(n);
+        if (n < 1e4)
+          return `${(n / 1e3).toFixed(1)}K`;
+        if (n < 1e6)
+          return `${Math.round(n / 1e3)}K`;
+        return `${(n / 1e6).toFixed(1)}M`;
+      }
+      /** Build the metrics line string with adaptive compaction */
       buildMetricsLine() {
         const m = this.metrics;
+        const termWidth = getTermWidth();
         const pastel2 = (code, s) => `\x1B[38;5;${code}m${s}\x1B[0m`;
         const pipe = pastel2(60, " \u2502 ");
-        const tokIn = m.promptTokens > 0 ? m.promptTokens.toLocaleString() : `~${Math.max(m.estimatedContextTokens, 0).toLocaleString()}`;
-        const tokInLabel = pastel2(117, "In: ") + c2.bold(tokIn);
+        const pipeW = 3;
+        const sections = [];
+        const tokInRaw = m.promptTokens > 0 ? m.promptTokens : Math.max(m.estimatedContextTokens, 0);
+        const tokInPrefix = m.promptTokens > 0 ? "" : "~";
+        const tokInExpanded = pastel2(117, "In: ") + c2.bold(tokInPrefix + tokInRaw.toLocaleString());
+        const tokInCompact = pastel2(117, "I:") + c2.bold(tokInPrefix + _StatusBar.compactNum(tokInRaw));
+        sections.push({
+          expanded: tokInExpanded,
+          compact: tokInCompact,
+          expandedW: 4 + (tokInPrefix + tokInRaw.toLocaleString()).length,
+          compactW: 2 + (tokInPrefix + _StatusBar.compactNum(tokInRaw)).length,
+          empty: false
+        });
         const effectiveOut = this.effectiveCompletionTokens;
-        const tokOut = effectiveOut > 0 ? effectiveOut.toLocaleString() : `~${Math.ceil(m.totalTokens > 0 ? m.totalTokens - m.promptTokens : m.estimatedContextTokens * 0.3).toLocaleString()}`;
-        const tokOutLabel = pastel2(151, "Out: ") + c2.bold(tokOut);
+        const tokOutRaw = effectiveOut > 0 ? effectiveOut : Math.ceil(m.totalTokens > 0 ? m.totalTokens - m.promptTokens : m.estimatedContextTokens * 0.3);
+        const tokOutPrefix = effectiveOut > 0 ? "" : "~";
+        const tokOutExpanded = pastel2(151, "Out: ") + c2.bold(tokOutPrefix + Math.max(0, tokOutRaw).toLocaleString());
+        const tokOutCompact = pastel2(151, "O:") + c2.bold(tokOutPrefix + _StatusBar.compactNum(Math.max(0, tokOutRaw)));
+        sections.push({
+          expanded: tokOutExpanded,
+          compact: tokOutCompact,
+          expandedW: 5 + (tokOutPrefix + Math.max(0, tokOutRaw).toLocaleString()).length,
+          compactW: 2 + (tokOutPrefix + _StatusBar.compactNum(Math.max(0, tokOutRaw))).length,
+          empty: false
+        });
         const ctxUsed = m.estimatedContextTokens;
         const ctxTotal = m.contextWindowSize;
-        let ctxLabel;
+        let ctxExpanded;
+        let ctxCompact;
+        let ctxExpandedW;
+        let ctxCompactW;
         if (ctxTotal <= 0) {
-          ctxLabel = pastel2(153, "Ctx: ") + c2.dim("--");
+          ctxExpanded = pastel2(153, "Ctx: ") + c2.dim("--");
+          ctxCompact = pastel2(153, "Ctx:") + c2.dim("--");
+          ctxExpandedW = 7;
+          ctxCompactW = 6;
         } else {
           const ctxPct = Math.max(0, Math.min(100, Math.round((1 - ctxUsed / ctxTotal) * 100)));
           const ctxColor = ctxPct > 50 ? c2.green : ctxPct > 20 ? c2.yellow : c2.red;
-          ctxLabel = pastel2(153, "Ctx: ") + c2.bold(`${ctxUsed.toLocaleString()}/${ctxTotal.toLocaleString()}`) + ` ${ctxColor(`${ctxPct}%`)}`;
+          const ctxFullStr = `${ctxUsed.toLocaleString()}/${ctxTotal.toLocaleString()}`;
+          ctxExpanded = pastel2(153, "Ctx: ") + c2.bold(ctxFullStr) + ` ${ctxColor(`${ctxPct}%`)}`;
+          ctxCompact = pastel2(153, "Ctx:") + ctxColor(`${ctxPct}%`);
+          ctxExpandedW = 5 + ctxFullStr.length + 1 + `${ctxPct}%`.length;
+          ctxCompactW = 4 + `${ctxPct}%`.length;
         }
-        let costLabel = "";
-        if (m.hasPricing && m.estimatedCost !== void 0) {
-          const costStr = m.estimatedCost < 0.01 ? `$${m.estimatedCost.toFixed(4)}` : m.estimatedCost < 1 ? `$${m.estimatedCost.toFixed(3)}` : `$${m.estimatedCost.toFixed(2)}`;
-          costLabel = pipe + pastel2(222, "Cost: ") + c2.bold(costStr);
-        }
-        let snrLabel = "";
+        sections.push({ expanded: ctxExpanded, compact: ctxCompact, expandedW: ctxExpandedW, compactW: ctxCompactW, empty: false });
         if (this._snr) {
           const snrPct = Math.round(this._snr.ratio * 100);
           const snrColor = snrPct >= 70 ? c2.green : snrPct >= 40 ? c2.yellow : c2.red;
           const dPrimeStr = this._snr.dPrime.toFixed(1);
           const capStr = this._snr.capacityWarning ? c2.red(" !CAP") : "";
-          snrLabel = pipe + pastel2(183, "SNR: ") + snrColor(c2.bold(`${snrPct}%`)) + c2.dim(` d'${dPrimeStr}`) + capStr;
+          const snrExpanded = pastel2(183, "SNR: ") + snrColor(c2.bold(`${snrPct}%`)) + c2.dim(` d'${dPrimeStr}`) + capStr;
+          const snrCompact = snrColor(`${snrPct}%`);
+          const expW = 5 + `${snrPct}%`.length + 3 + dPrimeStr.length + (this._snr.capacityWarning ? 5 : 0);
+          sections.push({ expanded: snrExpanded, compact: snrCompact, expandedW: expW, compactW: `${snrPct}%`.length, empty: false });
         }
-        let emotionLabel = "";
         if (this._emotion) {
-          emotionLabel = pipe + this._emotion.emoji + " " + pastel2(183, this._emotion.label);
+          const emotionExpanded = this._emotion.emoji + " " + pastel2(183, this._emotion.label);
+          const emotionCompact = this._emotion.emoji;
+          sections.push({
+            expanded: emotionExpanded,
+            compact: emotionCompact,
+            expandedW: 2 + 1 + this._emotion.label.length,
+            // emoji(2) + space + label
+            compactW: 2,
+            // just emoji
+            empty: false
+          });
         }
-        let speedLabel = "";
         if (this._speedTracker.hasData) {
           const ratio = this._speedTracker.getSpeedRatio();
           if (ratio > 0) {
             const ratioStr = ratio >= 10 ? `${Math.round(ratio)}x` : `${ratio.toFixed(1)}x`;
             const ratioColor = ratio >= 2 ? c2.green : ratio >= 1 ? c2.yellow : c2.red;
-            speedLabel = pipe + pastel2(218, "Exp: ") + ratioColor(c2.bold(ratioStr));
+            const speedExpanded = pastel2(218, "Exp: ") + ratioColor(c2.bold(ratioStr));
+            sections.push({
+              expanded: speedExpanded,
+              compact: speedExpanded,
+              expandedW: 5 + ratioStr.length,
+              compactW: 5 + ratioStr.length,
+              empty: false
+            });
           }
         }
-        let recordingLabel = "";
+        if (m.hasPricing && m.estimatedCost !== void 0) {
+          const costStr = m.estimatedCost < 0.01 ? `$${m.estimatedCost.toFixed(4)}` : m.estimatedCost < 1 ? `$${m.estimatedCost.toFixed(3)}` : `$${m.estimatedCost.toFixed(2)}`;
+          const costExpanded = pastel2(222, "Cost: ") + c2.bold(costStr);
+          const costCompact = pastel2(222, "") + c2.bold(costStr);
+          sections.push({
+            expanded: costExpanded,
+            compact: costCompact,
+            expandedW: 6 + costStr.length,
+            compactW: costStr.length,
+            empty: false
+          });
+        }
+        if (this._modelName) {
+          const capParts = [];
+          if (this._caps.vision)
+            capParts.push("\u{1F441}");
+          if (this._caps.toolUse)
+            capParts.push("\u{1F527}");
+          if (this._caps.thinking)
+            capParts.push("\u{1F9E0}");
+          const capsStr = capParts.length > 0 ? " " + capParts.join(" ") : "";
+          const capsVisW = capParts.length > 0 ? 1 + capParts.length * 2 + (capParts.length - 1) : 0;
+          const paramMatch = this._modelName.match(/(\d+\.?\d*[bBmM])/);
+          const paramStr = paramMatch ? paramMatch[1] : this._modelName.split(":")[0]?.split("/").pop() ?? this._modelName;
+          const modelExpanded = pastel2(146, this._modelName) + (capsStr ? pastel2(60, " ") + pastel2(183, capParts.join(" ")) : "");
+          const modelCompact = pastel2(146, paramStr) + (capsStr ? pastel2(60, " ") + pastel2(183, capParts.join(" ")) : "");
+          sections.push({
+            expanded: modelExpanded,
+            compact: modelCompact,
+            expandedW: this._modelName.length + capsVisW,
+            compactW: paramStr.length + capsVisW,
+            empty: false
+          });
+        } else {
+          const capParts = [];
+          if (this._caps.vision)
+            capParts.push("\u{1F441}");
+          if (this._caps.toolUse)
+            capParts.push("\u{1F527}");
+          if (this._caps.thinking)
+            capParts.push("\u{1F9E0}");
+          if (capParts.length > 0) {
+            const capsStr = pastel2(183, capParts.join(" "));
+            const capsVisW = capParts.length * 2 + (capParts.length - 1);
+            sections.push({ expanded: capsStr, compact: capsStr, expandedW: capsVisW, compactW: capsVisW, empty: false });
+          }
+        }
+        if (this._expose) {
+          const statusEmoji = this._expose.status === "active" ? "\u{1F7E2}" : this._expose.status === "error" ? "\u{1F534}" : "\u{1F7E0}";
+          const models = Array.from(this._expose.modelUsage.keys());
+          const modelParams = models.map((mdl) => {
+            const pm = mdl.match(/(\d+[bBmM])/);
+            return pm ? pm[1] : mdl.split(":")[0]?.split("/").pop() ?? mdl;
+          });
+          const modelStr = modelParams.join(",");
+          const reqStr = this._expose.totalRequests > 0 ? ` ${this._expose.totalRequests}req` : "";
+          const connStr = this._expose.activeConnections > 0 ? ` ${this._expose.activeConnections}conn` : "";
+          const exposeExpanded = statusEmoji + pastel2(183, (modelStr ? " " + modelStr : "") + reqStr + connStr);
+          const exposeCompact = statusEmoji + (modelStr ? pastel2(183, " " + modelStr) : "");
+          const expFullStr = (modelStr ? " " + modelStr : "") + reqStr + connStr;
+          const expCompStr = modelStr ? " " + modelStr : "";
+          sections.push({
+            expanded: exposeExpanded,
+            compact: exposeCompact,
+            expandedW: 2 + expFullStr.length,
+            // emoji(2) + text
+            compactW: 2 + expCompStr.length,
+            empty: false
+          });
+        }
         if (this._recording) {
           const dot = this._recBlink ? pastel2(210, "\u25CF") : " ";
           const countdown = this._countdown > 0 ? c2.dim(` ${this._countdown}s`) : "";
-          recordingLabel = pipe + dot + pastel2(210, " REC") + countdown;
-        }
-        const modelLabel = this._modelName ? pipe + pastel2(146, this._modelName) : "";
-        const capParts = [];
-        if (this._caps.vision)
-          capParts.push("\u{1F441}");
-        if (this._caps.toolUse)
-          capParts.push("\u{1F527}");
-        if (this._caps.thinking)
-          capParts.push("\u{1F9E0}");
-        const capsLabel = capParts.length > 0 ? pipe + pastel2(183, capParts.join(" ")) : "";
-        return ` ${tokInLabel}${pipe}${tokOutLabel}${pipe}${ctxLabel}${snrLabel}${emotionLabel}${speedLabel}${costLabel}${modelLabel}${capsLabel}${recordingLabel}`;
+          const recStr = dot + pastel2(210, " REC") + countdown;
+          const recW = 1 + 4 + (this._countdown > 0 ? 1 + `${this._countdown}s`.length : 0);
+          sections.push({ expanded: recStr, compact: recStr, expandedW: recW, compactW: recW, empty: false });
+        }
+        const activeIndices = sections.map((s, i) => !s.empty ? i : -1).filter((i) => i >= 0);
+        const isCompact = new Array(sections.length).fill(false);
+        const calcTotalWidth = () => {
+          let w = 1;
+          for (let j = 0; j < activeIndices.length; j++) {
+            const idx = activeIndices[j];
+            const sec = sections[idx];
+            if (j > 0)
+              w += pipeW;
+            w += isCompact[idx] ? sec.compactW : sec.expandedW;
+          }
+          return w;
+        };
+        let totalW = calcTotalWidth();
+        for (let j = activeIndices.length - 1; j >= 0 && totalW > termWidth; j--) {
+          const idx = activeIndices[j];
+          if (!isCompact[idx] && sections[idx].compactW < sections[idx].expandedW) {
+            isCompact[idx] = true;
+            totalW = calcTotalWidth();
+          }
+        }
+        for (let j = 0; j < activeIndices.length; j++) {
+          const idx = activeIndices[j];
+          if (isCompact[idx]) {
+            const savings = sections[idx].expandedW - sections[idx].compactW;
+            if (totalW + savings <= termWidth) {
+              isCompact[idx] = false;
+              totalW += savings;
+            } else {
+              break;
+            }
+          }
+        }
+        let result = " ";
+        for (let j = 0; j < activeIndices.length; j++) {
+          const idx = activeIndices[j];
+          if (j > 0)
+            result += pipe;
+          result += isCompact[idx] ? sections[idx].compact : sections[idx].expanded;
+        }
+        return result;
       }
       // -------------------------------------------------------------------------
       // Private
@@ -35119,6 +35665,7 @@ async function startInteractive(config, repoPath) {
   });
   const voiceEngine = new VoiceEngine();
   let voiceSession = null;
+  let exposeGateway = null;
   let adminSessionKey = null;
   const callSubAgents = /* @__PURE__ */ new Map();
   const streamRenderer = new StreamRenderer();
@@ -35279,6 +35826,7 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
     "/pause",
     "/stop",
     "/resume",
+    "/expose",
     "/full-send-bless",
     "/bless",
     "/telegram",
@@ -35290,9 +35838,26 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
   ];
   const discoveredSkillNames = discoverSkills(repoRoot).map((s) => `/${s.name}`);
   const allCompletions = [.../* @__PURE__ */ new Set([...BUILTIN_COMMANDS, ...discoveredSkillNames])].sort();
+  let cachedModelNames = [];
+  function refreshModelCache() {
+    fetchModels(config.backendUrl, config.apiKey).then((models) => {
+      cachedModelNames = models.map((m) => m.name);
+    }).catch(() => {
+    });
+  }
+  refreshModelCache();
   function completer(line) {
     if (!line.startsWith("/"))
       return [[], line];
+    const modelMatch = line.match(/^\/model\s+(.*)$/i);
+    if (modelMatch) {
+      const partial = modelMatch[1].toLowerCase();
+      const hits2 = cachedModelNames.filter((n) => n.toLowerCase().startsWith(partial));
+      if (hits2.length === 0 && partial.length > 0) {
+        return [[modelMatch[1]], modelMatch[1]];
+      }
+      return [hits2, modelMatch[1]];
+    }
     const lower = line.toLowerCase();
     const hits = allCompletions.filter((c3) => c3.toLowerCase().startsWith(lower));
     return [hits, line];
@@ -35948,6 +36513,55 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
     getCallUrl() {
       return voiceSession?.tunnelUrl ?? null;
     },
+    async exposeStart(kindOrUrl, authKey) {
+      const knownKinds = ["ollama", "vllm", "llvm"];
+      let kind;
+      let targetUrl;
+      if (knownKinds.includes(kindOrUrl)) {
+        kind = kindOrUrl;
+      } else {
+        kind = "custom";
+        targetUrl = kindOrUrl.includes("://") ? kindOrUrl : `http://${kindOrUrl}`;
+      }
+      exposeGateway = new ExposeGateway({ kind, targetUrl, authKey });
+      exposeGateway.on("stats", (stats) => {
+        statusBar.setExposeStatus({
+          status: stats.status,
+          totalRequests: stats.totalRequests,
+          activeConnections: stats.activeConnections,
+          modelUsage: stats.modelUsage
+        });
+      });
+      try {
+        const url = await exposeGateway.start();
+        writeContent(() => {
+          process.stdout.write("\n" + exposeGateway.formatConnectionInfo() + "\n\n");
+        });
+        return url;
+      } catch (err) {
+        exposeGateway = null;
+        throw err;
+      }
+    },
+    async exposeStop() {
+      if (exposeGateway) {
+        await exposeGateway.stop();
+        statusBar.clearExposeStatus();
+        exposeGateway = null;
+      }
+    },
+    isExposeActive() {
+      return exposeGateway?.isActive ?? false;
+    },
+    getExposeInfo() {
+      if (!exposeGateway)
+        return null;
+      return {
+        tunnelUrl: exposeGateway.tunnelUrl,
+        authKey: exposeGateway.authKey,
+        stats: exposeGateway.formatStats()
+      };
+    },
     async sendCallButton(chatId, url) {
       if (telegramBridge?.isActive) {
         await telegramBridge.sendCallButton(chatId, url);
@@ -35965,6 +36579,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       resolvedCaps = caps;
       statusBar.setCapabilities(caps);
     },
+    refreshModelCache,
     hasActiveTask: () => activeTask !== null,
     requestCompaction(strategy) {
       if (!activeTask)
@@ -36613,6 +37228,10 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
     showPrompt();
   }
   rl.on("close", () => {
+    if (exposeGateway?.isActive) {
+      exposeGateway.stop().catch(() => {
+      });
+    }
     statusBar.deactivate();
     const closeRows = process.stdout.rows ?? 24;
     process.stdout.write(`\x1B[${closeRows - 4};1H\x1B[J
@@ -36701,6 +37320,7 @@ var init_interactive = __esm({
     init_dist();
     init_listen();
     init_voice_session();
+    init_expose();
     init_call_agent();
     init_config();
     init_updater();
@@ -37364,7 +37984,7 @@ var serve_exports = {};
 __export(serve_exports, {
   serveCommand: () => serveCommand
 });
-import { spawn as spawn12 } from "node:child_process";
+import { spawn as spawn13 } from "node:child_process";
 async function serveCommand(opts, config) {
   const backendType = config.backendType;
   if (backendType === "ollama") {
@@ -37457,7 +38077,7 @@ async function serveVllm(opts, config) {
 }
 async function runVllmServer(args, verbose) {
   return new Promise((resolve28, reject) => {
-    const child = spawn12("python", args, {
+    const child = spawn13("python", args, {
       stdio: verbose ? "inherit" : ["ignore", "pipe", "pipe"],
       env: { ...process.env }
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.65.0",
+  "version": "0.67.0",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",