compresr 2.6.5__tar.gz → 2.7.2__tar.gz

{compresr-2.6.5 → compresr-2.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compresr
-Version: 2.6.5
+Version: 2.7.2
 Summary: Python SDK for Compresr - Intelligent prompt compression service
 Author-email: Compresr Team <founders@compresr.ai>
 License-Expression: Apache-2.0
@@ -26,7 +26,7 @@ Requires-Dist: httpx>=0.27.0
 Requires-Dist: pydantic>=2.10.0
 Requires-Dist: langchain>=1.0
 Requires-Dist: langchain-core>=0.3
-Requires-Dist: langchain-anthropic>=0.3
+Requires-Dist: langchain-anthropic>=1.0
 Requires-Dist: langchain-openai>=0.3
 Requires-Dist: langchain-google-genai>=4.0
 Requires-Dist: langchain-tavily>=0.1
@@ -216,6 +216,42 @@ OpenAI's `web_search_preview`, and Gemini's `google_search` run server-side
 and return encrypted/opaque content that Compresr cannot read or compress.
 Use Tavily or Brave so the result is plaintext we can compress.
 
+## Research agent
+
+`client.research.run(question)` runs a multi-step web-research loop with
+per-snippet `latte_v1` compression on tool results and multi-provider prompt
+caching. Loop structure adapted from Perplexity `search_evals` (MIT).
+
+```python
+from compresr import CompressionClient
+
+client = CompressionClient(
+    api_key="cmp_...",
+    llm="anthropic:claude-sonnet-4-6",
+    llm_api_key="sk-ant-...",
+)
+
+result = client.research.run(
+    "What was the latest stable Python version released in 2025?",
+    search="tavily",          # "tavily" | "brave" | a LangChain BaseTool
+    max_steps=10,
+)
+
+print(result.answer)              # parsed Exact Answer field
+print(result.explanation)         # parsed Explanation field
+print(result.confidence)          # parsed 0-1 confidence
+print(result.citations)           # list[Citation(url=...)]
+print(result.usage.cache_read_tokens, result.usage.calls)
+```
+
+Single-shot mode: `client.research.search(question)` runs one search + a
+forced final answer (equivalent to `run(..., max_steps=2)`).
+
+The agent respects all the prompt-cache options on `CompressionClient`
+(`enable_prompt_cache`, `prompt_cache_ttl`, `openai_prompt_cache_key`).
+Tavily / Brave keys are read from `TAVILY_API_KEY` / `BRAVE_SEARCH_API_KEY`
+(falls back to `BRAVE_API_KEY`).
+
 ## Compression options
 
 | Param | Purpose |

{compresr-2.6.5 → compresr-2.7.2}/README.md

@@ -153,6 +153,42 @@ OpenAI's `web_search_preview`, and Gemini's `google_search` run server-side
 and return encrypted/opaque content that Compresr cannot read or compress.
 Use Tavily or Brave so the result is plaintext we can compress.
 
+## Research agent
+
+`client.research.run(question)` runs a multi-step web-research loop with
+per-snippet `latte_v1` compression on tool results and multi-provider prompt
+caching. Loop structure adapted from Perplexity `search_evals` (MIT).
+
+```python
+from compresr import CompressionClient
+
+client = CompressionClient(
+    api_key="cmp_...",
+    llm="anthropic:claude-sonnet-4-6",
+    llm_api_key="sk-ant-...",
+)
+
+result = client.research.run(
+    "What was the latest stable Python version released in 2025?",
+    search="tavily",          # "tavily" | "brave" | a LangChain BaseTool
+    max_steps=10,
+)
+
+print(result.answer)              # parsed Exact Answer field
+print(result.explanation)         # parsed Explanation field
+print(result.confidence)          # parsed 0-1 confidence
+print(result.citations)           # list[Citation(url=...)]
+print(result.usage.cache_read_tokens, result.usage.calls)
+```
+
+Single-shot mode: `client.research.search(question)` runs one search + a
+forced final answer (equivalent to `run(..., max_steps=2)`).
+
+The agent respects all the prompt-cache options on `CompressionClient`
+(`enable_prompt_cache`, `prompt_cache_ttl`, `openai_prompt_cache_key`).
+Tavily / Brave keys are read from `TAVILY_API_KEY` / `BRAVE_SEARCH_API_KEY`
+(falls back to `BRAVE_API_KEY`).
+
 ## Compression options
 
 | Param | Purpose |

{compresr-2.6.5 → compresr-2.7.2}/compresr/__init__.py

@@ -56,6 +56,9 @@ __all__ = [
     "MODELS",
     "WebSearchTool",
     "CompressionPolicy",
+    "ResearchResult",
+    "ResearchAgent",
+    "Citation",
 ]
 
 
@@ -69,4 +72,8 @@ def __getattr__(name: str) -> Any:
         from .integrations._shared import CompressionPolicy as _P
 
         return _P
+    if name in {"ResearchResult", "ResearchAgent", "Citation"}:
+        from .agents import research as _r
+
+        return getattr(_r, name)
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

{compresr-2.6.5 → compresr-2.7.2}/compresr/agents/engine.py

@@ -13,7 +13,7 @@ public surface. Only the normalized result type leaks out.
 from __future__ import annotations
 
 import logging
-from typing import Any, Optional, Sequence
+from typing import Any, Literal, Optional, Sequence, cast
 
 from compresr.exceptions import CompresrError
 from compresr.integrations._shared import CompressionPolicy
@@ -64,6 +64,83 @@ def _CompresrToolMiddleware(*args: Any, **kwargs: Any) -> Any:
 _KNOWN_PROVIDERS = {"anthropic", "openai", "google_genai"}
 
 
+# ---------------------------------------------------------------------------
+# Solo-WebSearchTool auto-route
+# ---------------------------------------------------------------------------
+#
+# When a generic-agent facade (``client.messages.create`` / ``client.chat
+# .completions.create`` / ``client.run``) is invoked with exactly the
+# Compresr ``WebSearchTool`` and nothing else, the engine silently routes the
+# call through the deep-research loop instead of the standard ``create_agent``
+# middleware path. The caller still gets back their facade's expected shape
+# (Anthropic ``Message`` / OpenAI ``ChatCompletion`` / ``NormalizedResult``),
+# but the loop semantics are research-agent: ``tool_choice="none"`` on the
+# final step, per-snippet compression against the live query, 10-step cap,
+# manual Anthropic ``cache_control`` stamping.
+#
+# Detection is by tool name because ``WebSearchTool.__new__`` returns a
+# ``StructuredTool`` (not a ``WebSearchTool`` instance), so ``isinstance``
+# would always be False.
+_WEB_SEARCH_TOOL_NAMES = frozenset({"tavily_search", "brave_search"})
+
+
+def _is_solo_web_search(tools: Sequence) -> bool:
+    """True when ``tools`` is exactly one Compresr-built web-search tool."""
+    if len(tools) != 1:
+        return False
+    name = getattr(tools[0], "name", None)
+    return isinstance(name, str) and name in _WEB_SEARCH_TOOL_NAMES
+
+
+def _extract_last_user_text(messages: Sequence) -> str:
+    """Pull the last user/human message text out of a facade-shaped chain.
+
+    Supports the message shapes that the facades feed the engine — plain
+    dicts (Anthropic/OpenAI style) and LangChain ``BaseMessage`` instances.
+    Falls back to the first message's content when no explicit user message
+    is found, and to ``""`` on empty input.
+    """
+    for msg in reversed(list(messages)):
+        role = None
+        content: Any = None
+        if isinstance(msg, dict):
+            role = msg.get("role")
+            content = msg.get("content")
+        else:
+            role = getattr(msg, "role", None) or getattr(msg, "type", None)
+            content = getattr(msg, "content", None)
+        if role in ("user", "human") and content is not None:
+            return _content_text_any(content)
+    if messages:
+        first = messages[0]
+        content = (
+            first.get("content") if isinstance(first, dict) else getattr(first, "content", None)
+        )
+        return _content_text_any(content)
+    return ""
+
+
+def _content_text_any(content: Any) -> str:
+    """Stringify the ``content`` field of a chat message.
+
+    Handles strings, lists of text blocks (Anthropic/OpenAI structured form),
+    and arbitrary fallbacks via ``str()``.
+    """
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts: list[str] = []
+        for block in content:
+            if isinstance(block, dict):
+                text = block.get("text")
+                if isinstance(text, str):
+                    parts.append(text)
+            elif isinstance(block, str):
+                parts.append(block)
+        return "".join(parts)
+    return str(content) if content is not None else ""
+
+
 # Kwargs that propagate to the underlying chat model via ``.bind(...)`` per
 # call. Covers Anthropic / OpenAI / Gemini. LangChain's chat models normalize
 # most of these across providers; unsupported keys are silently ignored
@@ -266,6 +343,15 @@ _USAGE_NUMERIC_KEYS = (
     "cache_creation_input_tokens",
 )
 
+# Provider-specific cache-read aliases under ``input_token_details``.
+_INPUT_DETAILS_CACHE_READ_ALIASES = (
+    "cached_tokens",
+    "cache_read",
+    "priority_cache_read",
+    "flex_cache_read",
+    "cached_content_token_count",
+)
+
 
 def _aggregate_usage(messages: list) -> dict:
     """Sum ``usage_metadata`` across every AIMessage in the conversation.
@@ -305,8 +391,26 @@ def _aggregate_usage(messages: list) -> dict:
         if not has_top_cache:
             details = per.get("input_token_details")
             if isinstance(details, dict):
-                total["cache_read_input_tokens"] += int(details.get("cache_read", 0) or 0)
-                total["cache_creation_input_tokens"] += int(details.get("cache_creation", 0) or 0)
+                msg_cache_read = 0
+                msg_cache_create = 0
+                for alias in _INPUT_DETAILS_CACHE_READ_ALIASES:
+                    v = details.get(alias)
+                    if isinstance(v, (int, float)):
+                        msg_cache_read += int(v)
+                # When cache_control sets a ttl, langchain-anthropic writes
+                # the count to the TTL-specific keys and zeroes ``cache_creation``.
+                ttl_writes = int(details.get("ephemeral_5m_input_tokens", 0) or 0) + int(
+                    details.get("ephemeral_1h_input_tokens", 0) or 0
+                )
+                msg_cache_create = ttl_writes or int(details.get("cache_creation", 0) or 0)
+                total["cache_read_input_tokens"] += msg_cache_read
+                total["cache_creation_input_tokens"] += msg_cache_create
+                # langchain-anthropic 1.x inflates ``input_tokens`` to
+                # fresh + read + create; subtract so it means fresh-only.
+                this_input = per.get("input_tokens")
+                if isinstance(this_input, (int, float)) and (msg_cache_read or msg_cache_create):
+                    overcount = msg_cache_read + msg_cache_create
+                    total["input_tokens"] -= min(overcount, int(this_input))
         # Carry through any other numeric extras (reasoning_tokens, …).
         for k, v in per.items():
             if k in _USAGE_NUMERIC_KEYS or k == "input_token_details":
@@ -317,6 +421,22 @@ def _aggregate_usage(messages: list) -> dict:
     return out
 
 
+def _tool_name(t: Any) -> str:
+    name = getattr(t, "name", None)
+    if isinstance(name, str):
+        return name
+    if isinstance(t, dict):
+        return str(t.get("name") or "")
+    return ""
+
+
+def _sorted_tools_for_cache(tools: Sequence) -> list:
+    """Stable tool order so the Anthropic tool-block cache hash doesn't drift."""
+    indexed = list(enumerate(tools))
+    indexed.sort(key=lambda p: (_tool_name(p[1]), p[0]))
+    return [t for _, t in indexed]
+
+
 def _last_ai_message(messages: list) -> Any:
     """Return the final assistant message from an agent invoke result."""
     for msg in reversed(messages or []):
@@ -354,11 +474,19 @@ class _Engine:
         llm: str,
         llm_api_key: Optional[str] = None,
         policy: Optional[CompressionPolicy] = None,
+        enable_prompt_cache: bool = True,
+        prompt_cache_ttl: str = "5m",
+        prompt_cache_min_messages: int = 2,
+        openai_prompt_cache_key: Optional[str] = None,
     ) -> None:
         self._compresr_client = compresr_client
         self._provider, self._default_model_name = _parse_llm(llm)
         self._policy = policy or CompressionPolicy()
         self._llm_api_key = llm_api_key
+        self._enable_prompt_cache = bool(enable_prompt_cache)
+        self._prompt_cache_ttl = prompt_cache_ttl
+        self._prompt_cache_min_messages = int(prompt_cache_min_messages)
+        self._openai_prompt_cache_key = openai_prompt_cache_key
         # Chat-model cache keyed by effective model name. Construction is
         # deferred to the first ``run()`` so a provider-only client
         # (``llm="anthropic"``) doesn't try to resolve a model at init time.
@@ -416,6 +544,15 @@ class _Engine:
         kwargs: dict = dict(extra_kwargs)
         if self._llm_api_key is not None:
             kwargs.setdefault("api_key", self._llm_api_key)
+        # OpenAI caching is server-side; we only pass ``prompt_cache_key``
+        # and ``prompt_cache_retention`` via ``model_kwargs`` so they survive
+        # ``bind_tools``.
+        if self._provider == "openai" and self._enable_prompt_cache:
+            openai_extra = self._openai_cache_model_kwargs()
+            if openai_extra:
+                mk = dict(kwargs.get("model_kwargs") or {})
+                mk.update(openai_extra)
+                kwargs["model_kwargs"] = mk
         # OpenAI Responses output_version is a constructor kwarg in newer
         # langchain-openai; older versions reject unknown kwargs. Try both.
         if self._provider == "openai":
@@ -429,17 +566,57 @@ class _Engine:
                 logger.debug("init_chat_model rejected output_version; falling back without it")
         return init_chat_model(f"{self._provider}:{model_name}", **kwargs)
 
+    def _openai_cache_model_kwargs(self) -> dict:
+        """Build the OpenAI-specific cache controls. ``prompt_cache_retention``
+        is only set for ``ttl="1h"`` so older langchain-openai doesn't reject
+        the unknown field on the default path."""
+        out: dict = {}
+        if self._openai_prompt_cache_key:
+            out["prompt_cache_key"] = self._openai_prompt_cache_key
+        if self._prompt_cache_ttl == "1h":
+            out["prompt_cache_retention"] = "24h"
+        return out
+
     def _build_middleware(self) -> list:
         """Build the middleware stack used for every run.
 
         The compression knobs come straight from
         :meth:`CompressionPolicy.tool_kwargs`.
         """
-        mw = _CompresrToolMiddleware(
-            client=self._compresr_client,
-            **self._policy.tool_kwargs(),
+        mw: list = [
+            _CompresrToolMiddleware(
+                client=self._compresr_client,
+                **self._policy.tool_kwargs(),
+            )
+        ]
+        cache_mw = self._maybe_build_cache_middleware()
+        if cache_mw is not None:
+            # AFTER CompresrToolMiddleware so cache markers stamp the
+            # post-compression content.
+            mw.append(cache_mw)
+        return mw
+
+    def _maybe_build_cache_middleware(self) -> Optional[Any]:
+        """Anthropic prompt-cache middleware when enabled, else None. Silently
+        degrades on older ``langchain-anthropic`` without the middleware module."""
+        if not self._enable_prompt_cache or self._provider != "anthropic":
+            return None
+        try:
+            from langchain_anthropic.middleware import (  # type: ignore[import-not-found]
+                AnthropicPromptCachingMiddleware,
+            )
+        except ImportError:
+            logger.debug(
+                "langchain_anthropic.middleware.AnthropicPromptCachingMiddleware "
+                "unavailable; prompt caching disabled"
+            )
+            return None
+        ttl = cast(Literal["5m", "1h"], self._prompt_cache_ttl)
+        return AnthropicPromptCachingMiddleware(
+            ttl=ttl,
+            min_messages_to_cache=self._prompt_cache_min_messages,
+            unsupported_model_behavior="ignore",
         )
-        return [mw]
 
     def _build_agent(
         self,
@@ -454,7 +631,7 @@ class _Engine:
         If a future/older version rejects it we fall back to prepending a
         system message at invoke time instead.
         """
-        tools_list = list(tools)
+        tools_list = _sorted_tools_for_cache(tools)
         middleware = self._build_middleware()
         try:
             return create_agent(
@@ -566,9 +743,21 @@ class _Engine:
         ``stop_sequences``, etc.) are peeled off and forwarded to the
         underlying chat model via ``chat.bind(...)`` so they reach the
         provider without mutating the cached chat model.
+
+        When ``tools`` is exactly one Compresr ``WebSearchTool``, the call
+        is auto-routed through the deep-research loop — see
+        :data:`_WEB_SEARCH_TOOL_NAMES` and :meth:`_run_via_research_loop`.
         """
         effective_model = self._resolve_model(model)
         bind_kwargs = self._collect_bind_kwargs(max_tokens=max_tokens, kw=kw)
+        if _is_solo_web_search(tools):
+            return self._run_via_research_loop(
+                messages=messages,
+                search_tool=tools[0],
+                system=system,
+                model=effective_model,
+                bind_kwargs=bind_kwargs or None,
+            )
         chat = self._get_or_build_chat(effective_model, extra_kwargs=bind_kwargs or None)
         agent = self._build_agent(chat=chat, tools=tools, system=system)
         prepared = self._prepare_messages(agent=agent, messages=messages, system=system)
@@ -588,9 +777,26 @@ class _Engine:
         model: Optional[str] = None,
         **kw: Any,
     ) -> NormalizedResult:
-        """Async version of :meth:`run`."""
+        """Async version of :meth:`run`.
+
+        Solo-WebSearchTool calls are auto-routed through the research loop;
+        because the loop itself is synchronous (LangChain ``bind_tools``
+        + ``invoke``), the async path runs it via :func:`asyncio.to_thread`
+        to avoid blocking the event loop.
+        """
         effective_model = self._resolve_model(model)
         bind_kwargs = self._collect_bind_kwargs(max_tokens=max_tokens, kw=kw)
+        if _is_solo_web_search(tools):
+            import asyncio
+
+            return await asyncio.to_thread(
+                self._run_via_research_loop,
+                messages=messages,
+                search_tool=tools[0],
+                system=system,
+                model=effective_model,
+                bind_kwargs=bind_kwargs or None,
+            )
         chat = self._get_or_build_chat(effective_model, extra_kwargs=bind_kwargs or None)
         agent = self._build_agent(chat=chat, tools=tools, system=system)
         prepared = self._prepare_messages(agent=agent, messages=messages, system=system)
@@ -600,6 +806,40 @@ class _Engine:
             raise CompresrError(f"Agent execution failed: {e}") from e
         return self._normalize(result)
 
+    def _run_via_research_loop(
+        self,
+        *,
+        messages: Sequence,
+        search_tool: Any,
+        system: Optional[Any],
+        model: str,
+        bind_kwargs: Optional[dict],
+    ) -> NormalizedResult:
+        """Auto-route handler for solo-WebSearchTool calls.
+
+        Builds a :class:`ResearchAgent`, runs its strict-output loop against
+        the last user message, then feeds the resulting message chain through
+        :meth:`_normalize` so each facade still gets its expected shape.
+
+        ``system`` from the caller wins when supplied (string); otherwise
+        the research-agent default prompt is used.
+        """
+        from compresr.agents.research.agent import ResearchAgent
+
+        question = _extract_last_user_text(messages)
+        system_prompt = system if isinstance(system, str) and system.strip() else None
+        agent = ResearchAgent(
+            engine=self,
+            search_tool=search_tool,
+            system_prompt=system_prompt,
+        )
+        state = agent._run_loop(
+            question,
+            model=model,
+            extra_chat_kwargs=bind_kwargs,
+        )
+        return self._normalize({"messages": state.messages})
+
     # ------------------------------------------------------------------
     # Normalization
     # ------------------------------------------------------------------

{compresr-2.6.5 → compresr-2.7.2}/compresr/services/compression.py

@@ -34,6 +34,18 @@ class CompressionClient(BaseCompressionClient):
         llm_api_key: Optional provider API key forwarded to the LLM.
         compression: Optional dict of :class:`CompressionPolicy` kwargs
             (e.g. ``{"target_compression_ratio": 0.7, "min_tokens": 1000}``).
+        enable_prompt_cache: Provider-aware prompt-cache control. Default ``True``.
+            Anthropic → wires ``AnthropicPromptCachingMiddleware``.
+            OpenAI → attaches ``prompt_cache_key`` (when set) and maps
+            ``prompt_cache_ttl="1h"`` to ``prompt_cache_retention="24h"``.
+            Gemini → no-op for now (implicit caching always on at the API).
+        prompt_cache_ttl: ``"5m"`` or ``"1h"``. Anthropic uses it as the
+            ephemeral cache TTL. OpenAI maps ``"1h"`` to the 24h retention tier.
+        prompt_cache_min_messages: Skip Anthropic cache stamping until the
+            conversation has at least this many messages.
+        openai_prompt_cache_key: Optional routing key for OpenAI prompt caching
+            (improves hit rate when multiple clients share a backend). Ignored
+            for non-OpenAI providers.
 
     Example::
 
@@ -66,12 +78,16 @@ class CompressionClient(BaseCompressionClient):
         llm: Optional[str] = None,
         llm_api_key: Optional[str] = None,
         compression: Optional[Dict[str, Any]] = None,
+        enable_prompt_cache: bool = True,
+        prompt_cache_ttl: str = "5m",
+        prompt_cache_min_messages: int = 2,
+        openai_prompt_cache_key: Optional[str] = None,
     ):
         super().__init__(api_key=api_key, base_url=base_url, timeout=timeout)
         self._engine = None
         if llm is not None:
-            # Import lazily so that ``CompressionClient(api_key=...)`` without
-            # ``llm=`` keeps working even when langchain isn't installed.
+            # Lazy import: ``CompressionClient(api_key=...)`` without ``llm=``
+            # must keep working when langchain isn't installed.
             from compresr.agents.engine import _Engine
             from compresr.integrations._shared import CompressionPolicy
 
@@ -81,7 +97,29 @@ class CompressionClient(BaseCompressionClient):
                 llm=llm,
                 llm_api_key=llm_api_key,
                 policy=policy,
+                enable_prompt_cache=enable_prompt_cache,
+                prompt_cache_ttl=prompt_cache_ttl,
+                prompt_cache_min_messages=prompt_cache_min_messages,
+                openai_prompt_cache_key=openai_prompt_cache_key,
             )
+        self._research_facade: Optional[Any] = None
+
+    @property
+    def research(self) -> Any:
+        """Research facade: ``client.research.run("question")``. Requires ``llm=``."""
+        if self._research_facade is None:
+            if self._engine is None:
+                from ..exceptions import CompresrError
+
+                raise CompresrError(
+                    "client.research requires an LLM provider. "
+                    "Construct with CompressionClient(api_key=..., llm='anthropic:...', llm_api_key=...).",
+                    code="missing_llm",
+                )
+            from ..agents.research.facade import ResearchFacade
+
+            self._research_facade = ResearchFacade(self._engine)
+        return self._research_facade
 
     def compress(
         self,

{compresr-2.6.5 → compresr-2.7.2}/compresr.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compresr
-Version: 2.6.5
+Version: 2.7.2
 Summary: Python SDK for Compresr - Intelligent prompt compression service
 Author-email: Compresr Team <founders@compresr.ai>
 License-Expression: Apache-2.0
@@ -26,7 +26,7 @@ Requires-Dist: httpx>=0.27.0
 Requires-Dist: pydantic>=2.10.0
 Requires-Dist: langchain>=1.0
 Requires-Dist: langchain-core>=0.3
-Requires-Dist: langchain-anthropic>=0.3
+Requires-Dist: langchain-anthropic>=1.0
 Requires-Dist: langchain-openai>=0.3
 Requires-Dist: langchain-google-genai>=4.0
 Requires-Dist: langchain-tavily>=0.1
@@ -216,6 +216,42 @@ OpenAI's `web_search_preview`, and Gemini's `google_search` run server-side
 and return encrypted/opaque content that Compresr cannot read or compress.
 Use Tavily or Brave so the result is plaintext we can compress.
 
+## Research agent
+
+`client.research.run(question)` runs a multi-step web-research loop with
+per-snippet `latte_v1` compression on tool results and multi-provider prompt
+caching. Loop structure adapted from Perplexity `search_evals` (MIT).
+
+```python
+from compresr import CompressionClient
+
+client = CompressionClient(
+    api_key="cmp_...",
+    llm="anthropic:claude-sonnet-4-6",
+    llm_api_key="sk-ant-...",
+)
+
+result = client.research.run(
+    "What was the latest stable Python version released in 2025?",
+    search="tavily",          # "tavily" | "brave" | a LangChain BaseTool
+    max_steps=10,
+)
+
+print(result.answer)              # parsed Exact Answer field
+print(result.explanation)         # parsed Explanation field
+print(result.confidence)          # parsed 0-1 confidence
+print(result.citations)           # list[Citation(url=...)]
+print(result.usage.cache_read_tokens, result.usage.calls)
+```
+
+Single-shot mode: `client.research.search(question)` runs one search + a
+forced final answer (equivalent to `run(..., max_steps=2)`).
+
+The agent respects all the prompt-cache options on `CompressionClient`
+(`enable_prompt_cache`, `prompt_cache_ttl`, `openai_prompt_cache_key`).
+Tavily / Brave keys are read from `TAVILY_API_KEY` / `BRAVE_SEARCH_API_KEY`
+(falls back to `BRAVE_API_KEY`).
+
 ## Compression options
 
 | Param | Purpose |

{compresr-2.6.5 → compresr-2.7.2}/compresr.egg-info/requires.txt

@@ -2,7 +2,7 @@ httpx>=0.27.0
 pydantic>=2.10.0
 langchain>=1.0
 langchain-core>=0.3
-langchain-anthropic>=0.3
+langchain-anthropic>=1.0
 langchain-openai>=0.3
 langchain-google-genai>=4.0
 langchain-tavily>=0.1

{compresr-2.6.5 → compresr-2.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "compresr"
-version = "2.6.5"
+version = "2.7.2"
 description = "Python SDK for Compresr - Intelligent prompt compression service"
 readme = "README.md"
 license = "Apache-2.0"
@@ -35,7 +35,7 @@ dependencies = [
     # Tavily + Brave search tools are all available out of the box.
     "langchain>=1.0",
     "langchain-core>=0.3",
-    "langchain-anthropic>=0.3",
+    "langchain-anthropic>=1.0",
     "langchain-openai>=0.3",
     "langchain-google-genai>=4.0",
     "langchain-tavily>=0.1",