@fudrouter/fsrouter 0.6.64 → 0.6.66

package/open-sse/rtk/filters/gitLog.js

@@ -0,0 +1,99 @@
+// JS-native git-log filter
+// Compresses `git log` output: keeps commit headers, subjects, Author/Date;
+// drops body padding, decoration, embedded diff lines.
+import { GIT_LOG_MAX_LINES } from "../constants.js";
+
+export function gitLog(text, maxLines = GIT_LOG_MAX_LINES) {
+  if (!text) return "";
+
+  const input = String(text);
+  const lines = input.split("\n");
+  const out = [];
+  let skipped = 0;
+  let inCommit = false;
+  let subjectSeen = false;
+
+  function pushLine(l) {
+    if (out.length < maxLines) {
+      out.push(l);
+      return true;
+    }
+    skipped++;
+    return false;
+  }
+
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    const line = raw.trimEnd();
+    const trimmed = line.trim();
+
+    // commit <sha> header — starts new commit entry
+    // Also matched with leading graph decoration (`*   commit abc1234...` — --graph without --oneline)
+    if (/^commit [0-9a-f]{7,40}$/i.test(trimmed) || /^[*|/\\ ]+commit [0-9a-f]{7,40}/i.test(trimmed)) {
+      inCommit = true;
+      subjectSeen = false;
+      pushLine(line);
+      continue;
+    }
+
+    if (inCommit) {
+      // Author / Date — keep as-is (already column 0 in raw, or graph-prefix stripped by commit-header match)
+      if (/^[*|/\\ ]*(Author|Date):/i.test(trimmed)) {
+        pushLine(trimmed);
+        continue;
+      }
+      // blank — skip
+      if (trimmed === "") continue;
+      // indented subject (4 spaces, optionally preceded by graph decoration) — first one is subject
+      if (!subjectSeen && /^[*|/\\ ]*    \S/.test(line)) {
+        pushLine("  Subject: " + trimmed);
+        subjectSeen = true;
+        continue;
+      }
+      // stat summary: "N file(s) changed, N insertions(+), N deletions(-)"
+      if (/^\d+ file\w* changed/.test(trimmed)) {
+        pushLine("  " + trimmed);
+        continue;
+      }
+      // embedded diff header — one-line marker
+      if (/^diff --git /.test(trimmed)) {
+        pushLine("  ... diff body omitted");
+        continue;
+      }
+      // everything else in commit body — drop
+      continue;
+    }
+
+    // Not in a commit block (--oneline / --graph modes):
+
+    // Graph decoration + sha + subject: "*|/\\ <sha7> <subject>"
+    const graphMatch = trimmed.match(/^[*|/\\ ]+([0-9a-f]{7,40}\s+.+)/i);
+    if (graphMatch) {
+      pushLine(graphMatch[1]);
+      continue;
+    }
+
+    // Plain oneline: "<sha7> <subject>"
+    if (/^[0-9a-f]{7,40}\s+/.test(trimmed)) {
+      pushLine(trimmed);
+      continue;
+    }
+
+    // Pure graph decoration (no sha) — drop
+    if (/^[*|/\\ ]+$/.test(trimmed) && /[*|/\\]/.test(trimmed)) {
+      continue;
+    }
+
+    // catch-all pass-through
+    pushLine(trimmed);
+  }
+
+  if (skipped > 0) out.push(`... (${skipped} more lines)`);
+
+  const result = out.join("\n");
+  if (!result && input) return input;
+  if (result.length > input.length) return input;
+  return result;
+}
+
+gitLog.filterName = "git-log";

package/open-sse/rtk/filters/gitStatus.js

@@ -0,0 +1,117 @@
+// Port of git::format_status_output (rtk/src/cmds/git/git.rs:619-730)
+// Output format:
+//   * <branch>
+//   + Staged: N files
+//      path1
+//      ... +K more
+//   ~ Modified: N files
+//   ? Untracked: N files
+//   conflicts: N files
+//   clean — nothing to commit
+import { STATUS_MAX_FILES, STATUS_MAX_UNTRACKED } from "../constants.js";
+
+export function gitStatus(input) {
+  const lines = input.split("\n");
+  if (lines.length === 0 || (lines.length === 1 && !lines[0].trim())) {
+    return "Clean working tree";
+  }
+
+  let branch = "";
+  const stagedFiles = [];
+  const modifiedFiles = [];
+  const untrackedFiles = [];
+  let staged = 0;
+  let modified = 0;
+  let untracked = 0;
+  let conflicts = 0;
+
+  for (const raw of lines) {
+    if (!raw.trim()) continue;
+
+    // Long-form branch detection (LLM usually sends this, not porcelain)
+    const longBranch = raw.match(/^On branch (\S+)/);
+    if (longBranch) { branch = longBranch[1]; continue; }
+
+    // Porcelain branch header: "## main...origin/main"
+    if (raw.startsWith("##")) { branch = raw.replace(/^##\s*/, ""); continue; }
+
+    // Porcelain status (2 chars + space + path)
+    if (raw.length >= 3 && /^[ MADRCU?!][ MADRCU?!] /.test(raw)) {
+      const x = raw[0];
+      const y = raw[1];
+      const file = raw.slice(3);
+
+      if (raw.slice(0, 2) === "??") {
+        untracked++;
+        untrackedFiles.push(file);
+        continue;
+      }
+
+      if ("MADRC".includes(x)) {
+        staged++;
+        stagedFiles.push(file);
+      } else if (x === "U") {
+        conflicts++;
+      }
+
+      if (y === "M" || y === "D") {
+        modified++;
+        modifiedFiles.push(file);
+      }
+      continue;
+    }
+
+    // Long form fallback ("modified:   path", "new file:   path", ...)
+    const longMatch = raw.match(/^\s*(modified|new file|deleted|renamed|both modified):\s+(.+)$/);
+    if (longMatch) {
+      const kind = longMatch[1];
+      const path = longMatch[2].trim();
+      if (kind === "both modified") { conflicts++; }
+      else if (kind === "modified" || kind === "deleted") { modified++; modifiedFiles.push(path); }
+      else if (kind === "new file" || kind === "renamed") { staged++; stagedFiles.push(path); }
+      continue;
+    }
+
+    // "Untracked files:" section — gather bare paths after this marker
+    // Handled implicitly: plain paths without markers are skipped (safer).
+  }
+
+  let out = "";
+  if (branch) out += `* ${branch}\n`;
+
+  if (staged > 0) {
+    out += `+ Staged: ${staged} files\n`;
+    for (const f of stagedFiles.slice(0, STATUS_MAX_FILES)) out += `   ${f}\n`;
+    if (stagedFiles.length > STATUS_MAX_FILES) {
+      out += `   ... +${stagedFiles.length - STATUS_MAX_FILES} more\n`;
+    }
+  }
+
+  if (modified > 0) {
+    out += `~ Modified: ${modified} files\n`;
+    for (const f of modifiedFiles.slice(0, STATUS_MAX_FILES)) out += `   ${f}\n`;
+    if (modifiedFiles.length > STATUS_MAX_FILES) {
+      out += `   ... +${modifiedFiles.length - STATUS_MAX_FILES} more\n`;
+    }
+  }
+
+  if (untracked > 0) {
+    out += `? Untracked: ${untracked} files\n`;
+    for (const f of untrackedFiles.slice(0, STATUS_MAX_UNTRACKED)) out += `   ${f}\n`;
+    if (untrackedFiles.length > STATUS_MAX_UNTRACKED) {
+      out += `   ... +${untrackedFiles.length - STATUS_MAX_UNTRACKED} more\n`;
+    }
+  }
+
+  if (conflicts > 0) {
+    out += `conflicts: ${conflicts} files\n`;
+  }
+
+  if (staged === 0 && modified === 0 && untracked === 0 && conflicts === 0) {
+    out += "clean — nothing to commit\n";
+  }
+
+  return out.replace(/\n+$/, "");
+}
+
+gitStatus.filterName = "git-status";

package/open-sse/rtk/filters/grep.js

@@ -0,0 +1,48 @@
+// Port of grep_wrapper (rtk/src/cmds/system/pipe_cmd.rs:50-86)
+// Input format: "file:lineno:content" — splitn(3, ':') in Rust
+import { GREP_PER_FILE_MAX } from "../constants.js";
+
+export function grep(input) {
+  const byFile = new Map();
+  let total = 0;
+
+  for (const line of input.split("\n")) {
+    // splitn(3, ':') — only split on first 2 colons
+    const first = line.indexOf(":");
+    if (first === -1) continue;
+    const second = line.indexOf(":", first + 1);
+    if (second === -1) continue;
+    const file = line.slice(0, first);
+    const lineNumStr = line.slice(first + 1, second);
+    const content = line.slice(second + 1);
+    // Rust: parts[1].parse::<usize>().is_ok()
+    if (!/^\d+$/.test(lineNumStr)) continue;
+    total++;
+    if (!byFile.has(file)) byFile.set(file, []);
+    byFile.get(file).push([lineNumStr, content]);
+  }
+
+  if (total === 0) return input;
+
+  // Rust: files.sort_by_key(|(f, _)| *f)
+  const files = Array.from(byFile.keys()).sort();
+  let out = `${total} matches in ${files.length}F:\n\n`;
+
+  for (const file of files) {
+    const matches = byFile.get(file);
+    out += `[file] ${file} (${matches.length}):\n`;
+    const show = matches.slice(0, GREP_PER_FILE_MAX);
+    for (const [lineNum, content] of show) {
+      // Rust: format!("  {:>4}: {}", line_num, content.trim())
+      out += `  ${lineNum.padStart(4)}: ${content.trim()}\n`;
+    }
+    if (matches.length > GREP_PER_FILE_MAX) {
+      out += `  +${matches.length - GREP_PER_FILE_MAX}\n`;
+    }
+    out += "\n";
+  }
+
+  return out;
+}
+
+grep.filterName = "grep";

package/open-sse/rtk/filters/ls.js

@@ -0,0 +1,79 @@
+// Port of compact_ls (rtk/src/cmds/system/ls.rs:154-232)
+// Input: `ls -la` style output. Output: compact "name/  (dirs)\nname  size"
+import { LS_EXT_SUMMARY_TOP, LS_NOISE_DIRS } from "../constants.js";
+
+// Rust LS_DATE_RE: month + day + (year|HH:MM)
+const LS_DATE_RE = /\s+(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+\d{1,2}\s+(\d{4}|\d{2}:\d{2})\s+/;
+
+function humanSize(bytes) {
+  if (bytes >= 1_048_576) return `${(bytes / 1_048_576).toFixed(1)}M`;
+  if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)}K`;
+  return `${bytes}B`;
+}
+
+function parseLsLine(line) {
+  const m = LS_DATE_RE.exec(line);
+  if (!m) return null;
+  const name = line.slice(m.index + m[0].length);
+  const beforeDate = line.slice(0, m.index);
+  const beforeParts = beforeDate.split(/\s+/).filter(Boolean);
+  if (beforeParts.length < 4) return null;
+
+  const perms = beforeParts[0];
+  const fileType = perms.charAt(0);
+
+  // size = rightmost parseable number before the date
+  let size = 0;
+  for (let i = beforeParts.length - 1; i >= 0; i--) {
+    const n = Number(beforeParts[i]);
+    if (Number.isInteger(n) && String(n) === beforeParts[i]) { size = n; break; }
+  }
+  return { fileType, size, name };
+}
+
+export function ls(input) {
+  const dirs = [];
+  const files = [];      // [name, sizeStr]
+  const byExt = new Map();
+
+  for (const line of input.split("\n")) {
+    if (line.startsWith("total ") || line.length === 0) continue;
+    const parsed = parseLsLine(line);
+    if (!parsed) continue;
+    if (parsed.name === "." || parsed.name === "..") continue;
+
+    // Rust ls.rs: show_all flag respected — for LLM context always skip noise
+    if (LS_NOISE_DIRS.includes(parsed.name)) continue;
+
+    if (parsed.fileType === "d") {
+      dirs.push(parsed.name);
+    } else if (parsed.fileType === "-" || parsed.fileType === "l") {
+      const dot = parsed.name.lastIndexOf(".");
+      const ext = dot > 0 ? parsed.name.slice(dot) : "no ext";
+      byExt.set(ext, (byExt.get(ext) || 0) + 1);
+      files.push([parsed.name, humanSize(parsed.size)]);
+    }
+  }
+
+  if (dirs.length === 0 && files.length === 0) return input;
+
+  let out = "";
+  for (const d of dirs) out += `${d}/\n`;
+  for (const [name, size] of files) out += `${name}  ${size}\n`;
+
+  // Summary line (Rust port)
+  let summary = `\nSummary: ${files.length} files, ${dirs.length} dirs`;
+  if (byExt.size > 0) {
+    const ext = Array.from(byExt.entries()).sort((a, b) => b[1] - a[1]);
+    const parts = ext.slice(0, LS_EXT_SUMMARY_TOP).map(([e, c]) => `${c} ${e}`);
+    summary += ` (${parts.join(", ")}`;
+    if (ext.length > LS_EXT_SUMMARY_TOP) {
+      summary += `, +${ext.length - LS_EXT_SUMMARY_TOP} more`;
+    }
+    summary += ")";
+  }
+
+  return out + summary;
+}
+
+ls.filterName = "ls";

package/open-sse/rtk/filters/readNumbered.js

@@ -0,0 +1,27 @@
+// Handles Cursor/Codex read_file output: "  1|content\n  2|content".
+// Strategy mirrors Rust filter::smart_truncate (filter.rs): keep head+tail, drop middle.
+import { SMART_TRUNCATE_HEAD, SMART_TRUNCATE_TAIL, SMART_TRUNCATE_MIN_LINES } from "../constants.js";
+
+const LINE_RE = /^\s*\d+\|/;
+
+export function readNumbered(input) {
+  const lines = input.split("\n");
+  if (lines.length < SMART_TRUNCATE_MIN_LINES) return input;
+
+  // Count how many lines match "N|content" to verify shape (hit ratio check
+  // already done by autodetect; here we just truncate).
+  const head = lines.slice(0, SMART_TRUNCATE_HEAD);
+  const tail = lines.slice(lines.length - SMART_TRUNCATE_TAIL);
+  const cut = lines.length - head.length - tail.length;
+
+  return [
+    ...head,
+    `... +${cut} lines truncated (file continues)`,
+    ...tail
+  ].join("\n");
+}
+
+readNumbered.filterName = "read-numbered";
+
+// Exposed for autodetect
+export const READ_NUMBERED_LINE_RE = LINE_RE;

package/open-sse/rtk/filters/searchList.js

@@ -0,0 +1,52 @@
+// Compact "Result of search in '...' (total N files):\n- path\n- path" output
+// (Cursor Glob tool). Groups by parent dir like find, shows basenames.
+import { SEARCH_LIST_PER_DIR_MAX, SEARCH_LIST_TOTAL_DIR_MAX } from "../constants.js";
+
+const HEADER_RE = /^Result of search in '[^']*' \(total (\d+) files?\):/;
+
+export function searchList(input) {
+  const lines = input.split("\n");
+  if (lines.length === 0) return input;
+
+  // First line must be the header (validated by autodetect too)
+  const header = lines[0] || "";
+  const rest = lines.slice(1);
+
+  const paths = [];
+  for (const raw of rest) {
+    const t = raw.trim();
+    if (!t.startsWith("- ")) continue;
+    paths.push(t.slice(2));
+  }
+  if (paths.length === 0) return input;
+
+  const byDir = new Map();
+  for (const p of paths) {
+    const slash = p.lastIndexOf("/");
+    const dir = slash === -1 ? "." : (p.slice(0, slash) || "/");
+    const name = slash === -1 ? p : p.slice(slash + 1);
+    if (!byDir.has(dir)) byDir.set(dir, []);
+    byDir.get(dir).push(name);
+  }
+
+  const dirs = Array.from(byDir.keys()).sort();
+  let out = `${header}\n${paths.length} files in ${dirs.length} dirs:\n\n`;
+
+  for (const dir of dirs.slice(0, SEARCH_LIST_TOTAL_DIR_MAX)) {
+    const names = byDir.get(dir);
+    out += `${dir}/ (${names.length}):\n`;
+    for (const n of names.slice(0, SEARCH_LIST_PER_DIR_MAX)) out += `  ${n}\n`;
+    if (names.length > SEARCH_LIST_PER_DIR_MAX) {
+      out += `  +${names.length - SEARCH_LIST_PER_DIR_MAX}\n`;
+    }
+    out += "\n";
+  }
+  if (dirs.length > SEARCH_LIST_TOTAL_DIR_MAX) {
+    out += `+${dirs.length - SEARCH_LIST_TOTAL_DIR_MAX} more dirs\n`;
+  }
+
+  return out.replace(/\n+$/, "");
+}
+
+searchList.filterName = "search-list";
+export const SEARCH_LIST_HEADER_RE = HEADER_RE;

package/open-sse/rtk/filters/smartTruncate.js

@@ -0,0 +1,15 @@
+// Port concept of filter::smart_truncate (rtk/src/core/filter.rs).
+// Keep HEAD + TAIL lines, replace middle with "... +N lines truncated".
+import { SMART_TRUNCATE_HEAD, SMART_TRUNCATE_TAIL, SMART_TRUNCATE_MIN_LINES } from "../constants.js";
+
+export function smartTruncate(input) {
+  const lines = input.split("\n");
+  if (lines.length < SMART_TRUNCATE_MIN_LINES) return input;
+
+  const head = lines.slice(0, SMART_TRUNCATE_HEAD);
+  const tail = lines.slice(lines.length - SMART_TRUNCATE_TAIL);
+  const cut = lines.length - head.length - tail.length;
+  return [...head, `... +${cut} lines truncated`, ...tail].join("\n");
+}
+
+smartTruncate.filterName = "smart-truncate";

package/open-sse/rtk/filters/tree.js

@@ -0,0 +1,32 @@
+// Port of filter_tree_output (rtk/src/cmds/system/tree.rs:65-94)
+// Removes summary line (e.g. "5 directories, 23 files") and trailing blanks.
+import { TREE_MAX_LINES } from "../constants.js";
+
+export function tree(input) {
+  const lines = input.split("\n");
+  if (lines.length === 0) return input;
+
+  const filtered = [];
+  for (const line of lines) {
+    // Drop "X directories, Y files" summary
+    if (line.includes("director") && line.includes("file")) continue;
+    // Drop leading blanks
+    if (line.trim() === "" && filtered.length === 0) continue;
+    filtered.push(line);
+  }
+
+  // Drop trailing blanks
+  while (filtered.length > 0 && filtered[filtered.length - 1].trim() === "") {
+    filtered.pop();
+  }
+
+  // Cap overly long trees (JS-only safeguard; Rust has no cap)
+  if (filtered.length > TREE_MAX_LINES) {
+    const cut = filtered.length - TREE_MAX_LINES;
+    return filtered.slice(0, TREE_MAX_LINES).join("\n") + `\n... +${cut} more lines`;
+  }
+
+  return filtered.join("\n");
+}
+
+tree.filterName = "tree";

package/open-sse/rtk/headroom.js

@@ -0,0 +1,215 @@
+import { claudeToOpenAIRequest } from "../translator/request/claude-to-openai.js";
+import { openaiToClaudeRequest } from "../translator/request/openai-to-claude.js";
+import {
+  openaiResponsesToOpenAIRequest,
+  openaiToOpenAIResponsesRequest,
+} from "../translator/request/openai-responses.js";
+
+const DEFAULT_TIMEOUT_MS = 3000;
+
+function jsonBytes(value) {
+  try {
+    return new TextEncoder().encode(JSON.stringify(value) || "").length;
+  } catch {
+    return 0;
+  }
+}
+
+function messagePayload(body) {
+  if (Array.isArray(body?.messages)) return body.messages;
+  if (Array.isArray(body?.input)) return body.input;
+  return null;
+}
+
+function captureSizeSnapshot(body) {
+  const messages = messagePayload(body);
+  return {
+    bodyBytes: jsonBytes(body),
+    messageBytes: messages ? jsonBytes(messages) : 0,
+  };
+}
+
+function setDiagnostic(diagnostics, reason) {
+  if (diagnostics && !diagnostics.reason) diagnostics.reason = reason;
+}
+
+function scrubSensitiveUrlText(text) {
+  return String(text)
+    .replace(/\/\/[^/@\s]+@/g, "//")
+    .replace(/(https?:\/\/[^\s?#]+)[?#][^\s)]*/g, "$1");
+}
+
+function describeFetchError(error) {
+  const cause = error?.cause;
+  const code = cause?.code || error?.code;
+  const message = scrubSensitiveUrlText(cause?.message || error?.message || String(error));
+  return code ? `${code}: ${message}` : message;
+}
+
+function buildCompressEndpoint(url) {
+  try {
+    const parsed = new URL(url);
+    parsed.pathname = `${parsed.pathname.replace(/\/$/, "")}/v1/compress`;
+    parsed.hash = "";
+    return parsed.toString();
+  } catch {
+    const raw = String(url).replace(/#.*$/, "");
+    const [base, query = ""] = raw.split("?", 2);
+    const endpoint = `${base.replace(/\/$/, "")}/v1/compress`;
+    return query ? `${endpoint}?${query}` : endpoint;
+  }
+}
+
+function maskEndpoint(endpoint) {
+  try {
+    const parsed = new URL(endpoint);
+    parsed.username = "";
+    parsed.password = "";
+    parsed.search = "";
+    parsed.hash = "";
+    return parsed.toString();
+  } catch {
+    return String(endpoint).replace(/\/\/[^/@\s]+@/, "//").replace(/[?#].*$/, "");
+  }
+}
+
+function hasUnsafeResponsesInputForCompression(body) {
+  if (!Array.isArray(body?.input)) return false;
+  return body.input.some((item) => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return false;
+    return typeof item.type === "string" && item.type !== "message";
+  });
+}
+
+// POST messages to Headroom /v1/compress; returns compressed messages + stats or null.
+async function callCompress(url, messages, model, timeoutMs, compressUserMessages, diagnostics) {
+  const endpoint = buildCompressEndpoint(url);
+  diagnostics.endpoint = maskEndpoint(endpoint);
+  const payload = { messages, model };
+  if (compressUserMessages) payload.config = { compress_user_messages: true };
+  let res;
+  try {
+    res = await fetch(endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+  } catch (error) {
+    setDiagnostic(diagnostics, `request failed: ${describeFetchError(error)}`);
+    return null;
+  }
+  if (!res.ok) {
+    setDiagnostic(diagnostics, `proxy returned HTTP ${res.status}`);
+    return null;
+  }
+  const data = await res.json();
+  if (!Array.isArray(data?.messages)) {
+    setDiagnostic(diagnostics, "proxy response missing messages[]");
+    return null;
+  }
+  return data;
+}
+
+// Compress request body via Headroom proxy. Fail-open: returns null on any error.
+// /v1/compress only understands OpenAI shape, so Claude bodies are translated
+// to OpenAI, compressed, then translated back using 9Router's own translators.
+export async function compressWithHeadroom(body, { enabled, url, model, format, compressUserMessages, timeoutMs = DEFAULT_TIMEOUT_MS, diagnostics = null } = {}) {
+  if (!enabled) {
+    setDiagnostic(diagnostics, "disabled");
+    return null;
+  }
+  if (!url) {
+    setDiagnostic(diagnostics, "missing proxy URL");
+    return null;
+  }
+  if (!body) {
+    setDiagnostic(diagnostics, "missing request body");
+    return null;
+  }
+
+  try {
+    if (diagnostics) diagnostics.before = captureSizeSnapshot(body);
+
+    // Claude shape: translate → OpenAI → compress → translate back.
+    if (format === "claude") {
+      const oai = claudeToOpenAIRequest(model, body, false);
+      if (!Array.isArray(oai?.messages)) {
+        setDiagnostic(diagnostics, "Claude request did not translate to messages[]");
+        return null;
+      }
+      const data = await callCompress(url, oai.messages, model, timeoutMs, compressUserMessages, diagnostics || {});
+      if (!data) return null;
+      const claudeBody = openaiToClaudeRequest(model, { ...oai, messages: data.messages }, false);
+      if (Array.isArray(claudeBody?.messages)) body.messages = claudeBody.messages;
+      if (claudeBody?.system !== undefined) body.system = claudeBody.system;
+      if (diagnostics) diagnostics.after = captureSizeSnapshot(body);
+      return data;
+    }
+
+    // OpenAI Responses shape (Codex): body.input holds Responses items, NOT OpenAI
+    // messages. Translate input -> OpenAI -> compress -> translate back to input so
+    // body.input keeps the Responses contract (the proxy only understands OpenAI). (#1998)
+    if (format === "openai-responses") {
+      if (hasUnsafeResponsesInputForCompression(body)) {
+        setDiagnostic(diagnostics, "skipped: openai-responses tool/reasoning input is not safe to compress");
+        return null;
+      }
+      const oai = openaiResponsesToOpenAIRequest(model, body, false);
+      if (!Array.isArray(oai?.messages)) return null;
+      const data = await callCompress(url, oai.messages, model, timeoutMs, compressUserMessages, diagnostics || {});
+      if (!data) return null;
+      // input: undefined so the translator rebuilds input from the compressed
+      // messages instead of returning the original input unchanged.
+      const responsesBody = openaiToOpenAIResponsesRequest(
+        model,
+        { ...oai, input: undefined, messages: data.messages },
+        false
+      );
+      if (Array.isArray(responsesBody?.input)) body.input = responsesBody.input;
+      if (diagnostics) diagnostics.after = captureSizeSnapshot(body);
+      return data;
+    }
+
+    // OpenAI shape: messages/input go straight to the proxy.
+    const key = Array.isArray(body.messages) ? "messages"
+      : Array.isArray(body.input) ? "input"
+      : null;
+    if (!key) {
+      setDiagnostic(diagnostics, `unsupported ${format || "unknown"} request shape`);
+      return null;
+    }
+    const data = await callCompress(url, body[key], model, timeoutMs, compressUserMessages, diagnostics || {});
+    if (!data) return null;
+    body[key] = data.messages;
+    if (diagnostics) diagnostics.after = captureSizeSnapshot(body);
+    return data;
+  } catch (error) {
+    setDiagnostic(diagnostics, `unexpected error: ${error?.message || String(error)}`);
+    return null;
+  }
+}
+
+export function formatHeadroomLog(stats) {
+  if (!stats) return null;
+  const before = stats.tokens_before || 0;
+  const after = stats.tokens_after || 0;
+  const delta = stats.tokens_saved || 0;
+  const pct = before > 0 ? ((delta / before) * 100).toFixed(1) : "0";
+  return `reported token delta=${delta} before=${before}${after ? ` after=${after}` : ""} (${pct}%)`.trim();
+}
+
+export function formatHeadroomSizeLog(diagnostics) {
+  const before = diagnostics?.before;
+  const after = diagnostics?.after;
+  if (!before || !after) return "";
+  return `body=${before.bodyBytes}B→${after.bodyBytes}B messages=${before.messageBytes}B→${after.messageBytes}B`;
+}
+
+export function isHeadroomPhantomSavings(stats, diagnostics, minShrinkRatio = 0.05) {
+  if (!stats?.tokens_saved || stats.tokens_saved <= 0) return false;
+  const before = diagnostics?.before?.bodyBytes || 0;
+  const after = diagnostics?.after?.bodyBytes || 0;
+  if (before <= 0 || after <= 0) return false;
+  return after >= before * (1 - minShrinkRatio);
+}