contextpress 0.6.2__tar.gz → 0.6.3__tar.gz

{contextpress-0.6.2 → contextpress-0.6.3}/CHANGELOG.md

@@ -4,6 +4,15 @@ All notable changes to `contextpress` are recorded here.
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.6.3] - 2026-08-12
+
+- **LangChain round-trip** — ``compress()`` maps remaining turns back onto their original
+  message objects (not list index), so dropped turns no longer remap roles/content.
+- **``output_tokens`` on cost stats** — ``attach_cost(output_tokens=...)``,
+  ``compress(..., output_tokens=...)``, and ``ContextManager(cost_output_tokens=...)``
+  add assumed completion USD; ``summary()`` prints output + total when set.
+- Example: `examples/langchain_roundtrip.py`.
+
 ## [0.6.2] - 2026-07-27
 
 - **Agent-oriented fixtures** — three offline agent threads under `tests/fixtures/chats/`

{contextpress-0.6.2 → contextpress-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: contextpress
-Version: 0.6.2
+Version: 0.6.3
 Summary: Deterministic context compression for LLM chat, RAG, and agent pipelines
 Project-URL: Homepage, https://github.com/Taha-azizi/contextpress
 Project-URL: Documentation, https://github.com/Taha-azizi/contextpress#readme
@@ -436,6 +436,20 @@ print(result.summary())
 # est. input cost: $0.000126 -> $0.000061 (saved $0.000065)   # when cost_provider set
 ```
 
+**Assumed completion tokens** (0.6.3+, opt-in; output cost is unchanged by compression):
+
+```python
+cm = ContextManager(type="chat", model="gpt-4o-mini", cost_provider="openai", cost_output_tokens=200)
+result = cm.compress(messages, token_budget=2000, return_stats=True)
+print(result.summary())
+# ...
+# est. output cost: $0.000120 (200 tokens)
+# est. total: $0.000246 -> $0.000181
+```
+
+LangChain-style message objects (``.type`` / ``.content``) round-trip through ``compress()``;
+dropped turns keep their original object types. See `examples/langchain_roundtrip.py`.
+
 See [`ROADMAP.md`](ROADMAP.md) for positioning vs heavier compression stacks and the 0.6.x plan.
 
 ## Tier 1 vs Tier 2 (classical NLP vs LLM)

{contextpress-0.6.2 → contextpress-0.6.3}/README.md

@@ -195,6 +195,20 @@ print(result.summary())
 # est. input cost: $0.000126 -> $0.000061 (saved $0.000065)   # when cost_provider set
 ```
 
+**Assumed completion tokens** (0.6.3+, opt-in; output cost is unchanged by compression):
+
+```python
+cm = ContextManager(type="chat", model="gpt-4o-mini", cost_provider="openai", cost_output_tokens=200)
+result = cm.compress(messages, token_budget=2000, return_stats=True)
+print(result.summary())
+# ...
+# est. output cost: $0.000120 (200 tokens)
+# est. total: $0.000246 -> $0.000181
+```
+
+LangChain-style message objects (``.type`` / ``.content``) round-trip through ``compress()``;
+dropped turns keep their original object types. See `examples/langchain_roundtrip.py`.
+
 See [`ROADMAP.md`](ROADMAP.md) for positioning vs heavier compression stacks and the 0.6.x plan.
 
 ## Tier 1 vs Tier 2 (classical NLP vs LLM)

{contextpress-0.6.2 → contextpress-0.6.3}/ROADMAP.md

@@ -40,5 +40,6 @@ deterministic Tier‑1 NLP for chat / RAG / agent **message histories**, with op
 | **0.6.0** | `structure` stage + `estimate_cost()` + this roadmap — shipped |
 | **0.6.1** | Wire estimated USD into `CompressionStats` / reports — shipped |
 | **0.6.2** | Agent-oriented fixtures for JSON/tool payloads; `summary()` report — shipped |
+| **0.6.3** | LangChain compress round-trip; `output_tokens` on cost stats / `summary()` — shipped |
 
 Stay classical-NLP-first; keep optional LLM extras optional.

{contextpress-0.6.2 → contextpress-0.6.3}/contextpress/__init__.py

@@ -16,7 +16,7 @@ __all__ = [
     "CompressionResult",
     "CompressionStats",
 ]
-__version__ = "0.6.2"
+__version__ = "0.6.3"
 
 
 def __getattr__(name: str) -> Any:

{contextpress-0.6.2 → contextpress-0.6.3}/contextpress/core.py

@@ -48,6 +48,7 @@ class ContextManager:
         llm_max_summary_tokens: int = 2048,
         llm_mode: str = "replace_all",
         cost_provider: str | None = None,
+        cost_output_tokens: int = 0,
     ):
         if type not in PROFILES:
             raise ValueError(f"unknown context type {type!r}")
@@ -65,6 +66,7 @@ class ContextManager:
         self.llm_mode = llm_mode
         # When set, compress(..., return_stats=True) attaches USD fields on stats.
         self.cost_provider = cost_provider
+        self.cost_output_tokens = int(cost_output_tokens)
         self._custom_stages: dict[str, StageConfig] = {}
 
     def estimate_tokens(self, messages: Any, *, model: str | None = None) -> int:
@@ -185,6 +187,7 @@ class ContextManager:
         return_stats: bool = False,
         dry_run: bool = False,
         cost_provider: str | None = None,
+        output_tokens: int | None = None,
     ) -> Any | CompressionResult:
         """Run the pipeline; return value matches input shape (dict list, tuples, strings, etc.).
 
@@ -193,6 +196,8 @@ class ContextManager:
         With ``dry_run=True``, runs Tier 1 only (no LLM calls) and returns the original messages.
         When ``cost_provider`` (or ``self.cost_provider``) is set and stats are returned,
         ``stats`` includes approximate input USD before/after compression.
+        ``output_tokens`` (or ``self.cost_output_tokens``) adds an assumed completion cost
+        that is unchanged by compression.
         """
         if dry_run:
             return_stats = True
@@ -228,7 +233,14 @@ class ContextManager:
             stats.warnings_emitted = captured
             prov = cost_provider if cost_provider is not None else self.cost_provider
             if prov is not None:
-                stats.attach_cost(provider=prov, model=self.model or "gpt-4o-mini")
+                out_tok = (
+                    output_tokens if output_tokens is not None else self.cost_output_tokens
+                )
+                stats.attach_cost(
+                    provider=prov,
+                    model=self.model or "gpt-4o-mini",
+                    output_tokens=out_tok,
+                )
         if dry_run:
             messages_out = denormalize_output(clone_conversation(conv), ctx)
         else:
@@ -249,6 +261,7 @@ class ContextManager:
         return_stats: bool = False,
         dry_run: bool = False,
         cost_provider: str | None = None,
+        output_tokens: int | None = None,
     ) -> list[Any] | list[CompressionResult]:
         """Run ``compress()`` on each conversation in ``conversations``."""
         if not isinstance(conversations, list):
@@ -263,6 +276,7 @@ class ContextManager:
                 return_stats=return_stats,
                 dry_run=dry_run,
                 cost_provider=cost_provider,
+                output_tokens=output_tokens,
             )
             for messages in conversations
         ]
@@ -278,6 +292,7 @@ class ContextManager:
         return_stats: bool = False,
         dry_run: bool = False,
         cost_provider: str | None = None,
+        output_tokens: int | None = None,
     ) -> Any | CompressionResult:
         """Async wrapper around ``compress()`` (runs in a worker thread)."""
         return await asyncio.to_thread(
@@ -290,6 +305,7 @@ class ContextManager:
             return_stats=return_stats,
             dry_run=dry_run,
             cost_provider=cost_provider,
+            output_tokens=output_tokens,
         )
 
     def set_compression(self, compression: str) -> None:

{contextpress-0.6.2 → contextpress-0.6.3}/contextpress/normalizer.py

@@ -247,15 +247,14 @@ def denormalize_output(conversation: Conversation, ctx: dict[str, Any]) -> Any:
         return out
 
     if fmt == "langchain":
-        # Reconstruct LangChain objects by copying original and setting content
-        lc_objs = ctx.get("lc_objects", [])
-        if not lc_objs:
-            return []
+        # Reconstruct LangChain objects from the turn's original message, not list index
+        # (dropped turns would otherwise remap remaining content onto the wrong objects).
         result = []
-        for i, t in enumerate(turns):
-            if i < len(lc_objs):
-                obj = copy.copy(lc_objs[i])
-                text = _turn_to_plain_text(t)
+        for t in turns:
+            orig = t.metadata.get("_lc_original") or t.metadata.get("_lc_obj")
+            text = _turn_to_plain_text(t)
+            if orig is not None:
+                obj = copy.copy(orig)
                 if hasattr(obj, "content"):
                     try:
                         obj.content = text
@@ -270,7 +269,7 @@ def denormalize_output(conversation: Conversation, ctx: dict[str, Any]) -> Any:
                         self.type = role
                         self.content = content
 
-                result.append(_Msg(t.role, _turn_to_plain_text(t)))
+                result.append(_Msg(t.role, text))
         return result
 
     # dict_list

{contextpress-0.6.2 → contextpress-0.6.3}/contextpress/stats.py

@@ -57,6 +57,11 @@ class CompressionStats:
     cost_model: str | None = None
     estimated_input_cost_before_usd: float | None = None
     estimated_input_cost_after_usd: float | None = None
+    # Optional completion-side estimate (0.6.3+); same before/after (compression is input-only)
+    estimated_output_tokens: int | None = None
+    estimated_output_cost_usd: float | None = None
+    estimated_total_cost_before_usd: float | None = None
+    estimated_total_cost_after_usd: float | None = None
 
     @property
     def turns_removed(self) -> int:
@@ -86,14 +91,32 @@ class CompressionStats:
         *,
         provider: str = "openai",
         model: str | None = "gpt-4o-mini",
+        output_tokens: int = 0,
     ) -> CompressionStats:
-        """Fill USD fields from ``tokens_before`` / ``tokens_after``. Returns self."""
-        before = estimate_token_cost(self.tokens_before, provider=provider, model=model)
-        after = estimate_token_cost(self.tokens_after, provider=provider, model=model)
+        """Fill USD fields from ``tokens_before`` / ``tokens_after``. Returns self.
+
+        ``output_tokens`` is an assumed completion size (unchanged by compression).
+        """
+        before = estimate_token_cost(
+            self.tokens_before, provider=provider, model=model, output_tokens=output_tokens
+        )
+        after = estimate_token_cost(
+            self.tokens_after, provider=provider, model=model, output_tokens=output_tokens
+        )
         self.cost_provider = before.provider
         self.cost_model = before.model
         self.estimated_input_cost_before_usd = before.input_cost_usd
         self.estimated_input_cost_after_usd = after.input_cost_usd
+        if output_tokens > 0:
+            self.estimated_output_tokens = after.output_tokens
+            self.estimated_output_cost_usd = after.output_cost_usd
+            self.estimated_total_cost_before_usd = before.total_cost_usd
+            self.estimated_total_cost_after_usd = after.total_cost_usd
+        else:
+            self.estimated_output_tokens = None
+            self.estimated_output_cost_usd = None
+            self.estimated_total_cost_before_usd = None
+            self.estimated_total_cost_after_usd = None
         return self
 
     def summary(self) -> str:
@@ -118,6 +141,14 @@ class CompressionStats:
                 "est. input cost: "
                 f"${before_usd:.6f} -> ${after_usd:.6f} (saved ${saved:.6f})"
             )
+        out_usd = self.estimated_output_cost_usd
+        out_tok = self.estimated_output_tokens
+        if out_usd is not None and out_tok is not None:
+            lines.append(f"est. output cost: ${out_usd:.6f} ({out_tok} tokens)")
+        total_before = self.estimated_total_cost_before_usd
+        total_after = self.estimated_total_cost_after_usd
+        if total_before is not None and total_after is not None:
+            lines.append(f"est. total: ${total_before:.6f} -> ${total_after:.6f}")
         return "\n".join(lines)
 
     def to_dict(self) -> dict[str, Any]:
@@ -145,6 +176,10 @@ class CompressionStats:
             "estimated_input_cost_before_usd": self.estimated_input_cost_before_usd,
             "estimated_input_cost_after_usd": self.estimated_input_cost_after_usd,
             "estimated_cost_saved_usd": self.estimated_cost_saved_usd,
+            "estimated_output_tokens": self.estimated_output_tokens,
+            "estimated_output_cost_usd": self.estimated_output_cost_usd,
+            "estimated_total_cost_before_usd": self.estimated_total_cost_before_usd,
+            "estimated_total_cost_after_usd": self.estimated_total_cost_after_usd,
         }
 
 

contextpress-0.6.3/examples/langchain_roundtrip.py

@@ -0,0 +1,39 @@
+"""LangChain-style objects round-trip through compress() (0.6.3+).
+
+Uses duck-typed message objects (``.type`` / ``.content``), so no LangChain
+install is required. Real ``HumanMessage`` / ``AIMessage`` lists work the same way.
+"""
+
+from __future__ import annotations
+
+from contextpress import ContextManager
+
+
+class Msg:
+    def __init__(self, typ: str, content: str):
+        self.type = typ
+        self.content = content
+
+
+messages = [
+    Msg("system", "You are a concise assistant."),
+    Msg("human", "We've decided on using the new pipeline. Basically just confirm."),
+    Msg("ai", "Sounds good"),
+    Msg("human", "Schedule the api-v2 staging deploy for Monday."),
+    Msg("ai", "Confirmed. Monday staging deploy is scheduled."),
+]
+
+cm = ContextManager(
+    type="chat",
+    model="gpt-4o-mini",
+    compression="high",
+    cost_provider="openai",
+    cost_output_tokens=150,
+)
+result = cm.compress(messages, token_budget=None, return_stats=True)
+
+print(result.summary())
+print()
+for m in result.messages:
+    preview = str(m.content)[:80]
+    print(f"{m.type}: {preview}")

{contextpress-0.6.2 → contextpress-0.6.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "contextpress"
-version = "0.6.2"
+version = "0.6.3"
 description = "Deterministic context compression for LLM chat, RAG, and agent pipelines"
 readme = "README.md"
 license = { file = "LICENSE" }

contextpress-0.6.3/tests/test_v063.py

@@ -0,0 +1,101 @@
+"""0.6.3 — LangChain compress round-trip and output_tokens on cost stats."""
+
+from __future__ import annotations
+
+from contextpress import ContextManager
+from contextpress.stats import CompressionStats
+
+
+class _FakeMsg:
+    def __init__(self, typ: str, content: str):
+        self.type = typ
+        self.content = content
+
+
+def test_langchain_compress_roundtrip_keeps_object_shape():
+    msgs = [
+        _FakeMsg("system", "You are a concise assistant."),
+        _FakeMsg("human", "Summarize the deploy status for api-v2."),
+        _FakeMsg("ai", "Checking logs now."),
+    ]
+    cm = ContextManager(type="chat", compression="low")
+    out = cm.compress(msgs, token_budget=None)
+    assert isinstance(out, list)
+    assert len(out) >= 1
+    assert all(hasattr(m, "content") for m in out)
+    assert out[0].type == "system"
+    assert out[0].content == "You are a concise assistant."
+
+
+def test_langchain_dropped_turn_does_not_remap_roles():
+    """Index-based denormalize would put later content onto the dropped object's type."""
+    msgs = [
+        _FakeMsg("system", "sys"),
+        _FakeMsg("human", "We've decided on using Monday."),
+        _FakeMsg("ai", "Sounds good"),
+        _FakeMsg("human", "Please confirm the Monday plan in detail."),
+        _FakeMsg("ai", "Confirmed. Monday it is, with the new pipeline."),
+    ]
+    original = [(m.type, m.content) for m in msgs]
+    cm = ContextManager(type="chat", compression="high")
+    out = cm.compress(msgs, token_budget=None)
+    assert [(m.type, m.content) for m in msgs] == original
+    types = [getattr(m, "type", None) for m in out]
+    assert types[0] == "system"
+    for m in out:
+        if getattr(m, "type", None) == "human":
+            assert "Sounds good" not in str(m.content)
+
+
+def test_attach_cost_output_tokens():
+    stats = CompressionStats(tokens_before=1_000_000, tokens_after=500_000)
+    stats.attach_cost(provider="openai", model="gpt-4o-mini", output_tokens=100_000)
+    assert stats.estimated_input_cost_before_usd == 0.15
+    assert stats.estimated_input_cost_after_usd == 0.075
+    assert stats.estimated_output_tokens == 100_000
+    assert stats.estimated_output_cost_usd == 0.06
+    assert stats.estimated_total_cost_before_usd == 0.21
+    assert stats.estimated_total_cost_after_usd == 0.135
+    text = stats.summary()
+    assert "est. output cost:" in text
+    assert "100000 tokens" in text
+    assert "est. total:" in text
+    d = stats.to_dict()
+    assert d["estimated_output_cost_usd"] == 0.06
+
+
+def test_attach_cost_zero_output_leaves_output_fields_none():
+    stats = CompressionStats(tokens_before=1000, tokens_after=500)
+    stats.attach_cost(provider="openai", model="gpt-4o-mini", output_tokens=0)
+    assert stats.estimated_output_tokens is None
+    assert stats.estimated_output_cost_usd is None
+    assert "est. output cost" not in stats.summary()
+
+
+def test_compress_output_tokens_kwarg():
+    cm = ContextManager(type="chat", model="gpt-4o-mini", cost_provider="openai")
+    result = cm.compress(
+        [{"role": "user", "content": "hello " * 40}],
+        token_budget=None,
+        return_stats=True,
+        output_tokens=200,
+    )
+    assert result.stats.estimated_output_tokens == 200
+    assert result.stats.estimated_output_cost_usd is not None
+    assert result.stats.estimated_total_cost_after_usd is not None
+    assert "est. total:" in result.summary()
+
+
+def test_cost_output_tokens_constructor_default():
+    cm = ContextManager(
+        type="chat",
+        model="gpt-4o-mini",
+        cost_provider="openai",
+        cost_output_tokens=50,
+    )
+    result = cm.compress(
+        [{"role": "user", "content": "hello " * 20}],
+        token_budget=None,
+        return_stats=True,
+    )
+    assert result.stats.estimated_output_tokens == 50