mirror of
https://github.com/headroomlabs-ai/headroom.git
synced 2026-11-22 13:29:19 +08:00
## Description Closes #3697. An unchanged SmartCrusher result now keeps the original bytes and reports no structural compression. Formatting-only savings come from the existing Rust JsonMinifier, not from pretending the JSON value changed. The minifier preserves duplicate keys, order, escapes and number literals. A mixed result cannot use one section's CCR marker to hide unmarked loss in another. ## Type of Change - [x] Bug fix (non-breaking change that fixes an issue) - [x] Documentation update ## Changes Made - Keep SmartCrusher's exact-byte no-op behavior; route actual whitespace savings through JsonMinifier in Python and the eligible native live zone. - Keep all records and JSON literals; do not store originals or inject CCR markers for lossless minification. - Preserve mixed routing and reject uncovered lossy sections in both tool-result formats. Explicit no-CCR behavior is unchanged. - Replace incidental forwarding tests with native minification and complete-record regressions; document the distinction. ## Testing - [ ] Entire Python suite — not claimed. - [x] Four consumer/native modules: `python -m pytest -q tests/test_recursive_json.py tests/test_transforms_content_router.py tests/test_transforms/test_smart_crusher_rust_parity.py tests/test_transforms/test_smart_crusher_lossless_default.py` - [x] Changed-file Ruff checks; normal commit hooks, including mypy and commitlint. - [x] Manual public-API runs, with and without the HTML extra. ### Test Output Consumer/native modules: ```text collected 136 items ============================= 136 passed in 36.43s ============================= ``` Normal pre-push (fmt, clippy, 1,668 Rust tests with 3 ignored, native build, Python checks, commitlint): ```text ======================== 180 passed, 1 warning in 8.35s ======================== ✅ ci-precheck PASSED — safe to push. To https://github.com/oxura/headroom.git 64688217..0002af3e HEAD -> fix/3697-unchanged-json-passthrough ``` The first push stopped on an inherited commit footer because `origin/main` was stale. Fetching the actual upstream ref fixed the lint range; the normal push then passed. No source merge, lint-rule change or hook bypass. Hosted checks on `0002af3e` now pass: all four Python shards, Windows permissions, smoke tests, native wrappers, parity and Docker e2e. [Checks](https://github.com/headroomlabs-ai/headroom/pull/4044/checks). ## Real Behavior Proof - Environment: Linux x86-64, Python 3.13.14, Rust 1.95 and the actual extension built from this checkout. No provider billing calls. - Exact command / steps: the earlier localhost `/v1/compress` and TransformPipeline runs exercised the original fix. For this follow-up, call `ContentRouter.compress` on a data-only HTML page containing 60 complete records, with `smart_crusher_lossless_only=True`, `smart_crusher_with_compaction=False`, and `enable_kompress=False`. Run it once without trafilatura, then with the locked 2.0.0 extra. The new public-API test contains the full input/config. Separately call `route_embedded_json` on a compact array followed by a padded array, with Unicode and CRLF surroundings. - Observed result: both HTML modes keep all 60 records and the surrounding markup, with no unrecoverable section. The unchanged first JSON span does not stop the second span's compaction; surrounding text stays exact. Final Codecov is 96%; the two remaining lines are the deferred HTML fallback return. The real no-HTML-extra API run executed both, and local coverage also exercises the unchanged-span branch. - Not tested: live provider acceptance, invoices or production cache hit rates. No native eligibility or admission gates changed. ## Runtime Rollout Safety - Rollout-managed feature(s): none; existing JSON routing. - Minimum rollout channel: unchanged. - Stable/default behavior changed: eligible formatting savings return as json_minifier; standalone SmartCrusher remains byte-exact on no-ops. - Kill switch / disable path: existing routing configuration and HEADROOM_LIVE_ZONE_DISABLE_ARMS. - Unsafe override required: no. - Qualification impact: no-op, formatting, structural and CCR paths exercised separately. - Rollback path: revert the minifier integration; no persistence migration. ## Review Readiness - [x] I have performed a self-review - [x] This PR is ready for human review ## Checklist - [x] My code follows the project's style guidelines - [x] I have performed a self-review of my code - [x] I have made corresponding changes to the documentation - [x] I did not edit CHANGELOG.md — release-please owns it ## Additional Notes Addresses the [minifier review](https://github.com/headroomlabs-ai/headroom/pull/4044#issuecomment-6157583285). The maintainer’s main merge is retained. The latest follow-up only changes consumer tests. AI-assisted; no subagents. --------- Co-authored-by: JerrettDavis <mxjerrett@gmail.com>
146 lines
5.0 KiB
Python
146 lines
5.0 KiB
Python
"""Regression tests requested in review of PR #1668 (Go AST compression bugs
|
|
and CODE_AWARE token accounting) and PR #1670 (prefer_code_aware_for_code
|
|
default flip).
|
|
|
|
1. Go `statement_list` unwrapping — a Go function body no longer produces a
|
|
duplicated closing brace when truncated.
|
|
2. Multi-line Go signature (`) error {`) — the brace-bearing signature line
|
|
survives truncation instead of being silently dropped.
|
|
3. ContentRouter CODE_AWARE token accounting — compressed_tokens must come
|
|
from the same metric as original_tokens (the router's token estimator),
|
|
not the compressor's own (differently-scaled) estimator, or real savings
|
|
get misread as none.
|
|
4. prefer_code_aware_for_code defaults to True, both on the dataclass and via
|
|
the HEADROOM_PREFER_CODE_AWARE_FOR_CODE env var.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import pytest
|
|
|
|
from headroom.proxy.server import HeadroomProxy, ProxyConfig
|
|
from headroom.transforms.code_compressor import (
|
|
CodeAwareCompressor,
|
|
CodeCompressorConfig,
|
|
_check_tree_sitter_available,
|
|
)
|
|
from headroom.transforms.content_router import (
|
|
CompressionStrategy,
|
|
ContentRouter,
|
|
ContentRouterConfig,
|
|
_estimate_tokens,
|
|
)
|
|
|
|
pytestmark = pytest.mark.skipif(
|
|
not _check_tree_sitter_available(),
|
|
reason="tree-sitter not installed (pip install headroom-ai[code])",
|
|
)
|
|
|
|
GO_FUNC = """package main
|
|
|
|
func Compute(
|
|
\ta int,
|
|
\tb int,
|
|
) error {
|
|
\tx := a + b
|
|
\ty := x * 2
|
|
\tz := y - a
|
|
\tw := z + b
|
|
\treturn nil
|
|
}
|
|
"""
|
|
|
|
|
|
def _compress_go(**config_overrides: object):
|
|
config = CodeCompressorConfig(
|
|
min_tokens_for_compression=0,
|
|
max_body_lines=2,
|
|
semantic_analysis=False,
|
|
**config_overrides,
|
|
)
|
|
compressor = CodeAwareCompressor(config)
|
|
return compressor.compress(GO_FUNC, language="go")
|
|
|
|
|
|
def test_go_statement_list_unwrap_no_duplicate_closing_brace() -> None:
|
|
"""Go wraps a block's statements in one `statement_list` node; treating
|
|
that as a single statement made its row range swallow the block's own
|
|
closing brace, producing a duplicate `}` in the compressed output."""
|
|
result = _compress_go()
|
|
|
|
closing_braces = [line for line in result.compressed.splitlines() if line.strip() == "}"]
|
|
assert len(closing_braces) == 1, (
|
|
f"expected exactly one closing brace line, got {len(closing_braces)}:\n{result.compressed}"
|
|
)
|
|
|
|
|
|
def test_go_multiline_signature_brace_preserved() -> None:
|
|
"""The multi-line signature's closing line (`) error {`) shares its row
|
|
with the brace instead of starting one of its own. Detecting the brace
|
|
via startswith("{") missed this and silently dropped the line; it must
|
|
survive truncation via endswith("{")."""
|
|
result = _compress_go()
|
|
|
|
assert result.compressed.count(") error {") == 1, (
|
|
f"multi-line signature line missing or duplicated:\n{result.compressed}"
|
|
)
|
|
|
|
|
|
class _FakeCodeCompressor:
|
|
def __init__(self, compressed: str) -> None:
|
|
self._compressed = compressed
|
|
|
|
def compress(self, content: str, language=None, context=""):
|
|
class _Result:
|
|
pass
|
|
|
|
r = _Result()
|
|
r.compressed = self._compressed
|
|
# Deliberately inflated/differently-scaled "own" token estimate —
|
|
# simulates a compressor whose internal counter isn't comparable to
|
|
# the router's own token estimate.
|
|
r.compressed_tokens = 10_000_000
|
|
return r
|
|
|
|
|
|
def test_content_router_code_aware_token_accounting_matches_router_estimate() -> None:
|
|
"""compressed_tokens must be derived from _estimate_tokens(result.compressed),
|
|
the same metric as original_tokens, not the compressor's own estimator.
|
|
Using the mismatched estimator made a real compression look like "no
|
|
savings" and forced a needless fallback to Kompress."""
|
|
original = "word " * 200 # 200 words
|
|
compressed_text = "word " * 50 # a real, large reduction
|
|
|
|
router = ContentRouter(ContentRouterConfig(enable_code_aware=True))
|
|
router._code_compressor = _FakeCodeCompressor(compressed_text)
|
|
|
|
compressed, compressed_tokens, strategy_chain, _reversible = router._apply_strategy_to_content(
|
|
original, CompressionStrategy.CODE_AWARE, context=""
|
|
)
|
|
|
|
assert compressed == compressed_text
|
|
assert compressed_tokens == _estimate_tokens(compressed_text)
|
|
assert strategy_chain == ["code_aware"], (
|
|
f"real compression must not trigger a Kompress fallback, got {strategy_chain}"
|
|
)
|
|
|
|
|
|
def test_prefer_code_aware_for_code_dataclass_defaults_true() -> None:
|
|
assert ContentRouterConfig().prefer_code_aware_for_code is True
|
|
|
|
|
|
def test_prefer_code_aware_for_code_env_var_defaults_true(monkeypatch) -> None:
|
|
monkeypatch.delenv("HEADROOM_PREFER_CODE_AWARE_FOR_CODE", raising=False)
|
|
|
|
config = ProxyConfig(
|
|
optimize=False,
|
|
cache_enabled=False,
|
|
rate_limit_enabled=False,
|
|
cost_tracking_enabled=False,
|
|
code_aware_enabled=False,
|
|
)
|
|
proxy = HeadroomProxy(config)
|
|
router = proxy.anthropic_pipeline.transforms[-1]
|
|
|
|
assert router.config.prefer_code_aware_for_code is True
|