contextpress 0.2.0__tar.gz → 0.3.0__tar.gz

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

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

{contextpress-0.2.0 → contextpress-0.3.0}/CHANGELOG.md

@@ -4,6 +4,13 @@ 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.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: contextpress
-Version: 0.2.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
@@ -290,6 +290,27 @@ 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
@@ -405,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.2.0 → contextpress-0.3.0}/README.md

@@ -50,6 +50,27 @@ 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
@@ -165,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.2.0 → contextpress-0.3.0}/contextpress/__init__.py

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

{contextpress-0.2.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

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

@@ -6,12 +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.stats import CompressionResult, CompressionStats
+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:
@@ -39,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)
@@ -49,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,
@@ -68,6 +96,7 @@ class ContextManager:
         _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,
@@ -75,6 +104,7 @@ class ContextManager:
             stages=stages,
             disable=disable,
             token_budget=token_budget,
+            custom_stages=custom_stages,
         )
 
         conv, ctx = normalize_messages(messages, context_type=self._type)
@@ -86,6 +116,8 @@ 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, stats=stats)
         messages_out = denormalize_output(out, ctx)
@@ -100,9 +132,12 @@ class ContextManager:
 
     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):
+        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.2.0 → contextpress-0.3.0}/contextpress/pipeline.py

@@ -27,6 +27,11 @@ from contextpress.compression import STAGE_ORDER
 from contextpress.models import Conversation, Turn
 from contextpress.normalizer import extract_text_for_processing
 from contextpress.profiles import Profile, StageConfig
+from contextpress.registry import (
+    build_custom_strategy,
+    effective_stage_order,
+    registered_stage_names,
+)
 from contextpress.stats import CompressionStats, count_conversation_tokens
 from contextpress.strategies.base import BaseStrategy
 from contextpress.strategies.budget import BudgetStrategy
@@ -38,6 +43,8 @@ from contextpress.strategies.resolution import ResolutionStrategy
 if TYPE_CHECKING:
     from contextpress.llm.base import LLMBackend
 
+VALID_LLM_MODES = frozenset({"replace_all", "dedupe_only", "summarize_only"})
+
 
 def clone_turn(t: Turn) -> Turn:
     if isinstance(t.content, str):
@@ -80,6 +87,8 @@ class Pipeline:
         *,
         llm_min_input_chars: int = 1500,
         llm_max_summary_tokens: int = 2048,
+        llm_mode: str = "replace_all",
+        custom_stages: dict[str, StageConfig] | None = None,
     ):
         self.profile = profile
         self.token_budget = token_budget
@@ -87,6 +96,12 @@ class Pipeline:
         self.llm_backend = llm_backend  # None = Tier 1 only
         self.llm_min_input_chars = max(0, int(llm_min_input_chars))
         self.llm_max_summary_tokens = max(64, int(llm_max_summary_tokens))
+        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.llm_mode = llm_mode
+        self.custom_stages = custom_stages or {}
 
     def run(
         self,
@@ -100,11 +115,12 @@ class Pipeline:
             stats.token_budget = self.token_budget
 
         result = clone_conversation(conversation)
-        for stage_name in self.STAGE_ORDER:
+        stage_order = effective_stage_order()
+        for stage_name in stage_order:
             if stage_name == "budget" and self.token_budget is None:
                 continue
-            stage_config = getattr(self.profile, stage_name)
-            if not stage_config.enabled:
+            stage_config = self._stage_config(stage_name)
+            if stage_config is None or not stage_config.enabled:
                 continue
             before_turns = len(result.turns)
             strategy = self._build_strategy(stage_name, stage_config)
@@ -124,12 +140,26 @@ class Pipeline:
 
         return result
 
+    def _stage_config(self, name: str) -> StageConfig | None:
+        if name in self.custom_stages:
+            return self.custom_stages[name]
+        if hasattr(self.profile, name):
+            return getattr(self.profile, name)
+        return None
+
     def _build_strategy(self, name: str, config: StageConfig) -> BaseStrategy:
         kwargs: dict[str, Any] = {
             "aggressiveness": config.aggressiveness,
             "conv_type": self.profile.name,
             "role_aware": self.profile.role_aware,
         }
+        if name in registered_stage_names():
+            return build_custom_strategy(
+                name,
+                config,
+                conv_type=self.profile.name,
+                role_aware=self.profile.role_aware,
+            )
         if name == "filler":
             return FillerStrategy(**kwargs)
         if name == "repetition":
@@ -166,25 +196,36 @@ class Pipeline:
             stats.llm_dedup_turns_before = len(ns_turns)
 
         texts = [extract_text_for_processing(t) for t in ns_turns]
-        try:
-            keep_idx = self.llm_backend.deduplicate(texts)
-        except Exception:
-            keep_idx = list(range(len(ns_turns)))
-        valid = sorted(
-            {
-                i
-                for i in keep_idx
-                if type(i) is int and not isinstance(i, bool) and 0 <= i < len(ns_turns)
-            }
-        )
-        if not valid:
-            valid = list(range(len(ns_turns)))
-        if len(valid) < len(ns_turns):
-            ns_turns = [ns_turns[i] for i in valid]
-            texts = [texts[i] for i in valid]
+        if self.llm_mode in ("replace_all", "dedupe_only"):
+            try:
+                keep_idx = self.llm_backend.deduplicate(texts)
+            except Exception:
+                keep_idx = list(range(len(ns_turns)))
+            valid = sorted(
+                {
+                    i
+                    for i in keep_idx
+                    if type(i) is int and not isinstance(i, bool) and 0 <= i < len(ns_turns)
+                }
+            )
+            if not valid:
+                valid = list(range(len(ns_turns)))
+            if len(valid) < len(ns_turns):
+                ns_turns = [ns_turns[i] for i in valid]
+                texts = [texts[i] for i in valid]
 
-        if stats is not None:
-            stats.llm_dedup_turns_after = len(ns_turns)
+            if stats is not None:
+                stats.llm_dedup_turns_after = len(ns_turns)
+
+            if self.llm_mode == "dedupe_only":
+                new_turns = list(system_turns) + [clone_turn(t) for t in ns_turns]
+                if stats is not None:
+                    stats.llm_tier_applied = True
+                return Conversation(
+                    turns=new_turns,
+                    type=conversation.type,
+                    metadata=copy.deepcopy(conversation.metadata),
+                )
 
         lines = [f"{t.role}: {txt}" for t, txt in zip(ns_turns, texts, strict=True)]
         combined = "\n\n".join(lines)
@@ -207,6 +248,22 @@ class Pipeline:
         if stats is not None:
             stats.llm_tier_applied = True
 
+        if self.llm_mode == "summarize_only":
+            new_turns = list(system_turns) + [clone_turn(t) for t in ns_turns]
+            new_turns.append(
+                Turn(
+                    role="assistant",
+                    content=summary,
+                    metadata={"source": "contextpress_llm_tier", "mode": "summarize_only"},
+                    compressed=True,
+                )
+            )
+            return Conversation(
+                turns=new_turns,
+                type=conversation.type,
+                metadata=copy.deepcopy(conversation.metadata),
+            )
+
         new_turns: list[Turn] = list(system_turns)
         new_turns.append(
             Turn(

contextpress-0.3.0/contextpress/registry.py

@@ -0,0 +1,85 @@
+"""Register custom pipeline stages without subclassing ``Pipeline``."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from contextpress.profiles import StageConfig
+from contextpress.strategies.base import BaseStrategy
+
+# (name, factory, insert_before)
+_CustomEntry = tuple[str, Callable[..., BaseStrategy], str]
+_REGISTRY: list[_CustomEntry] = []
+
+
+def _builtin_stages() -> tuple[str, ...]:
+    from contextpress.compression import STAGE_ORDER
+
+    return STAGE_ORDER
+
+
+def register_stage(
+    name: str,
+    factory: Callable[..., BaseStrategy],
+    *,
+    before: str = "budget",
+) -> None:
+    """Register a custom stage factory.
+
+    ``factory`` receives ``aggressiveness``, ``conv_type``, ``role_aware``, and
+    optional ``**kwargs`` — same as built-in strategies. Custom stages run when
+    named in ``stages=`` on ``compress()``.
+
+    Parameters
+    ----------
+    name:
+        Unique stage name (must not collide with a built-in stage).
+    before:
+        Built-in or custom stage name to insert before (default: ``budget``).
+    """
+    if not name or name in _builtin_stages():
+        raise ValueError(f"cannot register stage {name!r}: name invalid or reserved")
+    if any(e[0] == name for e in _REGISTRY):
+        raise ValueError(f"stage {name!r} is already registered")
+    _REGISTRY.append((name, factory, before))
+
+
+def registered_stage_names() -> frozenset[str]:
+    return frozenset(name for name, _, _ in _REGISTRY)
+
+
+def clear_registry() -> None:
+    """Remove all custom stages (for tests)."""
+    _REGISTRY.clear()
+
+
+def effective_stage_order() -> list[str]:
+    """Built-in ``STAGE_ORDER`` with registered custom stages inserted."""
+    order = list(_builtin_stages())
+    for name, _, before in _REGISTRY:
+        if before not in order:
+            raise RuntimeError(f"custom stage {name!r}: anchor {before!r} not in stage order")
+        order.insert(order.index(before), name)
+    return order
+
+
+def build_custom_strategy(
+    name: str,
+    config: StageConfig,
+    *,
+    conv_type: str,
+    role_aware: bool,
+    extra_kwargs: dict[str, Any] | None = None,
+) -> BaseStrategy:
+    for reg_name, factory, _ in _REGISTRY:
+        if reg_name == name:
+            kwargs: dict[str, Any] = {
+                "aggressiveness": config.aggressiveness,
+                "conv_type": conv_type,
+                "role_aware": role_aware,
+            }
+            if extra_kwargs:
+                kwargs.update(extra_kwargs)
+            return factory(**kwargs)
+    raise ValueError(f"no registered factory for custom stage {name!r}")

contextpress-0.3.0/examples/estimate_and_stats.py

@@ -0,0 +1,21 @@
+"""Estimate tokens before compressing, then inspect stats after."""
+
+from contextpress import ContextManager
+
+messages = [
+    {"role": "system", "content": "You are helpful."},
+    {"role": "user", "content": "Old topic: " + "blah " * 50},
+    {"role": "assistant", "content": "Basically, honestly, " + "yak " * 50},
+    {"role": "user", "content": "What is 2+2?"},
+    {"role": "assistant", "content": "Four."},
+]
+
+cm = ContextManager(type="chat", compression="medium")
+before = cm.estimate_tokens(messages)
+print("tokens before:", before)
+
+result = cm.compress(messages, token_budget=200, return_stats=True)
+print("tokens after:", result.stats.tokens_after)
+print("saved:", result.stats.tokens_saved)
+print("stages:", result.stats.stages_run)
+print("turns:", result.stats.turns_before, "->", result.stats.turns_after)

{contextpress-0.2.0 → contextpress-0.3.0}/pyproject.toml

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

contextpress-0.3.0/tests/test_v03.py

@@ -0,0 +1,128 @@
+import copy
+
+import pytest
+
+from contextpress import ContextManager
+from contextpress.compression import known_stages
+from contextpress.models import Conversation, Turn
+from contextpress.pipeline import Pipeline
+from contextpress.profiles import PROFILES
+from contextpress.registry import clear_registry, register_stage
+from contextpress.strategies.base import BaseStrategy
+
+
+class _DropMarkedStrategy(BaseStrategy):
+    def process(self, conversation: Conversation) -> Conversation:
+        kept = [
+            copy.deepcopy(t)
+            for t in conversation.turns
+            if t.role == "system"
+            or "DROP" not in (t.content if isinstance(t.content, str) else str(t.content))
+        ]
+        return Conversation(
+            turns=kept,
+            type=conversation.type,
+            metadata=copy.deepcopy(conversation.metadata),
+        )
+
+
+@pytest.fixture(autouse=True)
+def _reset_registry():
+    clear_registry()
+    yield
+    clear_registry()
+
+
+def test_estimate_tokens_dict_list():
+    cm = ContextManager(type="chat")
+    messages = [
+        {"role": "user", "content": "Hello world"},
+        {"role": "assistant", "content": "Hi there"},
+    ]
+    n = cm.estimate_tokens(messages)
+    assert isinstance(n, int) and n > 0
+
+
+def test_register_stage_and_run():
+    cm = ContextManager(type="chat")
+    cm.register_stage("drop_marked", _DropMarkedStrategy)
+    assert "drop_marked" in known_stages()
+    messages = [
+        {"role": "user", "content": "keep me"},
+        {"role": "assistant", "content": "DROP this turn"},
+    ]
+    out = cm.compress(messages, stages=["drop_marked"])
+    assert len(out) == 1
+    assert out[0]["content"] == "keep me"
+
+
+def test_register_stage_reserved_name_raises():
+    with pytest.raises(ValueError):
+        register_stage("filler", _DropMarkedStrategy)
+
+
+def test_configure_custom_stage():
+    cm = ContextManager(type="chat")
+    cm.register_stage("drop_marked", _DropMarkedStrategy, aggressiveness=0.2)
+    cm.configure("drop_marked", aggressiveness=0.9)
+    assert cm._custom_stages["drop_marked"].aggressiveness == 0.9
+
+
+class _DedupOnlyBackend:
+    def summarize(self, text: str, max_tokens: int) -> str:
+        raise AssertionError("summarize should not run in dedupe_only mode")
+
+    def deduplicate(self, turns: list[str]) -> list[int]:
+        return [0]
+
+
+class _SummarizeOnlyBackend:
+    def summarize(self, text: str, max_tokens: int) -> str:
+        return "summary appended"
+
+    def deduplicate(self, turns: list[str]) -> list[int]:
+        raise AssertionError("deduplicate should not run in summarize_only mode")
+
+
+def test_llm_mode_dedupe_only():
+    conv = Conversation(
+        turns=[
+            Turn(role="user", content="hello"),
+            Turn(role="user", content="hello again"),
+        ],
+        type="chat",
+    )
+    p = Pipeline(
+        PROFILES["chat"],
+        token_budget=None,
+        llm_backend=_DedupOnlyBackend(),
+        llm_mode="dedupe_only",
+        llm_min_input_chars=0,
+    )
+    out = p.run(conv)
+    assert len(out.turns) == 1
+    assert out.turns[0].content == "hello"
+
+
+def test_llm_mode_summarize_only():
+    conv = Conversation(
+        turns=[Turn(role="user", content="hello " * 200)],
+        type="chat",
+    )
+    p = Pipeline(
+        PROFILES["chat"],
+        token_budget=None,
+        llm_backend=_SummarizeOnlyBackend(),
+        llm_mode="summarize_only",
+        llm_min_input_chars=0,
+    )
+    out = p.run(conv)
+    assert len(out.turns) == 2
+    assert out.turns[0].role == "user"
+    assert out.turns[1].content == "summary appended"
+    assert out.turns[1].metadata.get("mode") == "summarize_only"
+
+
+def test_invalid_llm_mode_raises():
+    with pytest.raises(ValueError):
+        ContextManager(llm_mode="invalid")