contextpress 0.4.0__tar.gz → 0.5.1__tar.gz

{contextpress-0.4.0 → contextpress-0.5.1}/CHANGELOG.md

@@ -4,6 +4,20 @@ 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.5.1] - 2026-07-22
+
+- **`ClaudeBackend`** — shortcut for Anthropic Claude (`ANTHROPIC_API_KEY` or `api_key=`).
+- **`GeminiBackend`** — optional `model_name` + `api_key` / env (`GOOGLE_API_KEY`, `GEMINI_API_KEY`).
+- Examples: `examples/llm_tier_claude.py`, `examples/llm_tier_gemini.py`.
+
+## [0.5.0] - 2026-07-22
+
+- **`compress_async()`** — async wrapper around ``compress()`` for asyncio apps.
+- **`compare_presets()`** — dry-run low/medium/high on the same messages and compare stats.
+- **`CompressionStats.to_dict()` / `CompressionResult.to_dict()`** — JSON-friendly export.
+- **`GeminiBackend`** — Google Gemini Tier 2 adapter (optional ``google-generativeai``).
+- Example: `examples/benchmark_presets.py`.
+
 ## [0.4.0] - 2026-07-20
 
 - **`preview()` / `dry_run=True`** — simulate compression and get stats without changing messages (Tier 1 only; no LLM calls).

{contextpress-0.4.0 → contextpress-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: contextpress
-Version: 0.4.0
+Version: 0.5.1
 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
@@ -234,6 +234,7 @@ Requires-Dist: pytest>=7.0; extra == 'dev'
 Requires-Dist: ruff; extra == 'dev'
 Provides-Extra: llm
 Requires-Dist: anthropic>=0.18; extra == 'llm'
+Requires-Dist: google-generativeai>=0.8.0; extra == 'llm'
 Requires-Dist: ollama>=0.3.0; extra == 'llm'
 Requires-Dist: openai>=1.0; extra == 'llm'
 Description-Content-Type: text/markdown
@@ -307,6 +308,20 @@ if cm.fits_budget(messages, 4000):
     ...
 ```
 
+**Compare presets** (0.5+):
+
+```python
+rows = cm.compare_presets(messages, token_budget=500)
+for preset, stats in rows.items():
+    print(preset, stats.tokens_saved)
+```
+
+**Async** (0.5+):
+
+```python
+out = await cm.compress_async(messages, token_budget=2000)
+```
+
 ### Custom stages (0.3+)
 
 Register a `BaseStrategy` and include it in `stages=`:
@@ -386,7 +401,7 @@ ContextManager(type="agent")
 | **Techniques** | Rules, TF–IDF, cosine similarity, NLTK, Sumy extractive summarization, tiktoken | Your provider’s chat/completions API (you supply the client) |
 | **API key** | None | Required for your chosen provider (OpenAI, Anthropic, …) |
 | **Determinism** | Deterministic for a fixed input and settings | Non-deterministic (model sampling) |
-| **How to enable** | Default: `ContextManager()` runs Tier 1 only | Pass `llm_backend=` (`OpenAIBackend`, `AnthropicBackend`, **`OllamaBackend`**, or custom `LLMBackend`) |
+| **How to enable** | Default: `ContextManager()` runs Tier 1 only | Pass `llm_backend=` (`OpenAIBackend`, **`ClaudeBackend`**, `GeminiBackend`, `OllamaBackend`, or custom `LLMBackend`) |
 
 **Note:** `ContextManager(model="gpt-4")` is only for **tiktoken** encoding when counting tokens in the **budget** stage. It does **not** call that model unless you also pass **`llm_backend`**.
 
@@ -479,6 +494,32 @@ out = cm.compress(messages, token_budget=4000)
 
 Runnable script: [`examples/llm_tier_ollama.py`](examples/llm_tier_ollama.py).
 
+**Claude (Anthropic)** — `pip install anthropic`, set `ANTHROPIC_API_KEY`:
+
+```python
+from contextpress import ContextManager
+from contextpress.llm.adapters import ClaudeBackend
+
+backend = ClaudeBackend(model="claude-haiku-4-5")
+cm = ContextManager(type="chat", llm_backend=backend, llm_min_input_chars=500)
+out = cm.compress(messages, token_budget=4000)
+```
+
+Runnable script: [`examples/llm_tier_claude.py`](examples/llm_tier_claude.py).
+
+**Gemini (Google)** — `pip install google-generativeai`, set `GOOGLE_API_KEY`:
+
+```python
+from contextpress import ContextManager
+from contextpress.llm.adapters import GeminiBackend
+
+backend = GeminiBackend(model_name="gemini-2.0-flash")
+cm = ContextManager(type="chat", llm_backend=backend, llm_min_input_chars=500)
+out = cm.compress(messages, token_budget=4000)
+```
+
+Runnable script: [`examples/llm_tier_gemini.py`](examples/llm_tier_gemini.py).
+
 ```bash
 pip install ollama
 ollama pull llama3.2

{contextpress-0.4.0 → contextpress-0.5.1}/README.md

@@ -67,6 +67,20 @@ if cm.fits_budget(messages, 4000):
     ...
 ```
 
+**Compare presets** (0.5+):
+
+```python
+rows = cm.compare_presets(messages, token_budget=500)
+for preset, stats in rows.items():
+    print(preset, stats.tokens_saved)
+```
+
+**Async** (0.5+):
+
+```python
+out = await cm.compress_async(messages, token_budget=2000)
+```
+
 ### Custom stages (0.3+)
 
 Register a `BaseStrategy` and include it in `stages=`:
@@ -146,7 +160,7 @@ ContextManager(type="agent")
 | **Techniques** | Rules, TF–IDF, cosine similarity, NLTK, Sumy extractive summarization, tiktoken | Your provider’s chat/completions API (you supply the client) |
 | **API key** | None | Required for your chosen provider (OpenAI, Anthropic, …) |
 | **Determinism** | Deterministic for a fixed input and settings | Non-deterministic (model sampling) |
-| **How to enable** | Default: `ContextManager()` runs Tier 1 only | Pass `llm_backend=` (`OpenAIBackend`, `AnthropicBackend`, **`OllamaBackend`**, or custom `LLMBackend`) |
+| **How to enable** | Default: `ContextManager()` runs Tier 1 only | Pass `llm_backend=` (`OpenAIBackend`, **`ClaudeBackend`**, `GeminiBackend`, `OllamaBackend`, or custom `LLMBackend`) |
 
 **Note:** `ContextManager(model="gpt-4")` is only for **tiktoken** encoding when counting tokens in the **budget** stage. It does **not** call that model unless you also pass **`llm_backend`**.
 
@@ -239,6 +253,32 @@ out = cm.compress(messages, token_budget=4000)
 
 Runnable script: [`examples/llm_tier_ollama.py`](examples/llm_tier_ollama.py).
 
+**Claude (Anthropic)** — `pip install anthropic`, set `ANTHROPIC_API_KEY`:
+
+```python
+from contextpress import ContextManager
+from contextpress.llm.adapters import ClaudeBackend
+
+backend = ClaudeBackend(model="claude-haiku-4-5")
+cm = ContextManager(type="chat", llm_backend=backend, llm_min_input_chars=500)
+out = cm.compress(messages, token_budget=4000)
+```
+
+Runnable script: [`examples/llm_tier_claude.py`](examples/llm_tier_claude.py).
+
+**Gemini (Google)** — `pip install google-generativeai`, set `GOOGLE_API_KEY`:
+
+```python
+from contextpress import ContextManager
+from contextpress.llm.adapters import GeminiBackend
+
+backend = GeminiBackend(model_name="gemini-2.0-flash")
+cm = ContextManager(type="chat", llm_backend=backend, llm_min_input_chars=500)
+out = cm.compress(messages, token_budget=4000)
+```
+
+Runnable script: [`examples/llm_tier_gemini.py`](examples/llm_tier_gemini.py).
+
 ```bash
 pip install ollama
 ollama pull llama3.2

{contextpress-0.4.0 → contextpress-0.5.1}/contextpress/__init__.py

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

{contextpress-0.4.0 → contextpress-0.5.1}/contextpress/core.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import copy
 import warnings
 from typing import TYPE_CHECKING, Any
@@ -86,6 +87,20 @@ class ContextManager:
         )
         return preview.stats.tokens_after <= token_budget
 
+    def compare_presets(
+        self,
+        messages: Any,
+        token_budget: int | None = None,
+        *,
+        presets: tuple[str, ...] = ("low", "medium", "high"),
+    ) -> dict[str, CompressionStats]:
+        """Dry-run each compression preset and return stats keyed by preset name."""
+        results: dict[str, CompressionStats] = {}
+        for preset in presets:
+            preview = self.preview(messages, token_budget=token_budget, compression=preset)
+            results[preset] = preview.stats
+        return results
+
     def preview(
         self,
         messages: Any,
@@ -176,6 +191,29 @@ class ContextManager:
             return CompressionResult(messages=messages_out, stats=stats)
         return messages_out
 
+    async def compress_async(
+        self,
+        messages: Any,
+        token_budget: int | None = None,
+        *,
+        compression: str | None = None,
+        stages: list[str] | None = None,
+        disable: list[str] | None = None,
+        return_stats: bool = False,
+        dry_run: bool = False,
+    ) -> Any | CompressionResult:
+        """Async wrapper around ``compress()`` (runs in a worker thread)."""
+        return await asyncio.to_thread(
+            self.compress,
+            messages,
+            token_budget,
+            compression=compression,
+            stages=stages,
+            disable=disable,
+            return_stats=return_stats,
+            dry_run=dry_run,
+        )
+
     def set_compression(self, compression: str) -> None:
         """Change the default preset for subsequent ``compress()`` calls (low / medium / high)."""
         self._compression = normalize_compression_level(compression)

{contextpress-0.4.0 → contextpress-0.5.1}/contextpress/llm/__init__.py

@@ -1,5 +1,7 @@
 from contextpress.llm.adapters import (
     AnthropicBackend,
+    ClaudeBackend,
+    GeminiBackend,
     OllamaBackend,
     OpenAIBackend,
     OpenAICompatibleBackend,
@@ -11,5 +13,7 @@ __all__ = [
     "OpenAIBackend",
     "OpenAICompatibleBackend",
     "AnthropicBackend",
+    "ClaudeBackend",
+    "GeminiBackend",
     "OllamaBackend",
 ]

{contextpress-0.4.0 → contextpress-0.5.1}/contextpress/llm/adapters.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import os
 import warnings
 from typing import Any
 
@@ -135,6 +136,43 @@ class AnthropicBackend(LLMBackend):
             return list(range(len(turns)))
 
 
+class ClaudeBackend(AnthropicBackend):
+    """
+    Convenience adapter for **Anthropic Claude** (wraps ``AnthropicBackend``).
+
+    Requires: ``pip install anthropic``
+
+    Usage::
+
+        from contextpress.llm.adapters import ClaudeBackend
+
+        backend = ClaudeBackend(model=\"claude-haiku-4-5\")  # uses ANTHROPIC_API_KEY
+        cm = ContextManager(type=\"chat\", llm_backend=backend)
+    """
+
+    def __init__(
+        self,
+        model: str = "claude-haiku-4-5",
+        *,
+        api_key: str | None = None,
+        client: Any | None = None,
+    ):
+        if client is not None:
+            super().__init__(client=client, model=model)
+            return
+        try:
+            import anthropic
+        except ImportError as exc:
+            raise ImportError(
+                "ClaudeBackend requires the 'anthropic' package. "
+                "Install with: pip install anthropic"
+            ) from exc
+        key = api_key or os.environ.get("ANTHROPIC_API_KEY")
+        if not key:
+            raise ValueError("Set ANTHROPIC_API_KEY or pass api_key= for ClaudeBackend")
+        super().__init__(client=anthropic.Anthropic(api_key=key), model=model)
+
+
 class OllamaBackend(LLMBackend):
     """
     Adapter for **Ollama** (local or remote) using the official ``ollama`` Python library.
@@ -262,3 +300,73 @@ class OpenAICompatibleBackend(OpenAIBackend):
             client=OpenAI(base_url=base_url, api_key=api_key),
             model=model,
         )
+
+
+class GeminiBackend(LLMBackend):
+    """
+    Adapter for Google Gemini via ``google-generativeai``.
+
+    Requires: ``pip install google-generativeai``
+
+    Usage (API key from env ``GOOGLE_API_KEY`` or ``GEMINI_API_KEY``)::
+
+        from contextpress.llm.adapters import GeminiBackend
+
+        backend = GeminiBackend(model_name=\"gemini-2.0-flash\")
+        cm = ContextManager(type=\"chat\", llm_backend=backend)
+
+    Or pass a preconfigured model instance::
+
+        import google.generativeai as genai
+        genai.configure(api_key=\"...\")
+        backend = GeminiBackend(model=genai.GenerativeModel(\"gemini-2.0-flash\"))
+    """
+
+    def __init__(
+        self,
+        model: Any | None = None,
+        *,
+        model_name: str = "gemini-2.0-flash",
+        api_key: str | None = None,
+    ):
+        if model is not None:
+            self.model = model
+            return
+        try:
+            import google.generativeai as genai
+        except ImportError as exc:
+            raise ImportError(
+                "GeminiBackend requires 'google-generativeai'. "
+                "Install with: pip install google-generativeai"
+            ) from exc
+        key = api_key or os.environ.get("GOOGLE_API_KEY") or os.environ.get("GEMINI_API_KEY")
+        if key:
+            genai.configure(api_key=key)
+        self.model = genai.GenerativeModel(model_name)
+
+    def _generate(self, prompt: str, *, max_tokens: int) -> str:
+        resp = self.model.generate_content(
+            prompt,
+            generation_config={"max_output_tokens": max(64, int(max_tokens))},
+        )
+        text = getattr(resp, "text", None)
+        return str(text).strip() if text else ""
+
+    def summarize(self, text: str, max_tokens: int) -> str:
+        try:
+            out = self._generate(f"Summarize concisely:\n\n{text}", max_tokens=max_tokens)
+            return out if out else text
+        except Exception as exc:
+            warnings.warn(f"contextpress GeminiBackend.summarize failed: {exc}", stacklevel=2)
+            raise
+
+    def deduplicate(self, turns: list[str]) -> list[int]:
+        if len(turns) <= 1:
+            return list(range(len(turns)))
+        prompt = f"{DEDUP_SYSTEM_PROMPT}\n\n{format_numbered_turns(turns)}"
+        try:
+            out = self._generate(prompt, max_tokens=128)
+            return parse_keep_indices(out, len(turns))
+        except Exception as exc:
+            warnings.warn(f"contextpress GeminiBackend.deduplicate failed: {exc}", stacklevel=2)
+            return list(range(len(turns)))

{contextpress-0.4.0 → contextpress-0.5.1}/contextpress/stats.py

@@ -60,6 +60,27 @@ class CompressionStats:
     def tokens_saved(self) -> int:
         return max(0, self.tokens_before - self.tokens_after)
 
+    def to_dict(self) -> dict[str, Any]:
+        """JSON-serializable snapshot of this run."""
+        return {
+            "turns_before": self.turns_before,
+            "turns_after": self.turns_after,
+            "turns_removed": self.turns_removed,
+            "tokens_before": self.tokens_before,
+            "tokens_after": self.tokens_after,
+            "tokens_saved": self.tokens_saved,
+            "stages_run": list(self.stages_run),
+            "turn_delta_by_stage": dict(self.turn_delta_by_stage),
+            "llm_tier_applied": self.llm_tier_applied,
+            "llm_dedup_turns_before": self.llm_dedup_turns_before,
+            "llm_dedup_turns_after": self.llm_dedup_turns_after,
+            "compression_level": self.compression_level,
+            "context_type": self.context_type,
+            "token_budget": self.token_budget,
+            "dry_run": self.dry_run,
+            "warnings_emitted": list(self.warnings_emitted),
+        }
+
 
 @dataclass
 class CompressionResult:
@@ -67,3 +88,9 @@ class CompressionResult:
 
     messages: Any
     stats: CompressionStats
+
+    def to_dict(self, *, include_messages: bool = True) -> dict[str, Any]:
+        data = {"stats": self.stats.to_dict()}
+        if include_messages:
+            data["messages"] = self.messages
+        return data

contextpress-0.5.1/examples/benchmark_presets.py

@@ -0,0 +1,23 @@
+"""Compare compression presets on the same fixture (dry run)."""
+
+from contextpress import ContextManager
+
+messages = [
+    {"role": "system", "content": "You are helpful."},
+    {"role": "user", "content": "Old topic: " + "blah " * 40},
+    {"role": "assistant", "content": "Basically, honestly, " + "yak " * 40},
+    {"role": "user", "content": "What is 2+2?"},
+    {"role": "assistant", "content": "Four."},
+]
+
+cm = ContextManager(type="chat")
+rows = cm.compare_presets(messages, token_budget=200)
+
+print(f"{'preset':<8} {'tokens':>12} {'saved':>8} {'turns':>12}")
+for preset, stats in rows.items():
+    print(
+        f"{preset:<8} "
+        f"{stats.tokens_before:>5}->{stats.tokens_after:<5} "
+        f"{stats.tokens_saved:>8} "
+        f"{stats.turns_before:>5}->{stats.turns_after:<5}"
+    )

contextpress-0.5.1/examples/llm_tier_claude.py

@@ -0,0 +1,50 @@
+"""
+Tier 2 compression with Anthropic Claude.
+
+Requires ``pip install anthropic`` and ``ANTHROPIC_API_KEY``.
+
+Run:
+    set ANTHROPIC_API_KEY=sk-ant-...   # Windows
+    python examples/llm_tier_claude.py
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+from contextpress import ContextManager
+from contextpress.llm.adapters import ClaudeBackend
+
+
+def main() -> None:
+    if not os.environ.get("ANTHROPIC_API_KEY"):
+        print("Set ANTHROPIC_API_KEY to run this example.", file=sys.stderr)
+        sys.exit(1)
+
+    messages = [
+        {"role": "system", "content": "You are a concise assistant."},
+        {"role": "user", "content": "What is Python? " + ("Explain briefly. " * 200)},
+        {"role": "assistant", "content": "Python is a programming language. " * 150},
+        {"role": "user", "content": "And numpy? " * 80},
+    ]
+
+    backend = ClaudeBackend(model="claude-haiku-4-5")
+    cm = ContextManager(
+        type="chat",
+        llm_backend=backend,
+        compression="medium",
+        llm_min_input_chars=500,
+        llm_max_summary_tokens=512,
+    )
+
+    out = cm.compress(messages, token_budget=2000)
+    print("turns in:", len(messages), "out:", len(out))
+    for i, m in enumerate(out):
+        c = m["content"]
+        preview = (c[:200] + "…") if isinstance(c, str) and len(c) > 200 else c
+        print(i, m["role"] + ":", preview)
+
+
+if __name__ == "__main__":
+    main()

contextpress-0.5.1/examples/llm_tier_gemini.py

@@ -0,0 +1,50 @@
+"""
+Tier 2 compression with Google Gemini.
+
+Requires ``pip install google-generativeai`` and ``GOOGLE_API_KEY``.
+
+Run:
+    set GOOGLE_API_KEY=...   # or GEMINI_API_KEY
+    python examples/llm_tier_gemini.py
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+from contextpress import ContextManager
+from contextpress.llm.adapters import GeminiBackend
+
+
+def main() -> None:
+    if not (os.environ.get("GOOGLE_API_KEY") or os.environ.get("GEMINI_API_KEY")):
+        print("Set GOOGLE_API_KEY or GEMINI_API_KEY to run this example.", file=sys.stderr)
+        sys.exit(1)
+
+    messages = [
+        {"role": "system", "content": "You are a concise assistant."},
+        {"role": "user", "content": "What is Python? " + ("Explain briefly. " * 200)},
+        {"role": "assistant", "content": "Python is a programming language. " * 150},
+        {"role": "user", "content": "And numpy? " * 80},
+    ]
+
+    backend = GeminiBackend(model_name="gemini-2.0-flash")
+    cm = ContextManager(
+        type="chat",
+        llm_backend=backend,
+        compression="medium",
+        llm_min_input_chars=500,
+        llm_max_summary_tokens=512,
+    )
+
+    out = cm.compress(messages, token_budget=2000)
+    print("turns in:", len(messages), "out:", len(out))
+    for i, m in enumerate(out):
+        c = m["content"]
+        preview = (c[:200] + "…") if isinstance(c, str) and len(c) > 200 else c
+        print(i, m["role"] + ":", preview)
+
+
+if __name__ == "__main__":
+    main()

{contextpress-0.4.0 → contextpress-0.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "contextpress"
-version = "0.4.0"
+version = "0.5.1"
 description = "Deterministic context compression for LLM chat, RAG, and agent pipelines"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -44,7 +44,7 @@ dependencies = [
 
 [project.optional-dependencies]
 dev = ["pytest>=7.0", "pytest-cov>=4.0", "black", "ruff"]
-llm = ["openai>=1.0", "anthropic>=0.18", "ollama>=0.3.0"]
+llm = ["openai>=1.0", "anthropic>=0.18", "ollama>=0.3.0", "google-generativeai>=0.8.0"]
 
 [project.urls]
 Homepage = "https://github.com/Taha-azizi/contextpress"

contextpress-0.5.1/tests/test_v05.py

@@ -0,0 +1,66 @@
+import asyncio
+from unittest.mock import MagicMock
+
+from contextpress import ContextManager
+from contextpress.llm.adapters import GeminiBackend
+from contextpress.stats import CompressionStats
+
+
+def test_stats_to_dict():
+    stats = CompressionStats(
+        turns_before=5,
+        turns_after=3,
+        tokens_before=100,
+        tokens_after=60,
+        stages_run=["filler", "budget"],
+        compression_level="medium",
+    )
+    d = stats.to_dict()
+    assert d["turns_removed"] == 2
+    assert d["tokens_saved"] == 40
+    assert d["stages_run"] == ["filler", "budget"]
+
+
+def test_result_to_dict():
+    cm = ContextManager()
+    result = cm.preview([{"role": "user", "content": "hello basically"}], token_budget=100)
+    d = result.to_dict()
+    assert "stats" in d and "messages" in d
+    assert d["stats"]["dry_run"] is True
+
+
+def test_compare_presets():
+    cm = ContextManager(type="chat")
+    messages = [
+        {"role": "user", "content": "hello basically there"},
+        {"role": "assistant", "content": "sounds good"},
+    ]
+    rows = cm.compare_presets(messages, token_budget=500)
+    assert set(rows) == {"low", "medium", "high"}
+    assert all(isinstance(v, CompressionStats) for v in rows.values())
+
+
+def test_compress_async():
+    async def _run() -> list:
+        cm = ContextManager(type="chat")
+        return await cm.compress_async(
+            [{"role": "user", "content": "hello basically"}],
+            token_budget=200,
+        )
+
+    out = asyncio.run(_run())
+    assert isinstance(out, list)
+
+
+def test_gemini_backend_summarize():
+    model = MagicMock()
+    model.generate_content.return_value = MagicMock(text="summary")
+    backend = GeminiBackend(model=model)
+    assert backend.summarize("long text", 50) == "summary"
+
+
+def test_gemini_backend_deduplicate():
+    model = MagicMock()
+    model.generate_content.return_value = MagicMock(text="0, 2")
+    backend = GeminiBackend(model=model)
+    assert backend.deduplicate(["a", "b", "c", "d"]) == [0, 2]

contextpress-0.5.1/tests/test_v051.py

@@ -0,0 +1,50 @@
+import os
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from contextpress.llm.adapters import ClaudeBackend, GeminiBackend
+
+
+def test_claude_backend_with_client():
+    client = MagicMock()
+    backend = ClaudeBackend(model="claude-haiku-4-5", client=client)
+    assert backend.client is client
+    assert backend.model == "claude-haiku-4-5"
+
+
+def test_claude_backend_requires_api_key():
+    mock_anthropic = MagicMock()
+    with patch.dict(os.environ, {}, clear=True):
+        with patch.dict("sys.modules", {"anthropic": mock_anthropic}):
+            with pytest.raises(ValueError, match="ANTHROPIC_API_KEY"):
+                ClaudeBackend()
+
+
+def test_claude_backend_from_api_key():
+    mock_module = MagicMock()
+    mock_client = MagicMock()
+    mock_module.Anthropic.return_value = mock_client
+    with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-test"}):
+        with patch.dict("sys.modules", {"anthropic": mock_module}):
+            backend = ClaudeBackend(model="claude-haiku-4-5")
+    assert backend.client is mock_client
+
+
+def test_gemini_backend_with_model_instance():
+    model = MagicMock()
+    backend = GeminiBackend(model=model)
+    assert backend.model is model
+
+
+def test_gemini_backend_from_model_name():
+    mock_genai = MagicMock()
+    mock_model = MagicMock()
+    mock_genai.GenerativeModel.return_value = mock_model
+    fake_google = MagicMock()
+    fake_google.generativeai = mock_genai
+    with patch.dict(os.environ, {"GOOGLE_API_KEY": "key-test"}):
+        with patch.dict("sys.modules", {"google": fake_google, "google.generativeai": mock_genai}):
+            backend = GeminiBackend(model_name="gemini-2.0-flash")
+    assert backend.model is mock_model
+    mock_genai.configure.assert_called_once_with(api_key="key-test")