deps: Bump lru from 0.18.5 to 0.19.0 (#4382)

## Why this version

Upgrade the native proxy's bounded session caches from lru 0.18.5 to
0.19.0 to retain the upstream iterator soundness correction. The
official 0.19.0 changelog says "Require Sync for sendable shared
iterators." In source, `Send for Iter<'a, K, V>` now requires `K: Sync,
V: Sync`, replacing `K: Send, V: Send`: the iterator yields shared
references, which may cross threads only when their referents are Sync.

Headroom uses this crate for the shared `BetaStickyState` session
beta-token union and `DriftState` structural-hash history. Both live in
`Arc<Mutex<LruCache<...>>>` and are cloned into concurrent request
handlers. They use String / Vec<String> / StructuralHash values; they do
not transfer shared iterators across threads. Thus this updates a
concurrency-sensitive dependency to its corrected upstream contract; it
does not claim that current Headroom calls demonstrate an exploit or
require a new API.

The patch preserves the 0.19 target and adds the dependency rationale
beside its declaration, removes an obsolete lru 0.12 documentation
reference, and mechanically merges current main so the current security
workflows and fixes are included.

## Compatibility and installation

This is a pre-1.0 minor bump, so compatibility was checked rather than
assumed. The only dependency introduced by lru remains hashbrown 0.17.1.
The crate's MSRV is 1.85.0 in both 0.18.5 and 0.19.0; this bump does not
raise it. Headroom's workspace rust-version=1.80 already understates
that dependency floor; its pinned toolchain is 1.95.0, used for this
validation. Correcting the workspace-wide MSRV declaration is outside
this dependency patch.

Native installation already builds the ONNX/image/AWS dependency stack
and may fetch build dependencies and ONNX Runtime artifacts; lru adds no
build script or model download. This was a fresh isolated native target
build using the existing registry/artifact caches, not a clean
offline-install certification. Runtime validation disables model
downloads with HEADROOM_OFFLINE/HF_HUB_OFFLINE and uses only local fake
upstreams, with no cloud inference or credentials.

## Validation

- `cargo test -p headroom-proxy --lib cache_stabilization --locked`: 105
passed, including concurrent_unions_lose_no_tokens (8 threads, 50
updates each), LRU eviction and recency checks.
- `cargo fmt --all -- --check`: passed.
- `git diff --check`: passed.
- `cargo test -p headroom-proxy --test integration_cache_drift --test
integration_cache_control --test integration_e3_anthropic_cache_control
--test integration_e4_openai_cache_key --locked`: 20 passed across four
binaries (1/8/5/6).
- `cargo build -p headroom-proxy --locked`: passed with Rust 1.95.0 on
Windows MSVC.
- `python scripts/verify_native_session_caches.py --proxy
target/debug/headroom-proxy`: passed. A separately spawned native binary
forwarded 12 requests to an ephemeral loopback fake Anthropic upstream
without credentials. Sequential requests retained beta-a,beta-b; eight
concurrent same-session requests retained all token-0 through token-7 in
the next request. Logs recorded both first-seen and changed-system drift
events. Both proxy and fake upstream were cleaned up. Compression
interception was enabled with compression-mode off; this exercises the
actual session caches and byte passthrough, not model compression or
cloud behavior.
- The standard-library runtime proof is committed as
`scripts/verify_native_session_caches.py`; no private artifacts are
required. Security/CI approval and remote branch update remain separate
gates; this local proof does not certify hosted checks.

Official upstream references:
https://github.com/jeromefroe/lru-rs/blob/0.19.0/CHANGELOG.md and
https://github.com/jeromefroe/lru-rs/blob/0.19.0/src/lib.rs .

## Reproduce the native loopback proof

From the repository root, with its pinned Rust toolchain and Python 3:

```sh
cargo build -p headroom-proxy --locked
python scripts/verify_native_session_caches.py --proxy target/debug/headroom-proxy
```

On Windows use `--proxy target/debug/headroom-proxy.exe`. If
`CARGO_TARGET_DIR` is set, pass the binary under that directory instead.
Optional `--log /path/to/proxy.log` preserves logs; otherwise logs and
the child working directory are temporary. The script uses only Python's
standard library, strips provider/Headroom configuration environment
variables, disables model egress, bypasses caller HTTP proxy settings,
disables stats persistence, and starts only its own loopback fake
upstream and native child. It returns nonzero on readiness, forwarding,
sticky-union, or drift-event failures and cleans up its processes.

This proof was rerun after making the harness portable: all 12 upstream
requests passed. Current main was fetched again and remains
`74277d47ecfbca349ddb99f81094c4dd30539d43`, already included in this
candidate.

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: JerrettDavis <mxjerrett@gmail.com>
This commit is contained in:
dependabot[bot]
2026-11-03 08:45:55 -06:00
committed by GitHub
co-authored by JerrettDavis
parent 99e223c0e2
commit 038af599e1
4 changed files with 209 additions and 4 deletions
Generated
+2 -2
View File
@@ -2710,9 +2710,9 @@ dependencies = [
[[package]]
name = "lru"
version = "0.18.5"
version = "0.19.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ef9ac18847474e638e3702b76c65d4eb93428471a74778ef0f1be711717f89b5"
checksum = "4a9f71e3591c7ec44d3e563e87bf14ddc2bada8519dca046e5b0e560cd004e2d"
dependencies = [
"hashbrown 0.17.1",
]
+5 -1
View File
@@ -91,7 +91,11 @@ sha2 = "0.11"
# unbounded memory growth from a flood of unique session keys. `lru`
# is the de-facto Rust LRU crate; minimal surface, no dependencies of
# our own beyond `hashbrown` (which we already pull transitively).
lru = "0.18"
# 0.19 corrects the Send bound on shared iterators to require Sync: shared
# references may cross threads only when their referents are Sync. Our caches
# use String/Vec<String>/StructuralHash behind Arc<Mutex<_>> and do not
# transfer iterators; retain the upstream soundness fix without API changes.
lru = "0.19"
# PR-D4: GCP Application Default Credentials → bearer token for
# Vertex `:rawPredict` / `:streamRawPredict`. See workspace
# Cargo.toml for rationale.
@@ -66,7 +66,7 @@
//! key-sorted rebuild) of the corresponding subtree. Still well
//! under a millisecond on a typical agentic request; the detector
//! stays log-only and off the forwarded-bytes path.
//! - One LRU lookup + insert. `lru = "0.12"` is O(1) amortised.
//! - One LRU lookup + insert. `lru` is O(1) amortised.
//! - One `tracing::info!` or `tracing::warn!`. No metric emission yet
//! (left for Phase F PR-F* when the global Prometheus registry can
//! accept session-scoped counters without a cardinality explosion).
+201
View File
@@ -0,0 +1,201 @@
"""Exercise native session caches against a credentialless loopback upstream.
Build: cargo build -p headroom-proxy --locked
Run: python scripts/verify_native_session_caches.py --proxy target/debug/headroom-proxy
On Windows append .exe. A custom CARGO_TARGET_DIR requires its binary path.
Only Python's standard library is required. Logs are temporary unless --log is set.
"""
import argparse
import concurrent.futures
import http.server
import json
import os
import socket
import subprocess
import tempfile
import threading
import time
import urllib.request
from pathlib import Path
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--proxy", required=True, type=Path)
parser.add_argument("--log", type=Path, help="preserve native proxy logs here")
args = parser.parse_args()
binary = args.proxy.resolve(strict=True)
captured = []
capture_lock = threading.Lock()
class Upstream(http.server.BaseHTTPRequestHandler):
def do_POST(self):
body = self.rfile.read(int(self.headers["Content-Length"]))
with capture_lock:
captured.append((json.loads(body), self.headers.get("anthropic-beta", "")))
reply = json.dumps(
{
"id": "local",
"type": "message",
"role": "assistant",
"model": "claude-sonnet-4-20250514",
"content": [{"type": "text", "text": "local stub"}],
"stop_reason": "end_turn",
"usage": {"input_tokens": 10, "output_tokens": 2},
}
).encode()
self.send_response(200)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(reply)))
self.end_headers()
self.wfile.write(reply)
def log_message(self, *unused):
pass
with tempfile.TemporaryDirectory(prefix="headroom-cache-proof-") as temporary:
log_path = args.log.resolve() if args.log else Path(temporary) / "proxy.log"
server = http.server.ThreadingHTTPServer(("127.0.0.1", 0), Upstream)
worker = threading.Thread(target=server.serve_forever, daemon=True)
worker.start()
# The native CLI does not publish its port when binding :0. Reserve a
# candidate briefly; readiness detects exit if another process wins it.
with socket.socket() as reservation:
reservation.bind(("127.0.0.1", 0))
port = reservation.getsockname()[1]
env = {
key: value
for key, value in os.environ.items()
if not key.upper().startswith(
(
"HEADROOM_",
"AWS_",
"ANTHROPIC_",
"OPENAI_",
"GOOGLE_",
"AZURE_",
)
)
}
env.update(
AWS_EC2_METADATA_DISABLED="true",
NO_PROXY="127.0.0.1,localhost",
HEADROOM_OFFLINE="1",
HF_HUB_OFFLINE="1",
HEADROOM_LIVE_ZONE_DISABLE_ARMS="source_code,plain_text",
)
command = [
str(binary),
"--listen",
f"127.0.0.1:{port}",
"--upstream",
f"http://127.0.0.1:{server.server_port}",
"--compression",
"--compression-mode",
"off",
"--stats",
"false",
"--log-level",
"info",
]
# Explicitly bypass caller HTTP proxy settings for all proof requests.
client = urllib.request.build_opener(urllib.request.ProxyHandler({}))
process = None
try:
with log_path.open("w", encoding="utf-8", newline="\n") as log:
process = subprocess.Popen(
command,
env=env,
cwd=temporary,
stdout=log,
stderr=subprocess.STDOUT,
)
deadline = time.monotonic() + 30
while time.monotonic() < deadline:
if process.poll() is not None:
raise RuntimeError(f"proxy exited: {process.returncode}")
try:
with client.open(f"http://127.0.0.1:{port}/healthz", timeout=1) as response:
response.read()
break
except OSError:
time.sleep(0.2)
else:
raise RuntimeError("proxy readiness timeout")
def request(system, token="", session="same"):
payload = {
"model": "claude-sonnet-4-20250514",
"max_tokens": 16,
"system": system,
"messages": [{"role": "user", "content": "hello local"}],
}
headers = {"content-type": "application/json", "x-headroom-session-id": session}
if token:
headers["anthropic-beta"] = token
outgoing = urllib.request.Request(
f"http://127.0.0.1:{port}/v1/messages",
data=json.dumps(payload).encode(),
headers=headers,
)
with client.open(outgoing, timeout=30) as response:
if (
response.status != 200
or json.load(response)["content"][0]["text"] != "local stub"
):
raise RuntimeError("unexpected forwarded response")
request("first system", "beta-a")
request("changed system", "beta-b")
request("changed system")
if captured[1][1] != "beta-a,beta-b" or captured[2][1] != "beta-a,beta-b":
raise RuntimeError(f"sequential beta union lost: {captured}")
with concurrent.futures.ThreadPoolExecutor(max_workers=8) as pool:
list(
pool.map(
lambda i: request("parallel system", f"token-{i}", "parallel"), range(8)
)
)
request("parallel system", session="parallel")
if set(captured[-1][1].split(",")) != {f"token-{i}" for i in range(8)}:
raise RuntimeError(f"concurrent beta union lost: {captured[-1]}")
if len(captured) != 12:
raise RuntimeError(f"expected 12 upstream requests, got {len(captured)}")
log.flush()
events = log_path.read_text(encoding="utf-8")
if (
"cache_drift_first_request" not in events
or "cache_drift_observed" not in events
):
raise RuntimeError("expected first-seen and changed-system drift events")
print(
json.dumps(
{
"passed": True,
"upstream_requests": len(captured),
"sequential_beta_union": captured[2][1],
"parallel_beta_tokens": sorted(captured[-1][1].split(",")),
"drift_first_seen_and_changed": True,
}
)
)
except Exception:
if log_path.exists():
print(log_path.read_text(encoding="utf-8"))
raise
finally:
if process is not None:
process.terminate()
try:
process.wait(timeout=10)
except subprocess.TimeoutExpired:
process.kill()
process.wait()
server.shutdown()
server.server_close()
worker.join(timeout=5)
if __name__ == "__main__":
main()