{"content":[{"text":"total 16\ndrwxr-xr-x 3 root root 4096 Sep 18 08:00 .\ndrwxr-xr-x 7 root root 4096 Sep 19 01:59 ..\ndrwxr-xr-x 8 root root 4096 Sep 18 08:00 .git\n-rw-r--r-- 1 root root  408 Sep 18 08:00 .gitignore\n","type":"text"}]}

{"content":[{"text":"Downloading leanctx-0.3.1-py3-none-any.whl (66 kB)\nSaved /tmp/x/leanctx-0.3.1-py3-none-any.whl\nSuccessfully downloaded leanctx\n\nleanctx@0.0.0 | MIT | deps: none | versions: 1\nDrop-in prompt compression for production LLM applications. Cut Anthropic / OpenAI / Gemini bills by 40-60%. Placeholder — TypeScript SDK coming in v0.3.\nhttps://github.com/jia-gao/leanctx\n\n","type":"text"}]}

{"content":[{"text":"Installing collected packages: leanctx\nSuccessfully installed leanctx-0.3.1\n/opt/freestyle/python/lib/python3.12/site-packages/leanctx/__init__.py\n['Anthropic', 'AsyncAnthropic', 'AsyncOpenAI', 'CompressionStats', 'Compressor', 'ContentType', 'DedupStrategy', 'Gemini', 'Lingua', 'MethodStatus', 'Middleware', 'ObservabilityConfig', 'OpenAI', 'PurgeErrorsStrategy', 'RepeatTracker', 'Router', 'SelfLLM', 'Strategy', 'Verbatim', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__', '__spec__', '__version__', '_content', '_gemini_adapter', 'classifier', 'classify', 'client', 'compressors', 'middleware', 'observability', 'router', 'stats', 'strategies', 'tokens']\n","type":"text"}]}

{"content":[{"text":"__init__.py\n__pycache__\n_content.py\n_gemini_adapter.py\nbench\nclassifier.py\nclient.py\ncompressors\nintegrations\nmiddleware.py\nobservability\npy.typed\nrouter.py\nstats.py\nstrategies\ntokens.py\n\"\"\"leanctx — drop-in prompt compression for production LLM applications.\n\nv0.0.x is a name-reservation release with the public SDK surface scaffolded\nas a passthrough. The working release (v0.1) swaps the passthrough for the\nreal three-mode compression pipeline (local LLMLingua-2 / self_llm / hybrid).\n\nSee https://github.com/jia-gao/leanctx for progress.\n\"\"\"\n\nfrom leanctx.classifier import RepeatTracker, classify\nfrom leanctx.client import Anthropic, AsyncAnthropic, AsyncOpenAI, Gemini, OpenAI\nfrom leanctx.compressors import Compressor, ContentType, Lingua, SelfLLM, Verbatim\nfrom leanctx.middleware import Middleware\nfrom leanctx.observability import MethodStatus, ObservabilityConfig\nfrom leanctx.router import Router\nfrom leanctx.stats import CompressionStats\nfrom leanctx.strategies import DedupStrategy, PurgeErrorsStrategy, Strategy\n\n__version__ = \"0.3.1\"\n\n__all__ = [\n    \"Anthropic\",\n    \"AsyncAnthropic\",\n    \"AsyncOpenAI\",\n    \"CompressionStats\",\n    \"Compressor\",\n    \"ContentType\",\n    \"DedupStrategy\",\n    \"Gemini\",\n    \"Lingua\",\n    \"MethodStatus\",\n    \"Middleware\",\n    \"ObservabilityConfig\",\n    \"OpenAI\",\n    \"PurgeErrorsStrategy\",\n    \"RepeatTracker\",\n    \"Router\",\n    \"SelfLLM\",\n    \"Strategy\",\n    \"Verbatim\",\n    \"__version__\",\n    \"classify\",\n]\n","type":"text"}]}

{"content":[{"text":"  648 client.py\n   20 compressors/__init__.py\n   51 compressors/base.py\n  277 compressors/lingua.py\n  325 compressors/selfllm.py\n   49 compressors/verbatim.py\n  261 middleware.py\n   40 router.py\n   20 strategies/__init__.py\n   22 strategies/base.py\n   39 strategies/dedup.py\n   47 strategies/purge_errors.py\n 1799 total\n\"\"\"Drop-in LLM SDK wrappers.\n\nInterface-compatible wrappers around the official anthropic / openai /\ngoogle-genai SDKs. Public surface mirrors the upstream client; an\nadditional ``leanctx_config`` kwarg controls compression behavior, and\neach response gains ``usage.leanctx_*`` telemetry attributes.\n\nWhen the ``[otel]`` extra is installed and observability is enabled\nin ``leanctx_config[\"observability\"][\"otel\"]``, every wrapper request\npath emits a ``leanctx.compress`` span.\n\"\"\"\n\nfrom __future__ import annotations\n\nfrom typing import Any\n\nfrom leanctx._gemini_adapter import (\n    contents_to_messages as _gemini_contents_to_messages,\n)\nfrom leanctx._gemini_adapter import (\n    messages_to_contents as _gemini_messages_to_contents,\n)\nfrom leanctx.middleware import Middleware\nfrom leanctx.observability.config import ObservabilityConfig\nfrom leanctx.observability.middleware_hooks import compression_span\nfrom leanctx.observability.stream_owners import (\n    _SpanOwningAsyncIterator,\n    _SpanOwningIterator,\n)\nfrom leanctx.stats import CompressionStats\n\n_ANTHROPIC_INSTALL_HINT = (\n    \"The 'anthropic' package is required for leanctx.Anthropic. \"\n    \"Install with: pip install 'leanctx[anthropic]'\"\n)\n\n_OPENAI_INSTALL_HINT = (\n    \"The 'openai' package is required for leanctx.OpenAI. \"\n    \"Install with: pip install 'leanctx[openai]'\"\n)\n\n_GEMINI_INSTALL_HINT = (\n    \"The 'google-genai' package is required for leanctx.Gemini. \"\n    \"Install with: pip install 'leanctx[gemini]'\"\n)\n\n\ndef _load_anthropic() -> Any:\n    try:\n        import anthropic\n    except ImportError as e:\n        raise ImportError(_ANTHROPIC_INSTALL_HINT) from e\n    return anthropic\n\n\ndef _load_openai() -> Any:\n    try:\n        import openai\n    except ImportError as e:\n        raise ImportError(_OPENAI_INSTALL_HINT) from e\n    return openai\n\n\ndef _load_gemini() -> Any:\n    try:\n        from google import genai\n    except ImportError as e:\n        raise ImportError(_GEMINI_INSTALL_HINT) from e\n    return genai\n\n\ndef _parse_observability(leanctx_config: dict[str, Any] | None) -> ObservabilityConfig:\n    if not leanctx_config:\n        return ObservabilityConfig()\n    return ObservabilityConfig.from_dict(leanctx_config.get(\"observability\"))\n\n\nclass Anthropic:\n    \"\"\"Drop-in replacement for ``anthropic.Anthropic``.\"\"\"\n\n","type":"text"}]}

{"content":[{"text":"# leanctx\n\n[![PyPI](https://img.shields.io/pypi/v/leanctx)](https://pypi.org/project/leanctx/)\n[![Python](https://img.shields.io/pypi/pyversions/leanctx)](https://pypi.org/project/leanctx/)\n[![License](https://img.shields.io/pypi/l/leanctx)](LICENSE)\n\n**Drop-in prompt compression for production LLM applications.**\nCut your input-token bill by 10–40%，without sacrificing accuracy.\n\n```python\n# before\nfrom openai import OpenAI\n\n# after\nfrom leanctx import OpenAI  # same interface, compressed requests\n```\n\nOn the full **[LongBench v2](https://longbench2.github.io/)** set (N=503), layered on top of a compressor that is already running, leanctx removes **an extra 18.7 % of tokens** — rising to **36.7 % on prose-heavy traffic** — at a cost of 1.8 pp of accuracy. Every figure regenerates from [per-item records committed to this repo](#every-figure-here-regenerates-from-committed-data). Open-source models, runs locally, MIT-licensed. Your prompts and user data never leave your infrastructure by default.\n\n[Quickstart](#quickstart-60-seconds) · [What makes it different](#what-makes-it-different) · [Benchmarks](#real-numbers) · [Integrations](#integrations) · [How it works](#how-it-works)\n\n---\n\n## What makes it different\n\n**Loss-tolerance routing** — classify every segment of a prompt by how much\ndistortion it can survive, then compress each class differently.\n\n```mermaid\nflowchart TD\n    A[\"Agent request\"] --> B[\"Classify by loss tolerance\"]\n    B -->|zero tolerance| C[\"Verbatim<br/>byte for byte\"]\n    B -->|high tolerance| D[\"LLMLingua-2<br/>~50% removed\"]\n    B -->|opt-in| E[\"Self-LLM\"]\n    C --> F[\"Recompose + check invariants\"]\n    D --> F\n    E --> F\n    F -->|hold| G[\"Compressed → provider\"]\n    F -->|fail or timeout| H[\"Original → provider\"]\n\n    classDef zero fill:#e8f1fd,stroke:#2a78d6,color:#0b0b0b\n    classDef high fill:#e9f4f0,stroke:#1baf7a,color:#0b0b0b\n    classDef open fill:#f4f4f1,stroke:#898781,color:#0b0b0b\n    class C zero\n    class D high\n    class H open\n```\n\n| Class | Content | Treatment | Effect |\n|---|---|---|---|\n| **Zero tolerance** | code, stack traces, `tool_use_id`, tool name and input, JSON | verbatim | 0 % altered |\n| **High tolerance** | documentation, retrieved passages, logs, prior turns | LLMLingua-2, on-device | ~50 % removed |\n| **Conditional** | low-confidence prose, oversized context | self-LLM, opt-in | 41–49 % removed |\n\nCompression applied uniformly to a prompt will eventually damage the one part that\ncannot survive being touched, and will do so unpredictably. The hard part is not\nshortening text — it is deciding, inside a live request, what may be shortened at all.\n\n---\n\n## Quickstart (60 seconds)\n\n```bash\npip install 'leanctx[openai,lingua]'    # or [anthropic], [gemini]\n```\n\n```python\nfrom leanctx import OpenAI\n\nclient = OpenAI(\n    leanctx_config={\n        \"mode\": \"on\",\n        \"trigger\": {\"threshold_tokens\": 2000},\n        \"routing\": {\"prose\": \"lingua\"},  # route prose through LLMLingua-2\n    },\n)\n\nresponse = client.chat.completions.create(\n    model=\"gpt-4o-mini\",\n    max_tokens=512,\n    messages=[{\"role\": \"user\", \"content\": LONG_DOCUMENT}],\n)\n\nprint(response.usage.leanctx_tokens_saved)  # e.g. 1841\nprint(response.usage.leanctx_ratio)         # e.g. 0.49\n```\n\n> **First Lingua call loads ~1.2 GB of model weights** to `~/.cache/huggingface/`. Subsequent calls reuse the cache. Add `pip install 'leanctx[lingua]'` to opt in; without it, leanctx falls back to passthrough.\n\nVerify the install with no API key needed:\n\n```bash\nleanctx bench list                                   # 7 registered scenarios\nleanctx bench run agent-structural --workload agent  # 5 invariants enforced, exit 0 = pass\n```\n\n## Why this exists\n\nYou're building a production LLM app and your token bill is a line item:\n\n- RAG apps with large retrieved documents\n- Long-running conversational agents (LangChain / LangGraph / CrewAI)\n- Document-processing pipelines\n- Coding agents — Cursor-like / Claude-Code-like, with growing tool-call histories\n\nExisting options have gaps:\n\n- **Provider prompt caching** (Anthropic / OpenAI / Gemini) wins on stable prefixes — system prompts, tool definitions, retrieved-document pools. **It doesn't help with dynamic per-query content** (chat history, freshly retrieved docs, tool outputs). Compose with leanctx, don't choose between them.\n- **Naive truncation** drops the middle of the document, exactly where many answers live. The LongBench v2 numbers above show this concretely.\n- **Hosted compression APIs** (Compresr, Token Company) require sending your context to their servers. Closed-source models. leanctx is MIT-licensed, runs the model locally, and never makes outbound calls except to your existing provider.\n\n## Real numbers\n\n### Full LongBench v2 sweep — N=503, layered on a production compressor\n\nThe headline result. leanctx runs as a semantic pass **on top of** [ClawRouter](https://github.com/BlockRunAI/ClawRouter)'s seven structural compression layers, so the measured delta is what leanctx adds to a system that is *already* compressing. All 503 LongBench v2 questions (Tsinghua KEG, 8K–2M words), Claude Haiku 4.5 eval, temperature 0.1.\n\n| | Avg tokens / request | vs raw | vs Leg A |\n|---|---:|---:|---:|\n| Raw (uncompressed) | 27,865 | — | — |\n","type":"text"}]}

{"content":[{"text":"[![License](https://img.shields.io/pypi/l/leanctx)](LICENSE)\n\n**Drop-in prompt compression for production LLM applications.**\nCut your input-token bill by 10–40%，without sacrificing accuracy.\n\n```python\n# before\n--\nOn the full **[LongBench v2](https://longbench2.github.io/)** set (N=503), layered on top of a compressor that is already running, leanctx removes **an extra 18.7 % of tokens** — rising to **36.7 % on prose-heavy traffic** — at a cost of 1.8 pp of accuracy. Every figure regenerates from [per-item records committed to this repo](#every-figure-here-regenerates-from-committed-data). Open-source models, runs locally, MIT-licensed. Your prompts and user data never leave your infrastructure by default.\n\n[Quickstart](#quickstart-60-seconds) · [What makes it different](#what-makes-it-different) · [Benchmarks](#real-numbers) · [Integrations](#integrations) · [How it works](#how-it-works)\n\n---\n\n## What makes it different\n--\n- **Hosted compression APIs** (Compresr, Token Company) require sending your context to their servers. Closed-source models. leanctx is MIT-licensed, runs the model locally, and never makes outbound calls except to your existing provider.\n\n## Real numbers\n\n### Full LongBench v2 sweep — N=503, layered on a production compressor\n\nThe headline result. leanctx runs as a semantic pass **on top of** [ClawRouter](https://github.com/BlockRunAI/ClawRouter)'s seven structural compression layers, so the measured delta is what leanctx adds to a system that is *already* compressing. All 503 LongBench v2 questions (Tsinghua KEG, 8K–2M words), Claude Haiku 4.5 eval, temperature 0.1.\n--\n**Compression costs accuracy, it does not add it.** The claim is that the cost is small and bounded — 1.8 pp overall, against the −2 pp go/no-go gate set for the integration. Because 54.2 % of Layer-8 input tokens route to verbatim, the compression actually applied to eligible content is **40.8 %**; the verbatim half contributes exactly 0 to both the savings and the accuracy delta by construction.\n\nSub-buckets are not uniform, and the report gives all of them: `short`/`lingua` is −17.6 pp (N=68) and Single-Document QA −11.5 pp (N=78), while Long Structured Data Understanding is +9.4 pp (N=32). Sidecar latency 47 ms p50 on GPU. At Sonnet input pricing the savings are ~$78 per 1,000 requests.\n\nFull report — per-bucket breakdowns by route × difficulty × length × domain, layer-by-layer contributions, cost model: [`benchmarks/clawrouter/full_long_bench_evaluation_result.md`](benchmarks/clawrouter/full_long_bench_evaluation_result.md).\n\n#### Independent execution and audit\n\nThis result was not produced by the maintainer. The benchmark was executed and audited by outside contributors ([@YingjingLu](https://github.com/YingjingLu), [@QianXiaoMoRan9](https://github.com/QianXiaoMoRan9)). An audit of an earlier draft showed that a headline \"+7.4 % on long context\" was **eval noise rather than a compression effect** — 7 of the 8 net improved items came from the verbatim subset, where the input was byte-identical (McNemar p = 0.143). Two methodology fixes followed ([#7](https://github.com/jia-gao/leanctx/pull/7)): Leg B now reuses Leg A's answer whenever the compressed context is byte-identical, so verbatim items contribute Δ = 0 by construction instead of decoder noise, and eval temperature dropped to 0.1. A separate correction forced a letter choice in the closed-book control, which had been scoring 6 % — below the 25 % random floor for 4-way multiple choice — and inflating apparent context lift.\n\nThe numbers above are post-correction. Discussion: [issue #3](https://github.com/jia-gao/leanctx/issues/3).\n--\n| Provider  | Model              | Compression | Latency   | Cost per call |\n|-----------|--------------------|:-----------:|:---------:|:-------------:|\n| Anthropic | `claude-haiku-4-5` | **41.6 %**  | 3.05 s    | ~$0.0016      |\n| OpenAI    | `gpt-4o-mini`      | **49.1 %**  | 6.42 s    | ~$0.0003      |\n","type":"text"}]}

cd /tmp && python - <<'EOF'
from leanctx import classify, ContentType, CompressionStats
from leanctx.tokens import count_tokens if False else None
import leanctx.tokens as t
print([x for x in dir(t) if not x.startswith('_')])
text = "The quick brown fox jumps over the lazy dog. " * 10
print(classify(text))
EOF

{"content":[{"text":"  File \"<stdin>\", line 2\n    from leanctx.tokens import count_tokens if False else None\n                                            ^^\nSyntaxError: invalid syntax\n\n\nCommand exited with code 1","type":"text"}],"details":{}}

cd /tmp && python - <<'EOF'
import leanctx.tokens as t, leanctx.classifier as c
from leanctx.compressors import Verbatim, Lingua, ContentType
print("tokens:", [x for x in dir(t) if not x.startswith('_')])
print("classifier:", [x for x in dir(c) if not x.startswith('_')])
print("ContentType:", list(ContentType))
EOF

{"content":[{"text":"tokens: ['Any', 'annotations', 'count_message_tokens', 'count_tokens', 'get_text_content', 'lru_cache']\nclassifier: ['Any', 'ContentType', 'RepeatTracker', 'annotations', 'classify', 'get_text_content', 'hashlib']\nContentType: [<ContentType.UNKNOWN: 'unknown'>, <ContentType.PROSE: 'prose'>, <ContentType.CODE: 'code'>, <ContentType.ERROR: 'error'>, <ContentType.REPEAT: 'repeat'>, <ContentType.LONG_IMPORTANT: 'long_important'>]\n","type":"text"}]}

cd /tmp && python - <<'EOF'
from leanctx.compressors import Compressor, Lingua, Verbatim
import inspect
print(inspect.signature(Compressor.__init__))
print(inspect.signature(Compressor.compress) if hasattr(Compressor,'compress') else [m for m in dir(Compressor) if not m.startswith('_')])
print(inspect.signature(Lingua.compress) if hasattr(Lingua,'compress') else '')
EOF

{"content":[{"text":"(self, *args, **kwargs)\n(self, messages: 'list[dict[str, Any]]') -> 'tuple[list[dict[str, Any]], CompressionStats]'\n(self, messages: 'list[dict[str, Any]]') -> 'tuple[list[dict[str, Any]], CompressionStats]'\n","type":"text"}]}

{"content":[{"text":"anthropic                                    0.122.0\nllama-index-embeddings-openai                0.6.0\nllama-index-llms-openai                      0.7.10\nopenai                                       2.54.0\nopenai-agents                                0.20.0\n","type":"text"}]}

cd /tmp && python - <<'EOF'
from leanctx import Compressor, Strategy, classify, ContentType
from leanctx.tokens import count_message_tokens
import inspect
print(inspect.signature(Strategy.__init__) if hasattr(Strategy,'__init__') else '')
print([m for m in dir(Strategy) if not m.startswith('_')])
msgs = [
    {"role": "system", "content": "You are a helpful assistant. Always answer in JSON."},
    {"role": "user", "content": "Here is a document. " * 500 + "\n\n```python\ndef f(x):\n    return x*2\n```\nSummarize."},
]
print("tokens before:", count_message_tokens(msgs))
c = Compressor()
out, stats = c.compress(msgs)
print("tokens after:", count_message_tokens(out))
print("stats:", stats)
for m in msgs[1:]:
    print(classify(m["content"]))
EOF

{"content":[{"text":"(self, *args, **kwargs)\n['apply']\ntokens before: 2531\nTraceback (most recent call last):\n  File \"<stdin>\", line 11, in <module>\n  File \"/usr/lib/python3.12/typing.py\", line 1742, in _no_init_or_replace_init\n    raise TypeError('Protocols cannot be instantiated')\nTypeError: Protocols cannot be instantiated\n\n\nCommand exited with code 1","type":"text"}],"details":{}}

cd /tmp && python - <<'EOF'
from leanctx import Lingua, Verbatim, classify
from leanctx.tokens import count_message_tokens
msgs = [
    {"role": "system", "content": "You are a helpful assistant. Always answer in JSON."},
    {"role": "user", "content": "Here is a document. " * 500 + "\n\n```python\ndef f(x):\n    return x*2\n```\nSummarize."},
]
print("tokens before:", count_message_tokens(msgs))
for C in (Verbatim, Lingua):
    c = C()
    out, stats = c.compress(msgs)
    print(C.__name__, "after:", count_message_tokens(out), "stats:", stats)
print("classify prose:", classify("Here is a document. " * 500))
print("classify code:", classify("```python\ndef f(x):\n    return x*2\n```"))
EOF

{"content":[{"text":"tokens before: 2531\nVerbatim after: 2531 stats: CompressionStats(input_tokens=2531, output_tokens=2531, ratio=1.0, method='verbatim', cost_usd=0.0)\nTraceback (most recent call last):\n  File \"/opt/freestyle/python/lib/python3.12/site-packages/leanctx/compressors/lingua.py\", line 268, in _load\n    import llmlingua\nModuleNotFoundError: No module named 'llmlingua'\n\nThe above exception was the direct cause of the following exception:\n\nTraceback (most recent call last):\n  File \"<stdin>\", line 10, in <module>\n  File \"/opt/freestyle/python/lib/python3.12/site-packages/leanctx/compressors/lingua.py\", line 117, in compress\n    stats = self._compress_inner(messages)\n            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"/opt/freestyle/python/lib/python3.12/site-packages/leanctx/compressors/lingua.py\", line 136, in _compress_inner\n    new_msg, in_tok, out_tok = self._compress_message(msg)\n                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"/opt/freestyle/python/lib/python3.12/site-packages/leanctx/compressors/lingua.py\", line 175, in _compress_message\n    compressed, in_tok, out_tok = self._compress_text(content)\n                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"/opt/freestyle/python/lib/python3.12/site-packages/leanctx/compressors/lingua.py\", line 253, in _compress_text\n    compressor = self._load()\n                 ^^^^^^^^^^^^\n  File \"/opt/freestyle/python/lib/python3.12/site-packages/leanctx/compressors/lingua.py\", line 270, in _load\n    raise ImportError(_LINGUA_INSTALL_HINT) from e\nImportError: The 'llmlingua' package is required for leanctx.Lingua. Install with: pip install 'leanctx[lingua]'\n\n\nCommand exited with code 1","type":"text"}],"details":{}}

{"content":[{"text":"/opt/freestyle/python/bin/python3: No module named leanctx.bench.__main__; 'leanctx.bench' is a package and cannot be directly executed\n__init__.py\n__pycache__\ncli.py\nrunners\nscenarios.py\nschema.py\nworkloads.py\n","type":"text"}]}

{"content":[{"text":"  agent-structural          Structural-integrity invariants on the agent workload.  [missing extras: lingua]\n  anthropic-e2e             Full leanctx.Anthropic stack with respx-mocked Anthropic API.  [missing extras: bench]\n  lingua-local              Offline LLMLingua-2 compression on a single workload.  [missing extras: lingua]\n  selfllm-anthropic         SelfLLM compression via Anthropic (Haiku) live API.  [missing env: ANTHROPIC_API_KEY]\n  selfllm-openai            SelfLLM compression via OpenAI (gpt-4o-mini) live API.  [missing env: OPENAI_API_KEY]\n  selfllm-gemini            SelfLLM compression via Gemini (2.5-flash) live API.  [missing env: GEMINI_API_KEY|GOOGLE_API_KEY]\n  agent-structural          Structural-integrity invariants on the agent workload.  [missing extras: lingua]\n  anthropic-e2e             Full leanctx.Anthropic stack with respx-mocked Anthropic API.  [missing extras: bench]\n  lingua-local              Offline LLMLingua-2 compression on a single workload.  [missing extras: lingua]\n  selfllm-anthropic         SelfLLM compression via Anthropic (Haiku) live API.  [missing env: ANTHROPIC_API_KEY]\n  selfllm-openai            SelfLLM compression via OpenAI (gpt-4o-mini) live API.  [missing env: OPENAI_API_KEY]\n  selfllm-gemini            SelfLLM compression via Gemini (2.5-flash) live API.  [missing env: GEMINI_API_KEY|GOOGLE_API_KEY]\n","type":"text"}]}

{"content":[{"text":"== classify segments (loss-tolerance routing) ==\nTraceback (most recent call last):\n  File \"/sandbox/repo/leanctx_example.py\", line 36, in <module>\n    print(f\"  prose doc  -> {classify(LONG_DOC).value}   (high tolerance: compressible)\")\n                             ^^^^^^^^^^^^^^^^^^\n  File \"/opt/freestyle/python/lib/python3.12/site-packages/leanctx/classifier.py\", line 70, in classify\n    text = get_text_content(message)\n           ^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"/opt/freestyle/python/lib/python3.12/site-packages/leanctx/_content.py\", line 42, in get_text_content\n    return _extract_text(message.get(\"content\"))\n                         ^^^^^^^^^^^\nAttributeError: 'str' object has no attribute 'get'\n\n\nCommand exited with code 1","type":"text"}],"details":{}}

{"content":[{"text":"Successfully replaced 1 block(s) in /sandbox/repo/leanctx_example.py.","type":"text"}],"details":{"diff":"    ...\n 32     {\"role\": \"user\", \"content\": f\"Context:\\n{LONG_DOC}\\n\\n{CODE_BLOCK}\\n\\nSummarize and compute discount(100, 20).\"},\n 33 ]\n 34 \n 35 print(\"== classify segments (loss-tolerance routing) ==\")\n-36 print(f\"  prose doc  -> {classify(LONG_DOC).value}   (high tolerance: compressible)\")\n-37 print(f\"  code block -> {classify(CODE_BLOCK).value}   (zero tolerance: verbatim)\")\n+36 print(f\"  prose doc  -> {classify({'role': 'user', 'content': LONG_DOC}).value}   (high tolerance: compressible)\")\n+37 print(f\"  code block -> {classify({'role': 'user', 'content': CODE_BLOCK}).value}   (zero tolerance: verbatim)\")\n 38 \n 39 before = count_message_tokens(messages)\n 40 \n 41 # Verbatim compressor: byte-for-byte passthrough (baseline; the Lingua\n    ...","patch":"--- /sandbox/repo/leanctx_example.py\n+++ /sandbox/repo/leanctx_example.py\n@@ -32,10 +32,10 @@\n     {\"role\": \"user\", \"content\": f\"Context:\\n{LONG_DOC}\\n\\n{CODE_BLOCK}\\n\\nSummarize and compute discount(100, 20).\"},\n ]\n \n print(\"== classify segments (loss-tolerance routing) ==\")\n-print(f\"  prose doc  -> {classify(LONG_DOC).value}   (high tolerance: compressible)\")\n-print(f\"  code block -> {classify(CODE_BLOCK).value}   (zero tolerance: verbatim)\")\n+print(f\"  prose doc  -> {classify({'role': 'user', 'content': LONG_DOC}).value}   (high tolerance: compressible)\")\n+print(f\"  code block -> {classify({'role': 'user', 'content': CODE_BLOCK}).value}   (zero tolerance: verbatim)\")\n \n before = count_message_tokens(messages)\n \n # Verbatim compressor: byte-for-byte passthrough (baseline; the Lingua\n","firstChangedLine":36}}

{"content":[{"text":"== classify segments (loss-tolerance routing) ==\n  prose doc  -> prose   (high tolerance: compressible)\n  code block -> code   (zero tolerance: verbatim)\n\n== compression stats ==\n  tokens before : 875\n  tokens after  : 875\n  stats         : CompressionStats(input_tokens=875, output_tokens=875, ratio=1.0, method='verbatim', cost_usd=0.0)\n","type":"text"}]}