billion-context

Universal context-compression proxy for AI coding agents
Any agent that can set a base URL — zero per-agent adapter code.

npm install -g billion-context

billion-context sits between any agent and its model API, rewriting Anthropic/OpenAI streams with acp-kernel compression. The model decides when and what to compress into high-fidelity summaries — not a hard truncation limit.

Why

Long coding sessions blow up context. Each provider charges per token, and once you pass the context window the session degrades or dies. billion-context compresses consumed conversation into layered summaries so you can run a single session for days — billions of tokens through one context window.

Unlike a host's built-in summarizer, compression here is incremental, reversible, and prefix-cache friendly: summaries are written in small ranges, can be decompressed on demand, and the cache prefix stays intact.

How it works

Agent (Claude Code / Codex / Cursor / Aider ...)
        │  you point the agent's base URL at the proxy
        ▼
┌─────────────────┐
│  billion-context│   1. parse the request (Anthropic or OpenAI shape)
│     proxy       │   2. run acp-kernel compression on the conversation
│                 │   3. inject a `compress` tool + compression philosophy
│                 │   4. forward to the real model API
│                 │   5. rewrite the streaming response
└─────────────────┘
        │
        ▼
   real model API (Anthropic / OpenAI / compatible)

The proxy injects four context-management tools (compress, decompress, search_context, acp_status) into the conversation. The model calls compress when the conversation grows, and the proxy executes it server-side — the compressed ranges are folded into the conversation history before the next turn.

An opt-in fifth tool, absorb (compress.absorb.enabled: true — see CONFIGURATION.md), compresses individual tool results the moment they arrive: large results (builds, logs, greps) get a forced absorb instruction, the model distills each into a compact summary, and the original pair is hidden from the wire from the next turn on — keeping mid-session pressure lower between fold rounds (#605).

Two compression modes — who executes `compress`

The proxy runs in one of two modes, and the mode decides who executes compress, which in turn decides how the summary travels to the model (the "carrier"). This distinction is the root of #377.

	Launcher / plugin mode (`bili pi`, `bili codex`, …)	Proxy mode (plain client → `/bili/`)
Client	ACP-native agent with the bili extension (pi/omp)	Any OpenAI/Anthropic client, no extension
Who executes `compress`	The agent (pi runs it locally)	The proxy (server-side compress loop)
`compress` tool call in the re-sent history?	Yes — part of the agent's own conversation	No — ephemeral proxy-loop traffic
Preflight blocks (no tool call)?	Last-resort backstop — the agent normally compresses on its own `compress` calls, but `src/preflight.ts` still fires (in both modes) when the input alone exceeds the window (#470)	Yes — `src/preflight.ts` compresses behind the client's back
Summary carrier on the wire	the `compress` tool call	an `acp_summary` user message
System messages on the wire	always exactly 1 (client + prompt)	always exactly 1 (client + prompt) — summaries ride on user messages
SGLang "single system" 400 (#377)	cannot happen	cannot happen (summaries are user messages, not system)
Proxy-injected `compress` tools	none — the agent registers the 4 ACP tools natively	the 4 context tools (when enabled)
Proxy-injected nudge	yes — the agent has no nudge channel of its own, so the proxy-side nudge is the proactive compression trigger (preflight alone only fires at the hard limit; #451)	yes (when enabled)

Why the carriers differ. In plugin mode the agent owns compression: the compress call + result live in the agent's own history and are re-sent every turn, so the summary rides on the tool call and the agent's view never renders the kernel's acp_summary fallback (billion-context-pi src/messages.ts skips acp_summary_*). In proxy mode the client is not ACP-native, so the proxy executes compress server-side; the tool call never enters the client's history, and preflight blocks have no tool call at all — so the kernel's acp_summary message is the only carrier. The kernel renders it as role system, but strict OpenAI-compatible backends (SGLang) require exactly one system message at index 0, so systemToUser (src/util.ts) re-voices it as a user message, leaving it at its anchor position. This keeps the head system message (the prefix-cache anchor) byte-stable across compress turns, so a new block does not invalidate the whole-conversation prefix.

Why user, not system or a forged tool call. A mid-stream system message is what SGLang rejects (#377). A forged compress tool call would be the "pure" carrier, but in proxy mode it requires fabricating an assistant tool_calls + user tool_result pair by id, declaring the tool in the request, and handling preflight blocks that have no authentic call — far more invasive than re-voicing a standalone note. A user message is allowed anywhere in the conversation, so it is the minimal change that satisfies both SGLang's one-system rule and prefix-cache stability. The accepted trade-off: a summary is a stand-in for the folded history, and re-voicing it as a user turn is a semantic mismatch the model tolerates (it is clearly marked [Compressed conversation section]).

Do the two modes coexist?

Same proxy instance: yes, by design. One proxy serves plugin and plain clients at once; pluginMode is decided per request (x-bili-plugin header) and bound per session (session.metadata.pluginAgent). The launcher reuses a running proxy.
Same session: the mode is sticky. A session created in plugin mode stays plugin mode (metadata inheritance); a plain session can only be upgraded to plugin mode if a plugin request arrives with a matching conversation id (the header outranks) — and never downgraded. In practice a plain→plugin upgrade requires the plugin client's conversation id to match an existing plain session id, which doesn't happen (each client generates its own id).
Cross-mode block hazard: theoretical only. It would require the same conversation id to span a mode switch. plugin→proxy is safe (the tool call is in the shared history); proxy→plugin could orphan proxy-created block summaries (their tool call isn't in the agent's history and the agent's view skips acp_summary) — but that needs the id match above, which doesn't occur.

Which do I need?

Pick by your client:

Client	Use
pi	`billion-context-pi` (in-process extension)
opencode	`opencode-acp` (in-process extension)
omp	`billion-context` via `bili omp` (built-in plugin)
everything else (no context hook)	`billion-context` — `bili <client>` (launcher, preferred) or `/bili/` prefix

Install

npm install -g billion-context

This installs the bili command (bili-proxy is kept as an alias).

Quickstart

Two ways to use it — pick one:

Launcher (easiest): one bili <client> command brings up the proxy and the client together — no real config file is ever touched.
URL change (persistent): prefix your client's baseURL with the proxy origin + /bili/.

Injection priority — no files unless unavoidable (#535)

bili never owns user data: every launched client runs on its real home, so runtime writes land where the user expects them. When pointing a client at the proxy, the launcher picks by priority — env vars first (proxy/CA envs for hermes/dsh/codex; the BILI_PROVIDER_REWRITES URL manifest for pi/omp, consumed by their extension's registerProvider at load), then CLI flags or extension APIs (codex -c key=value, opencode plugin), and generated files last — today only opencode's temp opencode.json (deleted on exit) and dsh's loopback exception: dsh's fetch stack bypasses proxy envs for loopback targets unconditionally, so local upstreams keep the persistent ~/.dsh-bili overlay rewrite until dsh gains a settings-path env or an upstream loopback opt-out. Overlay dirs created by older versions are left in place and never merged back into the real home.

Option 1 — Launcher (`bili pi` / `bili codex` / `bili claude` / `bili omp` / `bili opencode` / `bili hermes` / `bili dsh`)

The launcher wraps a client in one command: it starts a proxy on an independent port (a fresh instance is always spawned — a port is never reused), then points the client at it — certificate-based MITM where the client honors proxy/CA env vars, or an isolated /bili/ config rewrite where it doesn't. No real config file is ever edited; the client's own config is READ to discover which HTTPS upstream hosts it talks to, and those hosts are whitelisted for MITM so the proxy can TLS-terminate exactly them and blind-tunnel everything else.

bili pi                               # launch pi through the proxy — file-free (#535): env + extension registerProvider, real ~/.pi untouched
bili codex                            # launch codex through the proxy
bili claude                           # launch claude through the proxy
bili omp                              # pi-style, file-free (#535): env + extension registerProvider + compaction cancel, real ~/.omp untouched
bili opencode                         # MITM for HTTPS + temp opencode.json (/bili/ for HTTP) + thin /acp plugin
bili hermes                           # file-free (#535): hermes proxy env (HTTPS_PROXY + HERMES_CA_BUNDLE) — https via CONNECT MITM, http via absolute-form forward proxy; real ~/.hermes untouched
bili dsh                              # deepseek-harness: non-loopback upstreams ride proxy envs (https MITM, http absolute-form), loopback keeps the overlay DSH_HOME (~/.dsh-bili) rewrite (#535), built-in deepseek route via DEEPSEEK_BASE_URL, native /acp command injected via --patch
bili pi --mitm-domain api.foo.com     # add a domain to the MITM whitelist

Option 2 — URL change (`/bili/` prefix)

Start the proxy:

bili

Then just prefix your client's existing baseURL with http://localhost:8787/bili/. The full upstream URL is embedded in the path, so the proxy knows where to forward without any config:

client baseURL before:  https://api.openai.com/v1
client baseURL after:   http://localhost:8787/bili/https://api.openai.com/v1

That's it — put your real API key in the client config as usual (the proxy passes it through untouched). Context windows (gpt-5.1-codex=400K, glm-5.2=1M, claude-opus-4=200K, …) are looked up from models.dev automatically.

For per-client configuration examples (OpenCode, Codex, Pi, login-client MITM, …) see the web UI guide at http://localhost:8787.

Verify

With the proxy running and your config saved, check it answers and that your first real request shows compression activity in the log:

# Health check (proxy up + where it forwards)
curl -s http://localhost:8787/__bili/health
# → {"ok":true,"upstream":"https://api.anthropic.com"}

# Live session stats (after a real request)
curl -s http://localhost:8787/__bili/stats

Then send one message from your client and watch the log (~/.local/state/billion-context/bili.log, also printed to stderr). You should see a processTurn line per request, and once the conversation grows, [acp-usage] round N input=X cached=Y (cache hit Z%) + a compress event.

Running the proxy

Flags

bili --port 9000              # change listen port
bili --host 0.0.0.0           # listen on all interfaces (see host note below)
bili --debug                 # verbose logging (also: set "debug": true in config)
bili --passthrough           # forward without compression (smoke-test mode)
bili --config ~/my-bili.json # use a different config file
bili update                  # check & install a newer version now (bypasses throttle)
bili --no-auto-update        # disable self-update for this run

Flags override env vars and the config file. bili --help lists them all.

Remote agents (`--host`)

By default the proxy binds 127.0.0.1 and only accepts loopback connections. To serve agents on other machines, bind a non-loopback host:

bili --host 0.0.0.0           # all interfaces (or use your LAN IP)

Remote agents point their model baseURL at http://<this-host>:<port>/bili/….
MITM-mode CONNECT then also accepts remote clients — for whitelisted model hosts only. Blind tunnels to arbitrary hosts stay loopback-only, so the proxy can never be used as an open relay.
The /bili/<absolute-url> tunnel has destination admission (#409): the proxy itself and link-local/metadata addresses are always denied; loopback/private destinations are allowed for local clients (self-hosted upstreams) and denied for remote clients unless listed in BILI_TUNNEL_ALLOWED_HOSTS (host or host:port, comma-separated) — a remote peer must not use the proxy as an SSRF pivot into your LAN, and the management plane is unreachable through the tunnel even via NAT hairpin (tunneled requests carry an internal x-bili-tunnel marker that /__bili/ rejects).
There is no authentication: only do this on a trusted LAN or behind a firewall. The /__bili/ management endpoints remain loopback-only.
A startup [security] warning reminds you of the above.

Debugging

Three ways to enable verbose logging (priority: flag > env > config):

CLI flag (quickest): bili --debug
Env var: ACP_DEBUG=1 bili
Config file: "debug": true in billion-context.json

Verbose mode logs every processTurn (tag counts, token usage), the nudge decision (growth/usage/pendingT1/shouldInject), client headers, and SSE rewrites.

Log file

All logs are tee'd to a file by default: ~/.local/state/billion-context/bili.log (XDG state dir). They also still print to stderr so a foreground bili start shows them in the terminal.

# Config:  "logFile": "/custom/path.log"
# Env:     ACP_LOG_FILE=/custom/path.log   (or ACP_LOG_FILE=off to disable the file)

The file auto-rotates at 10 MB (renamed to bili.log.old). Cache-hit stats per request are logged as [acp-usage] round N input=X cached=Y (cache hit Z%) so you can measure prefix-cache health directly from the log.

Self-update

The proxy checks npm for a newer version on startup and every 3 minutes. When a newer version is found it installs it globally (npm install -g) and logs a notice — restart bili to pick up the new version.

Disable permanently via config ("autoUpdate": false) or env (ACP_AUTO_UPDATE=0).

Configuration

The full configuration reference — config file location, top-level keys, providers, compression tuning, environment variables — lives in CONFIGURATION.md.

Upstream proxy (firewall / GFW)

If the proxy's own outbound connections to a model provider are blocked (e.g. api.openai.com from inside the GFW), configure an upstream proxy (the local v2rayA / clash HTTP port) so the proxy reaches the provider:

{
  // Global default: ALL providers route through this proxy
  "proxy": "http://127.0.0.1:20172",
  "providers": {
    "https://api.openai.com/v1": {
      // Per-URL overrides global (use a different proxy for this host)
      "proxy": "http://127.0.0.1:20173",
      "models": { "gpt-5": { "context": 400000 } }
    },
    "https://open.bigmodel.cn/api/anthropic": {
      // Empty string = explicitly DIRECT, overriding the global proxy
      "proxy": "",
      "models": { "glm-5.2": { "context": 1000000 } }
    }
  }
}

Rules:

Per-URL proxy has the highest priority for its matching provider URL.
Remaining priority is BILI_UPSTREAM_PROXY → Web UI manual proxy → top-level proxy → HTTPS_PROXY / HTTP_PROXY / ALL_PROXY → Windows system proxy → direct.
Empty string "" means explicitly direct (override-and-disable).
Auto mode honors NO_PROXY and the Windows proxy bypass list for environment/system fallbacks. A proxy pointing back to bili's own local port is ignored or rejected to prevent a loop.
HTTP and HTTPS proxy origins are supported. SOCKS5 is not supported yet.
Both outbound paths are covered: /bili/ path-mode (fetch) AND MITM CONNECT tunnels (the proxy's connection to the real upstream goes through the HTTP CONNECT proxy).
The auto-updater's own egress (npm registry check + tarball download) uses the same decision for its hosts, so bili update and auto-update work on hosts where npm is only reachable through the proxy (#609).

Env override: BILI_UPSTREAM_PROXY=http://127.0.0.1:20172 (higher priority than the config file). On Windows, common Clash/Mihomo static system proxies are discovered automatically; the Web UI shows the effective source and any PAC URL detected in Internet Settings.

MITM vs /bili/ — distinguishing the key scheme. A login client (ZCode via MITM) and an API-key client can both hit the same host (open.bigmodel.cn). To let their config differ, MITM traffic uses a mitm:// scheme in the lookup key while /bili/ traffic uses the real https://:

Client	Lookup key example
ZCode (MITM, login)	`mitm://open.bigmodel.cn`
API-key client (`/bili/`)	`https://open.bigmodel.cn/api/anthropic`

So you can give ZCode its own proxy without affecting API-key clients:

{
  "providers": {
    "mitm://open.bigmodel.cn":            { "proxy": "http://127.0.0.1:20173" },
    "https://open.bigmodel.cn/api/anthropic": { "proxy": "http://127.0.0.1:20172" }
  }
}

Wire-compat role rewrite (`compat.roles`)

Some upstreams reject the developer role newer codex clients send on the Responses API (400 Invalid role: developer). compat.roles maps roles to what the upstream accepts — applied at the forward boundary to the final openai/responses body (client-sent roles and bili's own injected prompt alike), global or per-provider, default off = byte-for-byte:

{
  "compat": { "roles": { "developer": "system" } },
  "providers": {
    "https://picky.example.com": { "compat": { "roles": { "developer": "user" } } }
  }
}

No configuration needed for the common case. When an upstream answers a request with 400 Invalid role: …, bili auto-rewrites the offending role to system, retries the request once, and — if the retry succeeds — remembers the mapping for that session only (nothing is written to your config). Later requests in the session skip the 400 round-trip. The log line printed when the auto-fix fires includes a copy-paste per-provider snippet if you want the mapping permanently.

How sessions work

The proxy needs a stable per-conversation identifier to isolate compression state across concurrent users/accounts. It derives one from four dimensions (see src/session-id.ts): protocol × upstream origin × API key × conversation. The first three prevent cross-account / cross-provider bleeding; the conversation dimension comes from whatever the client sends.

Clients differ in what they send:

Client	Sends conversation id?	Source	Safety
Codex (0.147+)	✅ yes	`body.session_id` (per-conversation UUID)	✅ safe
OpenCode	✅ yes	`x-session-affinity` header (`ses_…`)	✅ safe
pi	❌ no	nothing	⚠️ collision risk

When the client sends an explicit id, the proxy uses it directly. When it does not (pi), the proxy falls back to hashing the first user message — so two conversations that start with the same opener collapse onto the same session. This does not corrupt data (per-message refs use a separate content fingerprint that stays stable), but it can skew nudge/compression timing and occasionally over-eagerly reap a block. It is self-healing: the worst case is reduced compression efficiency, never data loss.

For upstream sticky-routing, when the client sends no session header the proxy synthesizes one (x-session-id: ses_<hash>) so cache pools / load balancers still get a stable key.

Recommendation: Codex and OpenCode are safe to run many concurrent conversations through the proxy. pi is fine for a single agent, but is not recommended for many concurrent conversations because of the collision risk — until pi grows its own session-id signal. For pi multi-agent use, pass an explicit x-acp-session header per conversation to avoid collisions.

Windows: exclude the sessions dir from antivirus (#362)

The proxy persists each session's compression state to the sessions dir (%USERPROFILE%\.local\share\billion-context\ by default) and rewrites the file every turn of a long session. Persisted per session: the compression state (block summaries), the compressed originals cache (blockContents, what bili export --full recovers), and a bounded folded-view snapshot of the recent conversation (newest BILI_PERSIST_TAIL_TOKENS tokens, default 16k) — the raw full history is never duplicated on disk (#401). On Windows, real-time antivirus (Windows Defender), the search indexer, or a sync tool (OneDrive) can lock that directory mid-write, so the rename fails with EPERM and every persist for that session fails until the lock clears.

When the same session fails N consecutive writes (default 5), the proxy logs a one-time, actionable alert naming the directory to exclude. To fix it at the root: add %USERPROFILE%\.local\share\billion-context\ to your antivirus exclusions (Windows Defender: Settings → Virus & threat protection → Manage settings → Exclusions → Add an exclusion → Folder) and make sure no sync tool (OneDrive / Dropbox / …) is syncing that path. Full steps in CONFIGURATION.md.

Status

Early. Protocol handling and compression work against mock tests (500+ passing). Real-model integration testing is the next milestone. Expect rough edges.

Client-side plugins for pi / omp / opencode ship inside billion-context (dist/agent/*.js) for the cooperative-proxy path. See the "Which do I need?" section above for how billion-context, the standalone billion-context-pi, and opencode-acp relate.

License

MIT

Name		Name	Last commit message	Last commit date
.github/workflows		.github/workflows
devlog		devlog
scripts		scripts
src		src
tests		tests
tools		tools
.gitignore		.gitignore
AGENTS.md		AGENTS.md
CHANGELOG.md		CHANGELOG.md
CONFIGURATION.md		CONFIGURATION.md
CONFIGURATION.zh-CN.md		CONFIGURATION.zh-CN.md
LICENSE		LICENSE
PLUGIN.md		PLUGIN.md
README.md		README.md
README.zh-CN.md		README.zh-CN.md
UNIFIED_LOOP_SPEC.md		UNIFIED_LOOP_SPEC.md
package-lock.json		package-lock.json
package.json		package.json
tsconfig.build.json		tsconfig.build.json
tsconfig.json		tsconfig.json
tsup.config.ts		tsup.config.ts

Navigation Menu

Repository files navigation

billion-context

Why

How it works

Two compression modes — who executes `compress`

Which do I need?

Install

Quickstart

Injection priority — no files unless unavoidable (#535)

Option 1 — Launcher (`bili pi` / `bili codex` / `bili claude` / `bili omp` / `bili opencode` / `bili hermes` / `bili dsh`)

Option 2 — URL change (`/bili/` prefix)

Verify

Running the proxy

Flags

Remote agents (`--host`)

Debugging

Log file

Self-update

Configuration

Upstream proxy (firewall / GFW)

Wire-compat role rewrite (`compat.roles`)

How sessions work

Windows: exclude the sessions dir from antivirus (#362)

Status

License

About

Releases

Packages

Contributors

Languages

Latest commit

History

Folders and files

Repository files navigation

billion-context

Why

How it works

Two compression modes — who executes compress

Which do I need?

Install

Quickstart

Injection priority — no files unless unavoidable (#535)

Option 1 — Launcher (bili pi / bili codex / bili claude / bili omp / bili opencode / bili hermes / bili dsh)

Option 2 — URL change (/bili/ prefix)

Verify

Running the proxy

Flags

Remote agents (--host)

Debugging

Log file

Self-update

Configuration

Upstream proxy (firewall / GFW)

Wire-compat role rewrite (compat.roles)

How sessions work

Windows: exclude the sessions dir from antivirus (#362)

Status

License

About

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages

Two compression modes — who executes `compress`

Option 1 — Launcher (`bili pi` / `bili codex` / `bili claude` / `bili omp` / `bili opencode` / `bili hermes` / `bili dsh`)

Option 2 — URL change (`/bili/` prefix)

Remote agents (`--host`)

Wire-compat role rewrite (`compat.roles`)