contextpress 0.1.0__tar.gz → 0.3.0__tar.gz

{contextpress-0.1.0 → contextpress-0.3.0}/.gitignore

@@ -29,3 +29,6 @@ htmlcov/
 *.swp
 .DS_Store
 Thumbs.db
+
+# Secrets (never commit)
+.env

contextpress-0.3.0/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+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.3.0] - 2026-07-14
+
+- **`estimate_tokens(messages)`** — count tokens before compressing (same tiktoken encoding as budget).
+- **Stage registry** — `ContextManager.register_stage()` for custom `BaseStrategy` stages in `stages=[...]`.
+- **Tier 2 `llm_mode`** — `replace_all` (default), `dedupe_only`, or `summarize_only`.
+- Example: `examples/estimate_and_stats.py`.
+
+## [0.2.0] - 2026-05-24
+
+- **`return_stats=True`** on `ContextManager.compress()` returns a `CompressionResult` with token/turn counts, stages run, and per-stage turn deltas.
+- **Tier 2 deduplication** implemented in OpenAI, Anthropic, and Ollama adapters (LLM selects indices to keep).
+- **GitHub Actions CI** runs `pytest` on Python 3.10–3.13.
+- Added **`CONTRIBUTING.md`** with contribution and review expectations.
+
+## [0.1.0] - 2026-04-19
+
+- Initial release by Taha Azizi.
+- Tier 1 pipeline (filler, repetition, resolution, recency, budget) and optional Tier 2 `LLMBackend` (OpenAI, Anthropic, Ollama adapters).

contextpress-0.3.0/CONTRIBUTING.md

@@ -0,0 +1,61 @@
+# Contributing to contextpress
+
+Thank you for your interest in contributing. This project is maintained by [Taha Azizi](https://github.com/Taha-azizi) at a **low cadence**. Bug fixes are welcome; large feature work may be better suited to a fork if you need it quickly.
+
+## Before you start
+
+- Read the [Project Status](README.md#project-status) section in the README.
+- Search [existing issues](https://github.com/Taha-azizi/contextpress/issues) before opening a duplicate.
+- Expect a **2–4 week** review cycle for pull requests.
+
+## Branches
+
+| Branch | Purpose |
+|--------|---------|
+| **`dev`** | Active development — **branch from here, open PRs here** |
+| **`main`** | Stable releases (merged from `dev` at release time) |
+
+After cloning:
+
+```bash
+git checkout dev
+```
+
+## How to contribute
+
+1. **Fork** the repository and create a feature branch from **`dev`** (not `main`).
+2. **Set up** a local environment:
+   ```bash
+   pip install -e ".[dev]"
+   pytest tests -q
+   ```
+3. **Make focused changes** — one logical change per PR when possible.
+4. **Add or update tests** for behavior you change. Tier 1 tests must stay deterministic (no live LLM calls in `tests/`).
+5. **Open a pull request** targeting **`dev`** with:
+   - A short summary of *why* the change is needed
+   - How you tested it (`pytest tests -q`, etc.)
+   - A note if you changed public API (update `CHANGELOG.md`)
+
+## Code guidelines
+
+- Match existing style in the file you edit.
+- Do not break the [behavior contract](contextpress/pipeline.py) at the top of `pipeline.py`.
+- System turns stay protected; input is never mutated in place.
+- Keep Tier 1 deterministic — mock LLM backends in tests.
+
+## Reporting bugs
+
+Open a [GitHub issue](https://github.com/Taha-azizi/contextpress/issues) with:
+
+- Python version
+- `contextpress` version (`pip show contextpress`)
+- Minimal input that reproduces the problem
+- Expected vs actual behavior
+
+## Feature requests
+
+Feature requests may be accepted, deferred, or closed with a suggestion to fork. That is not a rejection of the idea — it reflects limited maintenance bandwidth.
+
+## License
+
+By contributing, you agree that your contributions are licensed under the [Apache License 2.0](LICENSE).

{contextpress-0.1.0 → contextpress-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: contextpress
-Version: 0.1.0
+Version: 0.3.0
 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
@@ -282,6 +282,35 @@ compressed = cm.compress(messages, token_budget=2000)
 
 No API keys are required for Tier 1. Passing **`token_budget`** turns on the **budget** stage; other stages follow the chosen **compression** preset (`low` / `medium` / `high`).
 
+Pass **`return_stats=True`** to get a `CompressionResult` with `messages` and compression stats (token counts, stages run, turn deltas):
+
+```python
+result = cm.compress(messages, token_budget=2000, return_stats=True)
+print(result.stats.tokens_saved, result.stats.stages_run)
+compressed = result.messages
+```
+
+Check token count **before** compressing:
+
+```python
+before = cm.estimate_tokens(messages)
+```
+
+### Custom stages (0.3+)
+
+Register a `BaseStrategy` and include it in `stages=`:
+
+```python
+from contextpress.strategies.base import BaseStrategy
+
+class MyStage(BaseStrategy):
+    def process(self, conversation):
+        ...
+
+cm.register_stage("my_stage", MyStage)
+out = cm.compress(messages, stages=["filler", "my_stage", "budget"], token_budget=500)
+```
+
 ### Minimal examples
 
 ```python
@@ -397,7 +426,9 @@ After **Tier 1** finishes, you can attach an **`LLMBackend`** for semantic compr
 2. If the combined transcript is long enough (default **1500** characters; set **`llm_min_input_chars=0`** to always run), calls **`summarize(transcript, max_tokens)`**.
 3. **System turns are unchanged** in order and content. **All other turns are replaced** by a **single assistant** message whose content is the LLM summary (metadata includes `source: contextpress_llm_tier`). If the LLM call fails, the Tier 1 conversation is returned and a **warning** is emitted.
 
-Optional constructor knobs: **`llm_min_input_chars`**, **`llm_max_summary_tokens`**.
+Optional constructor knobs: **`llm_min_input_chars`**, **`llm_max_summary_tokens`**, **`llm_mode`**.
+
+**`llm_mode`** (0.3+): `replace_all` (default — dedupe then one summary turn), `dedupe_only` (dedupe, keep turns), `summarize_only` (append summary, keep turns).
 
 **Install SDKs** (not bundled): `pip install openai`, `anthropic`, and/or **`ollama`** (for local Ollama), or `pip install "contextpress[llm]"` from this repo’s `pyproject.toml` to pull all optional LLM clients.
 

{contextpress-0.1.0 → contextpress-0.3.0}/README.md

@@ -42,6 +42,35 @@ compressed = cm.compress(messages, token_budget=2000)
 
 No API keys are required for Tier 1. Passing **`token_budget`** turns on the **budget** stage; other stages follow the chosen **compression** preset (`low` / `medium` / `high`).
 
+Pass **`return_stats=True`** to get a `CompressionResult` with `messages` and compression stats (token counts, stages run, turn deltas):
+
+```python
+result = cm.compress(messages, token_budget=2000, return_stats=True)
+print(result.stats.tokens_saved, result.stats.stages_run)
+compressed = result.messages
+```
+
+Check token count **before** compressing:
+
+```python
+before = cm.estimate_tokens(messages)
+```
+
+### Custom stages (0.3+)
+
+Register a `BaseStrategy` and include it in `stages=`:
+
+```python
+from contextpress.strategies.base import BaseStrategy
+
+class MyStage(BaseStrategy):
+    def process(self, conversation):
+        ...
+
+cm.register_stage("my_stage", MyStage)
+out = cm.compress(messages, stages=["filler", "my_stage", "budget"], token_budget=500)
+```
+
 ### Minimal examples
 
 ```python
@@ -157,7 +186,9 @@ After **Tier 1** finishes, you can attach an **`LLMBackend`** for semantic compr
 2. If the combined transcript is long enough (default **1500** characters; set **`llm_min_input_chars=0`** to always run), calls **`summarize(transcript, max_tokens)`**.
 3. **System turns are unchanged** in order and content. **All other turns are replaced** by a **single assistant** message whose content is the LLM summary (metadata includes `source: contextpress_llm_tier`). If the LLM call fails, the Tier 1 conversation is returned and a **warning** is emitted.
 
-Optional constructor knobs: **`llm_min_input_chars`**, **`llm_max_summary_tokens`**.
+Optional constructor knobs: **`llm_min_input_chars`**, **`llm_max_summary_tokens`**, **`llm_mode`**.
+
+**`llm_mode`** (0.3+): `replace_all` (default — dedupe then one summary turn), `dedupe_only` (dedupe, keep turns), `summarize_only` (append summary, keep turns).
 
 **Install SDKs** (not bundled): `pip install openai`, `anthropic`, and/or **`ollama`** (for local Ollama), or `pip install "contextpress[llm]"` from this repo’s `pyproject.toml` to pull all optional LLM clients.
 

{contextpress-0.1.0 → contextpress-0.3.0}/contextpress/__init__.py

@@ -4,15 +4,22 @@ from typing import Any
 
 from contextpress._bootstrap import bootstrap_nltk
 from contextpress.models import ContentBlock, Conversation, Turn
+from contextpress.stats import CompressionResult, CompressionStats
 
 bootstrap_nltk()
 
-__all__ = ["ContextManager", "Turn", "Conversation", "ContentBlock"]
-__version__ = "0.1.0"
+__all__ = [
+    "ContextManager",
+    "Turn",
+    "Conversation",
+    "ContentBlock",
+    "CompressionResult",
+    "CompressionStats",
+]
+__version__ = "0.3.0"
 
 
 def __getattr__(name: str) -> Any:
-    # Lazy import: ContextManager -> core -> pipeline -> strategies (sumy, etc.)
     if name == "ContextManager":
         from contextpress.core import ContextManager
 

{contextpress-0.1.0 → contextpress-0.3.0}/contextpress/compression.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from contextpress.profiles import Profile
+from contextpress.profiles import Profile, StageConfig
 
 STAGE_ORDER: tuple[str, ...] = (
     "filler",
@@ -14,6 +14,14 @@ STAGE_ORDER: tuple[str, ...] = (
 
 VALID_STAGES = frozenset(STAGE_ORDER)
 
+
+def known_stages() -> frozenset[str]:
+    """Built-in plus registered custom stage names."""
+    from contextpress.registry import registered_stage_names
+
+    return VALID_STAGES | registered_stage_names()
+
+
 _NON_BUDGET_ORDER: tuple[str, ...] = tuple(s for s in STAGE_ORDER if s != "budget")
 
 # NLP stages only; budget is toggled from token_budget (see apply_stage_selection)
@@ -38,6 +46,7 @@ __all__ = [
     "STAGE_ORDER",
     "VALID_STAGES",
     "apply_stage_selection",
+    "known_stages",
     "normalize_compression_level",
 ]
 
@@ -60,6 +69,7 @@ def apply_stage_selection(
     stages: list[str] | None,
     disable: list[str] | None,
     token_budget: int | None,
+    custom_stages: dict[str, StageConfig] | None = None,
 ) -> None:
     """
     Mutates ``profile`` in place: sets each stage's ``enabled`` from explicit
@@ -70,12 +80,15 @@ def apply_stage_selection(
     if stages is not None:
         if not stages:
             raise ValueError("stages= must list at least one stage name when provided")
-        unknown = [s for s in stages if s not in VALID_STAGES]
+        unknown = [s for s in stages if s not in known_stages()]
         if unknown:
-            raise ValueError(f"unknown stage name(s): {unknown}; valid: {sorted(VALID_STAGES)}")
+            raise ValueError(f"unknown stage name(s): {unknown}; valid: {sorted(known_stages())}")
         want = frozenset(stages)
         for name in _NON_BUDGET_ORDER:
             getattr(profile, name).enabled = name in want
+        if custom_stages:
+            for name, cfg in custom_stages.items():
+                cfg.enabled = name in want
     else:
         level = normalize_compression_level(compression)
         preset = _COMPRESSION_PRESETS[level]
@@ -85,6 +98,9 @@ def apply_stage_selection(
 
     if disable:
         for name in disable:
+            if custom_stages and name in custom_stages:
+                custom_stages[name].enabled = False
+                continue
             if not hasattr(profile, name):
                 continue
             getattr(profile, name).enabled = False
@@ -98,4 +114,4 @@ def apply_stage_selection(
         if disable and "budget" in disable:
             profile.budget.enabled = False
         else:
-            profile.budget.enabled = getattr(base_profile, "budget").enabled
+            profile.budget.enabled = base_profile.budget.enabled

{contextpress-0.1.0 → contextpress-0.3.0}/contextpress/core.py

@@ -6,11 +6,16 @@ from typing import TYPE_CHECKING, Any
 
 from contextpress.compression import apply_stage_selection, normalize_compression_level
 from contextpress.normalizer import denormalize_output, normalize_messages
-from contextpress.pipeline import Pipeline
+from contextpress.pipeline import VALID_LLM_MODES, Pipeline
 from contextpress.profiles import PROFILES, Profile, StageConfig
+from contextpress.registry import register_stage as _register_stage
+from contextpress.stats import CompressionResult, CompressionStats, count_conversation_tokens
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     from contextpress.llm.base import LLMBackend
+    from contextpress.strategies.base import BaseStrategy
 
 
 def _validate_token_budget(token_budget: int | None) -> None:
@@ -38,9 +43,14 @@ class ContextManager:
         compression: str = "medium",
         llm_min_input_chars: int = 1500,
         llm_max_summary_tokens: int = 2048,
+        llm_mode: str = "replace_all",
     ):
         if type not in PROFILES:
             raise ValueError(f"unknown context type {type!r}")
+        if llm_mode not in VALID_LLM_MODES:
+            raise ValueError(
+                f"unknown llm_mode {llm_mode!r}; use one of: {sorted(VALID_LLM_MODES)}"
+            )
         self._type = type
         self._profile: Profile = copy.deepcopy(PROFILES[type])
         self._compression: str = normalize_compression_level(compression)
@@ -48,6 +58,25 @@ class ContextManager:
         self.llm_backend = llm_backend
         self.llm_min_input_chars = int(llm_min_input_chars)
         self.llm_max_summary_tokens = int(llm_max_summary_tokens)
+        self.llm_mode = llm_mode
+        self._custom_stages: dict[str, StageConfig] = {}
+
+    def estimate_tokens(self, messages: Any, *, model: str | None = None) -> int:
+        """Count tokens for ``messages`` using the same encoding as the budget stage."""
+        conv, _ = normalize_messages(messages, context_type=self._type)
+        return count_conversation_tokens(conv, model if model is not None else self.model)
+
+    def register_stage(
+        self,
+        name: str,
+        factory: Callable[..., BaseStrategy],
+        *,
+        before: str = "budget",
+        aggressiveness: float = 0.5,
+    ) -> None:
+        """Register a custom pipeline stage (see ``contextpress.registry``)."""
+        _register_stage(name, factory, before=before)
+        self._custom_stages[name] = StageConfig(enabled=False, aggressiveness=aggressiveness)
 
     def compress(
         self,
@@ -57,23 +86,29 @@ class ContextManager:
         compression: str | None = None,
         stages: list[str] | None = None,
         disable: list[str] | None = None,
-    ) -> Any:
+        return_stats: bool = False,
+    ) -> Any | CompressionResult:
         """Run the pipeline; return value matches input shape (dict list, tuples, strings, etc.).
 
         ``token_budget`` must be a positive int or None. Unknown keys in ``disable`` are ignored.
+        With ``return_stats=True``, returns a ``CompressionResult`` with ``messages`` and ``stats``.
         """
         _validate_token_budget(token_budget)
+        level = compression if compression is not None else self._compression
         profile = copy.deepcopy(self._profile)
+        custom_stages = copy.deepcopy(self._custom_stages)
         apply_stage_selection(
             profile,
             base_profile=self._profile,
-            compression=compression if compression is not None else self._compression,
+            compression=level,
             stages=stages,
             disable=disable,
             token_budget=token_budget,
+            custom_stages=custom_stages,
         )
 
         conv, ctx = normalize_messages(messages, context_type=self._type)
+        stats = CompressionStats(compression_level=level) if return_stats else None
         pipeline = Pipeline(
             profile,
             token_budget=token_budget,
@@ -81,19 +116,28 @@ class ContextManager:
             llm_backend=self.llm_backend,
             llm_min_input_chars=self.llm_min_input_chars,
             llm_max_summary_tokens=self.llm_max_summary_tokens,
+            llm_mode=self.llm_mode,
+            custom_stages=custom_stages,
         )
-        out = pipeline.run(conv)
-        return denormalize_output(out, ctx)
+        out = pipeline.run(conv, stats=stats)
+        messages_out = denormalize_output(out, ctx)
+        if return_stats:
+            assert stats is not None
+            return CompressionResult(messages=messages_out, stats=stats)
+        return messages_out
 
     def set_compression(self, compression: str) -> None:
         """Change the default preset for subsequent ``compress()`` calls (low / medium / high)."""
         self._compression = normalize_compression_level(compression)
 
     def configure(self, stage: str, **kwargs: Any) -> None:
-        """Patch ``StageConfig`` fields on the live profile (e.g. ``aggressiveness``, ``enabled``)."""
-        if not hasattr(self._profile, stage):
+        """Patch ``StageConfig`` fields on the live profile (e.g. aggressiveness, enabled)."""
+        if stage in self._custom_stages:
+            sc = self._custom_stages[stage]
+        elif hasattr(self._profile, stage):
+            sc = getattr(self._profile, stage)
+        else:
             raise ValueError(f"unknown stage {stage!r}")
-        sc: StageConfig = getattr(self._profile, stage)
         for k, v in kwargs.items():
             if hasattr(sc, k):
                 setattr(sc, k, v)

contextpress-0.3.0/contextpress/llm/_helpers.py

@@ -0,0 +1,57 @@
+"""Shared helpers for Tier 2 LLM adapters."""
+
+from __future__ import annotations
+
+import json
+import re
+
+
+def parse_keep_indices(raw: str, n: int) -> list[int]:
+    """Parse an LLM response into sorted unique turn indices to keep."""
+    if n <= 0:
+        return []
+    if n == 1:
+        return [0]
+
+    text = (raw or "").strip()
+    if not text:
+        return list(range(n))
+
+    # JSON array: [0, 2, 4]
+    if text.startswith("["):
+        try:
+            data = json.loads(text)
+            if isinstance(data, list):
+                return _validate_indices(data, n)
+        except json.JSONDecodeError:
+            pass
+
+    # Comma / space separated: 0, 2, 4
+    nums = re.findall(r"\d+", text)
+    if nums:
+        return _validate_indices([int(x) for x in nums], n)
+
+    return list(range(n))
+
+
+def _validate_indices(values: list[int], n: int) -> list[int]:
+    valid = sorted({i for i in values if isinstance(i, int) and 0 <= i < n})
+    return valid if valid else list(range(n))
+
+
+def format_numbered_turns(turns: list[str], *, max_chars: int = 800) -> str:
+    lines: list[str] = []
+    for i, text in enumerate(turns):
+        snippet = text.strip().replace("\n", " ")
+        if len(snippet) > max_chars:
+            snippet = snippet[: max_chars - 3] + "..."
+        lines.append(f"{i}: {snippet}")
+    return "\n".join(lines)
+
+
+DEDUP_SYSTEM_PROMPT = (
+    "You deduplicate conversation turns. Given numbered turns, return ONLY the 0-based "
+    "indices of turns to KEEP as a comma-separated list (example: 0,2,5). "
+    "When turns repeat the same idea, keep the most recent index. "
+    "Always keep at least one turn. Output nothing else."
+)

{contextpress-0.1.0 → contextpress-0.3.0}/contextpress/llm/adapters.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import warnings
 from typing import Any
 
-
+from contextpress.llm._helpers import DEDUP_SYSTEM_PROMPT, format_numbered_turns, parse_keep_indices
 from contextpress.llm.base import LLMBackend
 
 
@@ -60,7 +60,24 @@ class OpenAIBackend(LLMBackend):
             raise
 
     def deduplicate(self, turns: list[str]) -> list[int]:
-        return list(range(len(turns)))
+        if len(turns) <= 1:
+            return list(range(len(turns)))
+        prompt = format_numbered_turns(turns)
+        try:
+            resp = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": DEDUP_SYSTEM_PROMPT},
+                    {"role": "user", "content": prompt},
+                ],
+                max_tokens=128,
+                temperature=0,
+            )
+            content = resp.choices[0].message.content or ""
+            return parse_keep_indices(content, len(turns))
+        except Exception as exc:
+            warnings.warn(f"contextpress OpenAIBackend.deduplicate failed: {exc}", stacklevel=2)
+            return list(range(len(turns)))
 
 
 class AnthropicBackend(LLMBackend):
@@ -98,7 +115,24 @@ class AnthropicBackend(LLMBackend):
             raise
 
     def deduplicate(self, turns: list[str]) -> list[int]:
-        return list(range(len(turns)))
+        if len(turns) <= 1:
+            return list(range(len(turns)))
+        prompt = format_numbered_turns(turns)
+        try:
+            msg = self.client.messages.create(
+                model=self.model,
+                max_tokens=128,
+                system=DEDUP_SYSTEM_PROMPT,
+                messages=[{"role": "user", "content": prompt}],
+            )
+            parts = []
+            for b in msg.content:
+                if hasattr(b, "text"):
+                    parts.append(b.text)
+            return parse_keep_indices("".join(parts), len(turns))
+        except Exception as exc:
+            warnings.warn(f"contextpress AnthropicBackend.deduplicate failed: {exc}", stacklevel=2)
+            return list(range(len(turns)))
 
 
 class OllamaBackend(LLMBackend):
@@ -171,4 +205,19 @@ class OllamaBackend(LLMBackend):
             raise
 
     def deduplicate(self, turns: list[str]) -> list[int]:
-        return list(range(len(turns)))
+        if len(turns) <= 1:
+            return list(range(len(turns)))
+        prompt = format_numbered_turns(turns)
+        try:
+            resp = self._client.chat(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": DEDUP_SYSTEM_PROMPT},
+                    {"role": "user", "content": prompt},
+                ],
+                options={"num_predict": 128, "temperature": 0},
+            )
+            return parse_keep_indices(_ollama_response_text(resp), len(turns))
+        except Exception as exc:
+            warnings.warn(f"contextpress OllamaBackend.deduplicate failed: {exc}", stacklevel=2)
+            return list(range(len(turns)))

{contextpress-0.1.0 → contextpress-0.3.0}/contextpress/models.py

@@ -32,7 +32,9 @@ class Turn:
     importance: float = 1.0  # set by pipeline stages, 0.0–1.0
     resolved: bool = False  # True when flagged by resolution detector
     compressed: bool = False  # True if content was modified by pipeline
-    original_content: str | list[ContentBlock] | None = None  # preserves original before compression
+    original_content: str | list[ContentBlock] | None = (
+        None  # preserves original before compression
+    )
 
 
 @dataclass

{contextpress-0.1.0 → contextpress-0.3.0}/contextpress/normalizer.py

@@ -52,8 +52,14 @@ def _blocks_from_openai_style(items: list[dict[str, Any]]) -> list[ContentBlock]
             url = ""
             if "image_url" in item:
                 iu = item["image_url"]
-                url = iu if isinstance(iu, str) else (iu.get("url", "") if isinstance(iu, dict) else "")
-            blocks.append(ContentBlock(type="image", content=url or str(item), metadata=copy.deepcopy(item)))
+                url = (
+                    iu
+                    if isinstance(iu, str)
+                    else (iu.get("url", "") if isinstance(iu, dict) else "")
+                )
+            blocks.append(
+                ContentBlock(type="image", content=url or str(item), metadata=copy.deepcopy(item))
+            )
         else:
             blocks.append(
                 ContentBlock(
@@ -83,12 +89,13 @@ def _blocks_to_openai_style(blocks: list[ContentBlock]) -> list[dict[str, Any]]:
             else:
                 out.append({"type": "image_url", "image_url": {"url": b.content}})
         else:
-            out.append(copy.deepcopy(b.metadata) if b.metadata else {"type": b.type, "content": b.content})
+            out.append(
+                copy.deepcopy(b.metadata) if b.metadata else {"type": b.type, "content": b.content}
+            )
     return out
 
 
 def _get_lc_role_and_content(obj: Any) -> tuple[str, str | list[ContentBlock], dict[str, Any]]:
-    meta: dict[str, Any] = {}
     role = None
     if hasattr(obj, "type") and obj.type is not None:
         role = _LC_TYPE_MAP.get(str(obj.type).lower(), str(obj.type).lower())
@@ -101,7 +108,11 @@ def _get_lc_role_and_content(obj: Any) -> tuple[str, str | list[ContentBlock], d
         blocks = []
         for part in content:
             if isinstance(part, dict) and part.get("type") == "text":
-                blocks.append(ContentBlock(type="text", content=part.get("text", ""), metadata=copy.deepcopy(part)))
+                blocks.append(
+                    ContentBlock(
+                        type="text", content=part.get("text", ""), metadata=copy.deepcopy(part)
+                    )
+                )
             elif isinstance(part, str):
                 blocks.append(ContentBlock(type="text", content=part))
             else:
@@ -176,7 +187,9 @@ def normalize_messages(
         turns = []
         for i, raw in enumerate(messages):
             if not isinstance(raw, dict):
-                warnings.warn(f"contextpress: unknown message shape at index {i}, skipping", stacklevel=2)
+                warnings.warn(
+                    f"contextpress: unknown message shape at index {i}, skipping", stacklevel=2
+                )
                 continue
             d = copy.deepcopy(raw)
             role = str(d.get("role", "user")).lower()
@@ -292,7 +305,9 @@ def apply_text_to_turn(turn: Turn, new_text: str) -> Turn:
             importance=turn.importance,
             resolved=turn.resolved,
             compressed=True,
-            original_content=turn.original_content if turn.original_content is not None else turn.content,
+            original_content=(
+                turn.original_content if turn.original_content is not None else turn.content
+            ),
         )
     new_blocks: list[ContentBlock] = []
     text_assigned = False
@@ -304,7 +319,9 @@ def apply_text_to_turn(turn: Turn, new_text: str) -> Turn:
             new_blocks.append(copy.deepcopy(b))
     if not text_assigned:
         new_blocks.insert(0, ContentBlock(type="text", content=new_text))
-    orig = turn.original_content if turn.original_content is not None else copy.deepcopy(turn.content)
+    orig = (
+        turn.original_content if turn.original_content is not None else copy.deepcopy(turn.content)
+    )
     return Turn(
         role=turn.role,
         content=new_blocks,