llm-switcher 1.6.5 → 1.6.6

package/maintenance/gateway-upstream-watch/watch.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+"""Read public upstream evidence; leave interpretation and alerts to Hermes. Stdlib only."""
+import argparse
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime, timedelta, timezone
+import hashlib
+from html.parser import HTMLParser
+import json
+import os
+from pathlib import Path
+import re
+import subprocess
+import tempfile
+import urllib.error
+import urllib.parse
+import urllib.request
+import xml.etree.ElementTree as ET
+
+MAX_BYTES = 4 * 1024 * 1024
+TOPICS = re.compile(r"compac|responses|codex|claude|gemini|tool|strict|schema|stream|sse|websocket|context|catalog|signature|thinking|proxy|oauth|retry|429|failover|gateway|provider|certificate|multimodal|image|resume", re.I)
+
+
+def github_token():
+    token = os.environ.get("GH_TOKEN") or os.environ.get("GITHUB_TOKEN")
+    if token:
+        return token
+    # Reuse the VPS's existing GitHub credential in memory, only for api.github.com.
+    # Verify the checkout origin first; never print helper output or persist the credential.
+    checkout = Path("/opt/zencore")
+    if not checkout.is_dir():
+        return None
+    env = {**os.environ, "GIT_TERMINAL_PROMPT": "0", "GCM_INTERACTIVE": "never"}
+    try:
+        origin = subprocess.run(["git", "remote", "get-url", "origin"], cwd=checkout, env=env, capture_output=True, text=True, timeout=10, check=True).stdout.strip()
+        if origin != "https://github.com/louisphamdev/zencore.git":
+            return None
+        result = subprocess.run(["git", "credential", "fill"], cwd=checkout, env=env, capture_output=True, text=True, timeout=10,
+                                input="protocol=https\nhost=github.com\npath=louisphamdev/zencore.git\n\n", check=True)
+        fields = dict(line.split("=", 1) for line in result.stdout.splitlines() if "=" in line)
+        return fields.get("password") or None
+    except (OSError, subprocess.SubprocessError):
+        return None
+
+
+def atomic_json(path, value):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", dir=path.parent, delete=False) as f:
+        json.dump(value, f, ensure_ascii=False, indent=2)
+        f.write("\n")
+        temporary = f.name
+    os.replace(temporary, path)
+
+
+def read_json(path, default):
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except FileNotFoundError:
+        return default
+
+
+def fetch(url, token=None):
+    headers = {"User-Agent": "Hermes-gateway-upstream-watch/1", "Accept": "application/json" if url.startswith("https://api.github.com/") else "*/*"}
+    if token and url.startswith("https://api.github.com/"):
+        headers["Authorization"] = f"Bearer {token}"
+    req = urllib.request.Request(url, headers=headers)
+    with urllib.request.urlopen(req, timeout=20) as response:
+        data = response.read(MAX_BYTES + 1)
+        if len(data) > MAX_BYTES:
+            raise RuntimeError("source exceeds 4 MiB evidence limit")
+        return data, dict(response.headers)
+
+
+def atom_entries(data):
+    ns = {"a": "http://www.w3.org/2005/Atom"}
+    root = ET.fromstring(data)
+    entries = []
+    for item in root.findall("a:entry", ns):
+        link = next((x.get("href") for x in item.findall("a:link", ns) if x.get("rel", "alternate") == "alternate"), None)
+        entries.append({"id": item.findtext("a:id", "", ns), "title": item.findtext("a:title", "", ns).strip(),
+                        "updated_at": item.findtext("a:updated", "", ns), "url": link})
+    return entries
+
+
+class PageText(HTMLParser):
+    def __init__(self):
+        super().__init__()
+        self.skip = 0
+        self.parts = []
+
+    def handle_starttag(self, tag, attrs):
+        if tag in ("script", "style"):
+            self.skip += 1
+
+    def handle_endtag(self, tag):
+        if tag in ("script", "style") and self.skip:
+            self.skip -= 1
+
+    def handle_data(self, data):
+        if not self.skip and data.strip():
+            self.parts.append(data.strip())
+
+
+def scan_repo(repo, since, prior, token):
+    name = repo["repo"]
+    result = {"repo": name, "group": repo["group"], "since": since, "sources": {}, "errors": [], "issues": [], "commits": [], "releases": []}
+    complete = True
+    # Atom feeds avoid spending GitHub API quota on public releases/commits.
+    for kind, url in [("releases", f"https://github.com/{name}/releases.atom"),
+                      ("commits", f"https://github.com/{name}/commits/{urllib.parse.quote(repo['branch'], safe='')}.atom")]:
+        try:
+            raw, _ = fetch(url)
+            items = atom_entries(raw)
+            seen = set(prior.get(kind, []))
+            result[kind] = [x for x in items if x["id"] not in seen]
+            result["sources"][kind] = {"ok": True, "url": url, "ids": [x["id"] for x in items], "scope": "latest feed entries; older entries require source review"}
+        except Exception as error:
+            try:
+                endpoint = f"https://api.github.com/repos/{name}/releases?per_page=30" if kind == "releases" else f"https://api.github.com/repos/{name}/commits?" + urllib.parse.urlencode({"sha": repo["branch"], "per_page": 30})
+                raw, _ = fetch(endpoint, token)
+                values = json.loads(raw)
+                if not isinstance(values, list):
+                    raise RuntimeError("unexpected fallback API response")
+                items = [{"id": str(x.get("id") or x.get("sha")), "title": x.get("name") or x.get("tag_name") or x.get("commit", {}).get("message", "").split("\n")[0],
+                          "updated_at": x.get("published_at") or x.get("commit", {}).get("committer", {}).get("date"), "url": x.get("html_url")} for x in values]
+                seen = set(prior.get(kind, []))
+                result[kind] = [x for x in items if x["id"] not in seen]
+                result["sources"][kind] = {"ok": True, "url": endpoint, "ids": [x["id"] for x in items], "fallback": True, "scope": "latest 30 entries; older entries require source review"}
+            except Exception as fallback_error:
+                complete = False
+                result["sources"][kind] = {"ok": False, "url": url}
+                result["errors"].append(f"{kind}: {type(fallback_error).__name__}: {fallback_error}")
+    try:
+        rows = []
+        max_pages = 50 if token else 2
+        for page in range(1, max_pages + 1):
+            query = urllib.parse.urlencode({"state": "all", "sort": "updated", "direction": "desc", "since": since, "per_page": 100, "page": page})
+            raw, headers = fetch(f"https://api.github.com/repos/{name}/issues?{query}", token)
+            batch = json.loads(raw)
+            if not isinstance(batch, list):
+                raise RuntimeError("unexpected GitHub issue response")
+            rows.extend(batch)
+            if len(batch) < 100:
+                break
+        partial = len(batch) == 100
+        result["sources"]["issues"] = {"ok": True, "partial": partial, "fetched": len(rows), "quota_remaining": headers.get("X-RateLimit-Remaining", headers.get("x-ratelimit-remaining"))}
+        complete = complete and not partial
+        # Retain every fetched title and status. Mark topics to help review without discarding evidence.
+        result["issues"] = [{"number": x["number"], "title": x["title"], "state": x["state"], "updated_at": x["updated_at"],
+                             "url": x["html_url"], "pr": "pull_request" in x, "comments": x.get("comments", 0),
+                             "topic_match": bool(TOPICS.search(x["title"]))} for x in rows]
+        if partial:
+            result["errors"].append(f"issues: {max_pages * 100}-entry cap reached; older changes remain unscanned, checkpoint not advanced")
+    except Exception as error:
+        complete = False
+        result["sources"]["issues"] = {"ok": False}
+        result["errors"].append(f"issues: {type(error).__name__}: {error}")
+    result["complete"] = complete
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    default_home = Path(os.environ.get("HERMES_HOME", str(Path.home() / ".hermes")))
+    parser.add_argument("--manifest", type=Path, default=default_home / "skills/devops/gateway-upstream-watch/references/repos.json")
+    parser.add_argument("--state-dir", type=Path, default=default_home / "gateway-upstream-watch")
+    parser.add_argument("--only", help="one repository for a bounded smoke check")
+    parser.add_argument("--no-checkpoint", action="store_true", help="probe without advancing persistent scan state")
+    args = parser.parse_args()
+    manifest = read_json(args.manifest, None)
+    if manifest is None:
+        raise RuntimeError("verified repository manifest is missing")
+    state_path = args.state_dir / "scan-state.json"
+    state = read_json(state_path, {"repos": {}, "docs": {}})
+    now = datetime.now(timezone.utc)
+    token = github_token()
+    repos = [r for r in manifest["repos"] if not args.only or r["repo"] == args.only]
+    if not repos:
+        raise RuntimeError("requested repository is not in the verified manifest")
+    report = {"checked_at": now.isoformat(), "authenticated_github": bool(token), "requested_repos": len(repos), "repos": [], "docs": [],
+              "review_required": True, "scope": "GitHub issue metadata plus latest release/commit feeds; the agent must read source/diffs for conclusions"}
+    with ThreadPoolExecutor(max_workers=3) as pool:
+        tasks = {}
+        for repo in repos:
+            prior = state["repos"].get(repo["repo"], {})
+            checkpoint = prior.get("checkpoint")
+            since = (datetime.fromisoformat(checkpoint) - timedelta(hours=2) if checkpoint else now - timedelta(days=2)).isoformat()
+            tasks[pool.submit(scan_repo, repo, since, prior, token)] = repo
+        for task in as_completed(tasks):
+            result = task.result()
+            report["repos"].append(result)
+            prior = state["repos"].setdefault(result["repo"], {})
+            if result["complete"]:
+                prior["checkpoint"] = now.isoformat()
+            for kind in ("commits", "releases"):
+                if result["sources"][kind]["ok"]:
+                    prior[kind] = result["sources"][kind]["ids"]
+    if not args.only:
+        for url in manifest["docs"]:
+            try:
+                raw, _ = fetch(url)
+                page = PageText()
+                page.feed(raw.decode("utf-8", errors="replace"))
+                digest = hashlib.sha256(" ".join(page.parts).encode()).hexdigest()
+                old = state["docs"].get(url)
+                report["docs"].append({"url": url, "ok": True, "changed": old != digest, "first_check": old is None, "hash": digest})
+                state["docs"][url] = digest
+            except Exception as error:
+                report["docs"].append({"url": url, "ok": False, "error": f"{type(error).__name__}: {error}"})
+    report["repos"].sort(key=lambda x: x["repo"])
+    report["complete_repos"] = sum(r["complete"] for r in report["repos"])
+    report["partial"] = report["complete_repos"] != len(repos) or any(not d["ok"] for d in report["docs"])
+    target = args.state_dir / "evidence" / f"{now.strftime('%Y-%m-%dT%H-%M-%S')}.json"
+    atomic_json(target, report)
+    atomic_json(args.state_dir / "latest.json", report)
+    if not args.no_checkpoint:
+        atomic_json(state_path, state)
+    print(json.dumps({"evidence_file": str(target), "requested_repos": len(repos), "complete_repos": report["complete_repos"], "partial": report["partial"],
+                      "instruction": "Read the evidence JSON and gateway-upstream-watch skill. Report incomplete sources explicitly; metadata alone is not a verified fix."}, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-switcher",
-  "version": "1.6.5",
+  "version": "1.6.6",
   "description": "Zero-dependency multi-protocol edge gateway & provider switcher for Claude Code and Codex, with OpenAI-compatible, Anthropic and Vertex upstreams",
   "keywords": [
     "llm",

package/proxy.mjs

@@ -27,7 +27,9 @@ import {
   contractLabSettings, STATE_DIR, stopRecordedBlindfold
 } from './state.mjs';
 import { parseModelWindows, resolveProfileWindows, readLocalCodexWindows } from './windows.mjs';
-import { createToolVocab, NULL_TOOL_VOCAB } from './toolvocab.mjs';
+import { createToolVocab, NULL_TOOL_VOCAB, toolNameMapForIR } from './toolvocab.mjs';
+import { readUpstreamPayloads } from './upstream-stream.mjs';
+import { compactionResponse, emitCompaction, expandGatewayCompactions, collectCompaction } from './compaction.mjs';
 import { classifyCodexRole, classifyClaudeTier, syncLocalCatalog, refreshCatalog, checkVersionAndRefresh } from './catalog.mjs';
 import { checkForUpdate } from './version.mjs';
 import { applyUpdate } from './update.mjs';
@@ -454,53 +456,13 @@ function upstreamEndpoint(profile, outFormat, model, stream, req) {
   return { url: ov['openai-chat'] || `${base}/chat/completions`, headers };
 }
 
-// Read the upstream stream: accept both SSE `data:` and raw JSON lines (Vertex framing).
-async function* readUpstreamPayloads(upstreamRes) {
-  const reader = upstreamRes.body.getReader();
-  const decoder = new TextDecoder('utf8');
-  let buffer = '';
-  let finished = false;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
-        finished = true;
-        break;
-      }
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split('\n');
-      buffer = lines.pop();
-      for (const line of lines) {
-        const parsed = parsePayloadLine(line);
-        if (parsed) yield parsed;
-      }
-    }
-    buffer += decoder.decode();
-    const tail = parsePayloadLine(buffer);
-    if (tail) yield tail;
-  } finally {
-    // A consumer that stops early (an in-band error) must close the upstream connection too.
-    if (!finished) await reader.cancel().catch(() => {});
-    try { reader.releaseLock(); } catch {}
-  }
-}
-
-function parsePayloadLine(line) {
-  let s = line.trim();
-  if (!s) return null;
-  if (s.startsWith('data:')) s = s.slice(5).trim();
-  else if (s.startsWith('event:') || s.startsWith(':') || s.startsWith('id:') || s.startsWith('retry:')) return null;
-  if (!s || s === '[DONE]' || !s.startsWith('{')) return null;
-  try { return JSON.parse(s); } catch { return null; }
-}
-
 // The tool vocabulary the caller declared, so a model that answers with a name from its own
 // training is written back in the caller's words instead of ending the turn with "No such tool
 // available". Built once per request from the tools the caller actually sent, so a request that
 // declared none pays nothing and a turn where the model agreed with the list changes nothing.
-function toolVocabFor(ir) {
+function toolVocabFor(ir, outFormat) {
   if (!ir || typeof ir !== 'object') return NULL_TOOL_VOCAB;
-  if (!ir._vocab) ir._vocab = createToolVocab(ir.tools);
+  if (!ir._vocab) ir._vocab = createToolVocab(ir.tools, { allowHyphens: outFormat !== 'vertex', names: [...toolNameMapForIR(ir).forward.keys()] });
   return ir._vocab;
 }
 
@@ -937,7 +899,7 @@ async function handleConvert(clientFormat, req, res, bodyBuffer, opts = {}) {
 
   let ir;
   try {
-    ir = parseToIR(clientFormat, payload);
+    ir = parseToIR(clientFormat, payload, { allowOpaqueCompaction: true });
   } catch (e) {
     sendClientError(res, clientFormat, 400, `Cannot parse ${clientFormat} request: ${e.message}`);
     return;
@@ -955,7 +917,7 @@ async function handleConvert(clientFormat, req, res, bodyBuffer, opts = {}) {
   const shrunk = await maybeCompactIdle(req, clientFormat, payload, ir, profile, profileKey, bodyBuffer);
   if (shrunk) {
     try {
-      const compactedIR = parseToIR(clientFormat, shrunk.payload);
+      const compactedIR = parseToIR(clientFormat, shrunk.payload, { allowOpaqueCompaction: true });
       payload = shrunk.payload;
       bodyBuffer = shrunk.bodyBuffer;
       ir = compactedIR;
@@ -1008,7 +970,9 @@ async function handleConvert(clientFormat, req, res, bodyBuffer, opts = {}) {
       const headers = bifrostHeaders(req, profile);
       if (traceId) headers['x-intact-trace'] = traceId;
       try {
-        const r = await forwardAnthropicDirect(res, payload, bodyBuffer, bifrostURL(profile, clientFormat, req, opts), headers, mappedModel, ac.signal, profile, true);
+        const nativePayload = clientFormat === 'responses' ? expandGatewayCompactions(payload) : payload;
+        const nativeBytes = nativePayload === payload ? bodyBuffer : Buffer.from(JSON.stringify(nativePayload));
+        const r = await forwardAnthropicDirect(res, nativePayload, nativeBytes, bifrostURL(profile, clientFormat, req, opts), headers, mappedModel, ac.signal, profile, true);
         answered = !r.error && r.status >= 200 && r.status < 300;
         log({ status: r.status, tokens: r.tokens, responsePreview: '(bifrost)', error: r.error || undefined });
       } catch (err) {
@@ -1038,6 +1002,10 @@ async function handleConvert(clientFormat, req, res, bodyBuffer, opts = {}) {
       return;
     }
 
+    if (ir.opaqueCompaction) {
+      sendClientError(res, clientFormat, 400, 'Cannot convert native or legacy compaction state; resume through its original Responses provider.');
+      return log({ status: 400, error: 'unsupported compaction state' });
+    }
     const slot = resolveSlot(requestedModel, mappedModel, profile, clientFormat);
     const { url, headers, upBody } = buildUpstreamRequest(profile, outFormat, ir, mappedModel, req, slot);
     if (traceId) headers['x-intact-trace'] = traceId;
@@ -1063,6 +1031,24 @@ async function handleConvert(clientFormat, req, res, bodyBuffer, opts = {}) {
     const normalize = createUpstreamNormalizer(outFormat);
     const col = createCollector();
 
+    if (ir.compaction) {
+      try {
+        await collectCompaction(upstreamRes, outFormat, ir.stream, normalize, col);
+        if (ac.signal.aborted) return log({ status: 499, error: 'client disconnected' });
+        const response = compactionResponse(col, requestedModel || mappedModel, text => splitThinkTags(text).text);
+        if (ir.stream) {
+          res.writeHead(200, { 'Content-Type': 'text/event-stream; charset=utf-8', 'Cache-Control': 'no-cache', 'X-Accel-Buffering': 'no' });
+          emitCompaction(response, (event, data) => sendSSE(res, event, data)); res.end();
+        } else sendJson(res, 200, response);
+        answered = true;
+        return log({ status: 200, responsePreview: '(compaction)', tokens: { prompt: col.prompt, completion: col.completion() } });
+      } catch (err) {
+        if (ac.signal.aborted) return log({ status: 499, error: 'client disconnected' });
+        sendClientError(res, clientFormat, 502, err.message);
+        return log({ status: 502, error: err.message });
+      }
+    }
+
     // ---- non-stream ----
     if (!ir.stream) {
       let json;
@@ -1085,7 +1071,7 @@ async function handleConvert(clientFormat, req, res, bodyBuffer, opts = {}) {
       const out = clientMessage(clientFormat, {
         model: requestedModel || mappedModel, think, text: [split.text], tools, toolMeta: ir.toolMeta,
         finish: col.finish, prompt: col.prompt, completion, cached: col.cached,
-        reasoning: col.reasoning, sig: col.sig, vocab: toolVocabFor(ir)
+        reasoning: col.reasoning, sig: col.sig, vocab: toolVocabFor(ir, outFormat)
       });
       sendJson(res, 200, out);
       answered = true;
@@ -1102,7 +1088,7 @@ async function handleConvert(clientFormat, req, res, bodyBuffer, opts = {}) {
       'Connection': 'keep-alive',
       'X-Accel-Buffering': 'no'
     });
-    const renderer = clientRenderer(clientFormat, res, requestedModel || mappedModel, { toolMeta: ir.toolMeta, vocab: toolVocabFor(ir) });
+    const renderer = clientRenderer(clientFormat, res, requestedModel || mappedModel, { toolMeta: ir.toolMeta, vocab: toolVocabFor(ir, outFormat) });
     renderer.start();
     const splitter = createThinkTagSplitter(t => renderer.think(t), t => renderer.text(t));
     const streamError = await pumpStream(upstreamRes, { normalize, col, renderer, splitter, signal: ac.signal, sink: res, tag: profileKey });
@@ -2019,7 +2005,7 @@ function sendWsFailed(socket, model, message, status = 500, tap = null, code = n
 // previous_response_id; the server keeps the rest. The gateway keeps it per socket, bounded.
 const WS_HISTORY_MAX = 8;
 // Only these output items are valid input for the next turn; reasoning items are not replayed.
-const WS_REPLAY_TYPES = new Set(['message', 'function_call', 'custom_tool_call', 'local_shell_call']);
+const WS_REPLAY_TYPES = new Set(['message', 'function_call', 'custom_tool_call', 'local_shell_call', 'compaction']);
 
 function wsInputItems(input) {
   if (typeof input === 'string') return input ? [{ type: 'message', role: 'user', content: [{ type: 'input_text', text: input }] }] : [];
@@ -2169,7 +2155,7 @@ async function handleWsResponseCreate(socket, payload, req, ac, history = null)
 
   const bifrostModel = mapModel(payload.model || '', profile, clientFormat);
   if (await crossesBifrost(req, profile, bifrostModel)) {
-    return wsBifrostTurn({ socket, payload, req, ac, history, input, profile, profileKey, mappedModel: bifrostModel });
+    return wsBifrostTurn({ socket, payload: expandGatewayCompactions(payload), req, ac, history, input, profile, profileKey, mappedModel: bifrostModel });
   }
 
   let ir;
@@ -2224,6 +2210,21 @@ async function handleWsResponseCreate(socket, payload, req, ac, history = null)
     const normalize = createUpstreamNormalizer(outFormat);
     const col = createCollector();
 
+    if (ir.compaction) {
+      try {
+        await collectCompaction(upstreamRes, outFormat, true, normalize, col);
+        if (ac.signal.aborted) return log({ status: 499, error: 'client disconnected' });
+        const response = compactionResponse(col, requestedModel || mappedModel, text => splitThinkTags(text).text);
+        emitCompaction(response, (event, data) => { tapWsEvent(halfTap, event, data); if (socket.writable) socket.write(encodeWsFrame(JSON.stringify(data))); });
+        rememberWsTurn(history, response, []); answered = true;
+        return log({ status: 200, responsePreview: '(compaction)', tokens: { prompt: col.prompt, completion: col.completion() } });
+      } catch (err) {
+        if (ac.signal.aborted) return log({ status: 499, error: 'client disconnected' });
+        sendWsFailed(socket, mappedModel, err.message, 502, halfTap);
+        return log({ status: 502, error: err.message });
+      }
+    }
+
     let completedResponse = null;
     const renderer = createResponsesStream((e, d) => {
       tapWsEvent(halfTap, e, d);
@@ -2231,7 +2232,7 @@ async function handleWsResponseCreate(socket, payload, req, ac, history = null)
       if (socket.writable) {
         socket.write(encodeWsFrame(JSON.stringify(d)));
       }
-    }, requestedModel || mappedModel, { toolMeta: ir.toolMeta, vocab: toolVocabFor(ir) });
+    }, requestedModel || mappedModel, { toolMeta: ir.toolMeta, vocab: toolVocabFor(ir, outFormat) });
 
     renderer.start();
     const splitter = createThinkTagSplitter(t => renderer.think(t), t => renderer.text(t));

package/tests/codex-daemon.test.mjs

@@ -12,6 +12,7 @@ import { buildCerts } from '../blindfold/certs.mjs';
 const root = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-codex-daemon-'));
 process.env.HOME = path.join(root, 'home');
 process.env.LLM_SWITCHER_STATE_DIR = path.join(root, 'state');
+process.env.LLM_SWITCHER_BLINDFOLD_CERTS = path.join(root, 'certs');
 delete process.env.CODEX_HOME;
 fs.mkdirSync(process.env.LLM_SWITCHER_STATE_DIR, { recursive: true });
 const { restartCodexDaemon, applyLaunchState, clearLaunchState, emptyToolEnvFiles, computeLaunchState, STATE_DIR, INTERCEPT_HOSTS, usableCACertificate } = await import('../state.mjs');

package/tests/compaction.e2e.test.mjs

@@ -0,0 +1,79 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import http from 'node:http';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { openResponsesWs } from './ws-client.mjs';
+const root = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const listen = server => new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+async function until(check) { const deadline = Date.now() + 6000; while (Date.now() < deadline) { if (await check()) return; await new Promise(r => setTimeout(r, 20)); } throw new Error('timeout'); }
+async function fixture(t) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-compaction-'));
+  const received = []; let finish = 'stop', truncate = false;
+  const up = http.createServer((req, res) => {
+    let raw = ''; req.on('data', b => raw += b); req.on('end', () => {
+      if (req.method === 'GET') return res.end('{"data":[]}');
+      const body = JSON.parse(raw); received.push(body);
+      const summary = 'KEEP_DECISION_7391';
+      if (body.stream) {
+        res.setHeader('content-type', 'text/event-stream');
+        res.write(`data: {"choices":\ndata: [{"index":0,"delta":{"content":"${summary}"}}]}\n\n`);
+        if (!truncate) res.write(`data: {"choices":[{"index":0,"delta":{},"finish_reason":"${finish}"}]}\n\ndata: [DONE]\n\n`);
+        res.end();
+      } else { res.setHeader('content-type', 'application/json'); res.end(JSON.stringify({ choices: [{ message: { content: summary }, finish_reason: finish }] })); }
+    });
+  }); await listen(up);
+  const reserve = http.createServer(); await listen(reserve); const port = reserve.address().port; await new Promise(r => reserve.close(r));
+  const config = path.join(dir, 'config.json'); fs.writeFileSync(config, JSON.stringify({ port, profiles: {
+    p1: { name: 'Offline', mode: 'convert', outFormat: 'openai-chat', baseURL: `http://127.0.0.1:${up.address().port}/v1`, apiKey: 'fixture-only' }
+  } }));
+  const child = spawn(process.execPath, [path.join(root, 'proxy.mjs')], { env: { ...process.env,
+    LLM_SWITCHER_CONFIG: config, LLM_SWITCHER_STATE_DIR: dir, LLM_SWITCHER_PORT: '', LLM_SWITCHER_REGISTRY_URL: 'http://127.0.0.1:9/' }, stdio: ['ignore', 'pipe', 'pipe'] });
+  let logs = ''; child.stdout.on('data', b => logs += b); child.stderr.on('data', b => logs += b);
+  t.after(async () => {
+    if (child.exitCode === null) { const done = new Promise(r => child.once('exit', r)); child.kill(); await done; }
+    up.closeAllConnections?.(); await new Promise(r => up.close(r));
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+  await until(async () => (await fetch(`http://127.0.0.1:${port}/health`).catch(() => null))?.ok);
+  const send = body => fetch(`http://127.0.0.1:${port}/v1/responses`, { method: 'POST', headers: { 'content-type': 'application/json', 'x-profile': 'p1' }, body: JSON.stringify(body) });
+  return { port, received, send, failure: (reason, cut = false) => { finish = reason; truncate = cut; }, logs: () => logs };
+}
+const trigger = stream => ({ model: 'm', stream, input: [{ role: 'user', content: 'ORIGINAL_HISTORY' }, { type: 'compaction_trigger' }] });
+const events = text => text.split('\n').filter(l => l.startsWith('data: {')).map(l => JSON.parse(l.slice(6)));
+
+test('HTTP compaction produces one item, replays it, and can compact the replay again', { timeout: 20000 }, async t => {
+  const f = await fixture(t);
+  for (const stream of [false, true]) {
+    const first = await f.send(trigger(stream)); assert.equal(first.status, 200, f.logs());
+    const response = stream ? events(await first.text()).find(e => e.type === 'response.completed').response : await first.json();
+    assert.equal(response.output.length, 1); assert.equal(response.output[0].type, 'compaction');
+    const replay = await f.send({ model: 'm', input: [response.output[0], { role: 'user', content: 'continue' }] });
+    assert.equal(replay.status, 200, await replay.text());
+    assert.match(JSON.stringify(f.received.at(-1).messages), /KEEP_DECISION_7391.*continue/);
+    const again = await f.send({ ...trigger(false), input: [response.output[0], { type: 'compaction_trigger' }] });
+    assert.equal(again.status, 200, await again.text());
+    assert.match(JSON.stringify(f.received.at(-1).messages), /KEEP_DECISION_7391/);
+    assert.doesNotMatch(JSON.stringify(f.received.at(-1)), /encrypted_content|compaction_trigger/);
+  }
+});
+test('HTTP compaction rejects token-limit and prematurely ended summaries', { timeout: 20000 }, async t => {
+  const f = await fixture(t);
+  f.failure('length'); assert.equal((await f.send(trigger(false))).status, 502);
+  f.failure('stop', true); const r = await f.send(trigger(true)); assert.equal(r.status, 502);
+  assert.doesNotMatch(await r.text(), /encrypted_content/);
+});
+test('WS compaction replays the compacted state through previous_response_id', { timeout: 20000 }, async t => {
+  const f = await fixture(t); const ws = await openResponsesWs(f.port, { 'x-profile': 'p1' }); t.after(ws.close);
+  ws.send({ type: 'response.create', ...trigger(true) });
+  await until(() => ws.messages.some(m => ['response.completed', 'response.failed'].includes(m.type)));
+  const completed = ws.messages.find(m => m.type === 'response.completed'); assert.ok(completed, JSON.stringify(ws.messages));
+  assert.equal(ws.messages.filter(m => m.type === 'response.output_item.done' && m.item.type === 'compaction').length, 1);
+  ws.send({ type: 'response.create', model: 'm', previous_response_id: completed.response.id, input: [{ role: 'user', content: 'NEXT_TURN' }] });
+  await until(() => f.received.length === 2);
+  assert.match(JSON.stringify(f.received.at(-1).messages), /KEEP_DECISION_7391.*NEXT_TURN/);
+  assert.doesNotMatch(JSON.stringify(f.received.at(-1).messages), /ORIGINAL_HISTORY/);
+});

package/tests/gateway-contract.test.mjs

@@ -0,0 +1,59 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { anthropicToIR, responsesToIR, irToChatBody, irToVertexBody, irToAnthropicBody } from '../formats.mjs';
+import { createToolVocab } from '../toolvocab.mjs';
+
+const prefix = 'llm-gateway-compact-v1:';
+const compact = summary => ({ type: 'compaction', encrypted_content: prefix + Buffer.from(JSON.stringify({ summary })).toString('base64url') });
+
+test('converted Responses replays gateway compaction and refuses unknown ciphertext', () => {
+  const body = irToChatBody(responsesToIR({ input: [compact('KEEP_DECISION'), { role: 'user', content: 'continue' }] }), 'm');
+  assert.match(JSON.stringify(body.messages), /KEEP_DECISION/);
+  assert.doesNotMatch(JSON.stringify(body.messages), /llm-gateway-compact/);
+  assert.throws(() => responsesToIR({ input: [{ type: 'compaction', encrypted_content: 'opaque-native-ciphertext' }] }), /compaction/i);
+});
+
+test('explicit true and false strict survive Responses to Chat', () => {
+  for (const strict of [true, false]) {
+    const ir = responsesToIR({ input: 'go', tools: [{ type: 'function', name: 'f', strict,
+      parameters: { type: 'object', properties: { x: { type: 'string' } }, required: ['x'], additionalProperties: false } }] });
+    assert.equal(irToChatBody(ir, 'm').tools[0].function.strict, strict);
+  }
+});
+
+test('Vertex tool names remain unique and reverse to the correct declaration, history and choice', () => {
+  const names = ['mcp__server-a__read', 'mcp__server_a__read'];
+  for (const order of [names, [...names].reverse()]) {
+    const ir = anthropicToIR({ tools: order.map(name => ({ name, input_schema: { type: 'object' } })), tool_choice: { type: 'tool', name: names[0] },
+      messages: [{ role: 'assistant', content: names.map((name, i) => ({ type: 'tool_use', id: `c${i}`, name, input: {} })) },
+        { role: 'user', content: names.map((_, i) => ({ type: 'tool_result', tool_use_id: `c${i}`, content: 'ok' })) }] });
+    const body = irToVertexBody(ir, 'gemini-2.5-pro');
+    const emitted = body.tools[0].functionDeclarations.map(t => t.name);
+    assert.equal(new Set(emitted).size, 2);
+    const vocab = createToolVocab(ir.tools, { allowHyphens: false });
+    assert.deepEqual(emitted.map(n => vocab.name(n)), order);
+    const calls = body.contents.find(c => c.role === 'model').parts.map(p => p.functionCall.name);
+    assert.deepEqual(calls.map(n => vocab.name(n)), names);
+    assert.equal(vocab.name(body.toolConfig.functionCallingConfig.allowedFunctionNames[0]), names[0]);
+    assert.equal(emitted[order.indexOf(names[1])], names[1], 'valid original stays reserved');
+  }
+});
+
+test('tool-result image reaches Chat, Anthropic and Vertex without becoming text', () => {
+  const ir = anthropicToIR({ messages: [
+    { role: 'assistant', content: [{ type: 'tool_use', id: 'image-call', name: 'screen', input: {} }] },
+    { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'image-call', content: [
+      { type: 'text', text: 'screenshot' }, { type: 'image', source: { type: 'base64', media_type: 'image/png', data: 'iVBORw0KGgo=' } }
+    ] }] }
+  ] });
+  const chat = irToChatBody(ir, 'm');
+  const tool = chat.messages.find(m => m.role === 'tool');
+  assert.equal(tool.content, 'screenshot');
+  const image = chat.messages.find(m => m.role === 'user' && Array.isArray(m.content));
+  assert.equal(image.content.find(p => p.type === 'image_url').image_url.url, 'data:image/png;base64,iVBORw0KGgo=');
+  const anthropic = irToAnthropicBody(ir, 'm');
+  assert.equal(anthropic.messages.at(-1).content[0].content[1].source.data, 'iVBORw0KGgo=');
+  const vertex = irToVertexBody(ir, 'gemini-2.5-pro');
+  assert.match(JSON.stringify(vertex.contents), /"inlineData":\{"mimeType":"image\/png","data":"iVBORw0KGgo="\}/);
+  assert.doesNotMatch(tool.content, /omitted|base64/);
+});

package/tests/gateway.e2e.test.mjs

@@ -95,6 +95,19 @@ function startUpstream() {
         return res.end(JSON.stringify({ id: 'c1', object: 'chat.completion', model: json.model, choices: [{ index: 0, message: { role: 'assistant', content: 'converted ok' }, finish_reason: 'stop' }], usage: { prompt_tokens: 1, completion_tokens: 1 } }));
       }
       if (req.url.startsWith('/chat/v1/chat/completions')) {
+        if (lastUser.includes('TOOL_ALIAS_REPLAY')) {
+          const reference = json.messages.find(m => m.role === 'tool');
+          const name = JSON.parse(reference.content).tool_name;
+          if (!json.tools.some(t => t.function.name === name)) {
+            return sse(res, [{ error: { message: `upstream called undeclared tool '${name}'`, type: 'server_error' } }]);
+          }
+          return sse(res, [
+            { choices: [{ index: 0, delta: { tool_calls: [{ index: 0, id: 'console1', type: 'function', function: { name, arguments: '{"pageSize":0}' } }] } }] },
+            { choices: [{ index: 0, delta: { tool_calls: [{ index: 1, id: 'search2', type: 'function', function: { name: 'ToolSearch', arguments: '{"query":"select:' } }] } }] },
+            { choices: [{ index: 0, delta: { tool_calls: [{ index: 1, function: { arguments: `${name}","max_results":5}` } }] } }] },
+            { choices: [{ index: 0, delta: {}, finish_reason: 'tool_calls' }], usage: { prompt_tokens: 10, completion_tokens: 15 } }
+          ], { raw: ['data: [DONE]\n\n'] });
+        }
         if (lastUser.includes('RATE_LIMIT')) {
           res.writeHead(429, { 'Content-Type': 'application/json', 'retry-after': '7' });
           return res.end(JSON.stringify({ error: { message: 'slow down' } }));
@@ -650,6 +663,40 @@ test('Bifrost stays off for a model that is not a Claude Code account', async ()
   assert.equal(received.at(-1).url, '/intact/v1/chat/completions');
 });
 
+test('ToolSearch replay calls declared upstream aliases and restores original tool names and queries to Claude', async () => {
+  const name = 'mcp__plugin_chrome-devtools-mcp_chrome-devtools__list_console_messages';
+  const res = await post('/v1/messages', {
+    model: 'claude-opus-4-6', max_tokens: 256, stream: true, system: `Use ${name} to inspect errors.`,
+    tools: [
+      { name: 'ToolSearch', input_schema: { type: 'object', properties: { query: { type: 'string' }, max_results: { type: 'integer' } } } },
+      { name, input_schema: { type: 'object', properties: { pageSize: { type: 'integer' } } } }
+    ],
+    messages: [
+      { role: 'user', content: 'Inspect errors.' },
+      { role: 'assistant', content: [{ type: 'tool_use', id: 'search1', name: 'ToolSearch', input: { query: `select:${name}` } }] },
+      { role: 'user', content: [
+        { type: 'tool_result', tool_use_id: 'search1', content: [{ type: 'tool_reference', tool_name: name }] },
+        { type: 'text', text: 'TOOL_ALIAS_REPLAY' }
+      ] }
+    ]
+  });
+  assert.equal(res.status, 200);
+  const events = parseSSE(await res.text());
+  assertValidAnthropicEvents(events);
+  assert.ok(events.some(e => e.event === 'message_stop'));
+  assert.ok(!events.some(e => e.event === 'error'));
+  const starts = events.filter(e => e.data?.content_block?.type === 'tool_use');
+  assert.deepEqual(starts.map(e => e.data.content_block.name), [name, 'ToolSearch']);
+  const args = start => JSON.parse(events.filter(e => e.data?.index === start.data.index && e.data?.delta?.type === 'input_json_delta').map(e => e.data.delta.partial_json).join(''));
+  assert.deepEqual(args(starts[0]), { pageSize: 0 });
+  assert.deepEqual(args(starts[1]), { query: `select:${name}`, max_results: 5 });
+  const up = received.at(-1).body;
+  const alias = up.tools.find(t => t.function.name !== 'ToolSearch').function.name;
+  assert.equal(alias.length, 64);
+  assert.ok(!JSON.stringify(up.messages).includes(name));
+  assert.equal(JSON.parse(up.messages.find(m => m.tool_calls).tool_calls[0].function.arguments).query, `select:${alias}`);
+});
+
 test('Bifrost stays off for a client that is not Claude Code', async () => {
   await post('/v1/messages', { model: 'claude-opus-4-6', max_tokens: 10, messages: [{ role: 'user', content: 'hi' }] },
     { 'x-llm-profile': 'intactcc', 'user-agent': 'some-sdk/1.0' });