compresr 2.7.2__tar.gz → 2.7.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compresr
-Version: 2.7.2
+Version: 2.7.3
 Summary: Python SDK for Compresr - Intelligent prompt compression service
 Author-email: Compresr Team <founders@compresr.ai>
 License-Expression: Apache-2.0

compresr-2.7.3/compresr/agents/research/__init__.py

@@ -0,0 +1,24 @@
+"""Compresr research agent — multi-step web search with per-snippet compression.
+
+Public entry: ``client.research.run(question)`` / ``client.research.search(question)``.
+Loop structure adapted from Perplexity ``search_evals`` (MIT,
+https://github.com/perplexityai/search_evals).
+"""
+
+from .agent import ResearchAgent
+from .facade import ResearchFacade
+from .parser import parse_research_output
+from .prompts import DEFAULT_RESEARCH_SYSTEM_PROMPT
+from .types import Citation, ResearchResult, ResearchUsage, Step, StepKind
+
+__all__ = [
+    "Citation",
+    "DEFAULT_RESEARCH_SYSTEM_PROMPT",
+    "ResearchAgent",
+    "ResearchFacade",
+    "ResearchResult",
+    "ResearchUsage",
+    "Step",
+    "StepKind",
+    "parse_research_output",
+]

compresr-2.7.3/compresr/agents/research/agent.py

@@ -0,0 +1,334 @@
+"""``ResearchAgent`` — strict-output ReAct loop with per-snippet compression.
+
+Bypasses ``_Engine.run`` so we can control ``tool_choice`` per step (forces
+the model to commit on the final step) and compress each tool result against
+the live query before it enters the conversation. Cache control is stamped
+manually for Anthropic since ``create_agent`` is not in the call path.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+import time
+from dataclasses import dataclass, field
+from typing import Any, Optional, Sequence
+
+from .parser import parse_research_output
+from .prompts import DEFAULT_RESEARCH_SYSTEM_PROMPT
+from .types import Citation, ResearchResult, ResearchUsage, Step
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_MAX_CONTEXT_TOKENS = 120_000
+_DEFAULT_MAX_STEPS = 10
+_DEFAULT_MIN_COMPRESS_TOKENS = 100
+
+
+def _estimate_tokens(text: str) -> int:
+    return max(1, len(text) // 4)
+
+
+@dataclass
+class _LoopState:
+    """Internal result of :meth:`ResearchAgent._run_loop`.
+
+    Exposed to the engine's solo-WebSearchTool fast-path so it can feed the
+    raw message chain to :meth:`_Engine._normalize` while the public
+    :meth:`run` keeps producing a typed :class:`ResearchResult`.
+    """
+
+    messages: list
+    ai_history: list = field(default_factory=list)
+    trajectory: list = field(default_factory=list)
+    last_ai: Optional[Any] = None
+
+
+class ResearchAgent:
+    """Multi-step web-research agent with on-the-fly compression.
+
+    Args:
+        engine: A live :class:`compresr.agents.engine._Engine`.
+        search_tool: LangChain ``BaseTool`` taking ``query: str``.
+        max_steps: Hard cap on LLM turns. On the final turn ``tool_choice``
+            is set to ``"none"`` so the model has to commit.
+        system_prompt: Override the default research prompt.
+        compress_snippets: Compress each tool result via
+            ``client.compress(query=live_query)`` before appending.
+        compression_model: Compresr model name (default ``"latte_v1"``).
+        min_compress_tokens: Skip compression for tool results below this size.
+        max_context_tokens: Drop the oldest tool-result pair when context
+            exceeds this cap.
+    """
+
+    def __init__(
+        self,
+        *,
+        engine: Any,
+        search_tool: Any,
+        max_steps: int = _DEFAULT_MAX_STEPS,
+        system_prompt: Optional[str] = None,
+        compress_snippets: bool = True,
+        compression_model: str = "latte_v1",
+        min_compress_tokens: int = _DEFAULT_MIN_COMPRESS_TOKENS,
+        max_context_tokens: int = _DEFAULT_MAX_CONTEXT_TOKENS,
+    ) -> None:
+        self._engine = engine
+        self._search_tool = search_tool
+        self._max_steps = max(1, int(max_steps))
+        self._system_prompt = system_prompt or DEFAULT_RESEARCH_SYSTEM_PROMPT
+        self._compress_snippets = bool(compress_snippets)
+        self._compression_model = compression_model
+        self._min_compress_tokens = int(min_compress_tokens)
+        self._max_context_tokens = int(max_context_tokens)
+
+    def run(self, question: str, *, model: Optional[str] = None) -> ResearchResult:
+        state = self._run_loop(question, model=model)
+        usage = self._aggregate_usage(
+            state.ai_history,
+            search_calls=sum(1 for s in state.trajectory if s.type == "search"),
+        )
+        final_text = self._stringify(state.last_ai.content) if state.last_ai is not None else ""
+        parsed = parse_research_output(final_text)
+        citations = self._collect_citations(parsed.citation_urls, state.trajectory)
+
+        return ResearchResult(
+            answer=parsed.answer,
+            explanation=parsed.explanation,
+            confidence=parsed.confidence,
+            text=final_text,
+            citations=citations,
+            trajectory=state.trajectory,
+            usage=usage,
+            raw=state.last_ai,
+        )
+
+    def _run_loop(
+        self,
+        question: str,
+        *,
+        model: Optional[str] = None,
+        extra_chat_kwargs: Optional[dict] = None,
+    ) -> _LoopState:
+        """Execute the strict-output ReAct loop and return raw state.
+
+        Shared by :meth:`run` (which parses ``ResearchResult``) and the
+        engine's solo-WebSearchTool fast-path (which feeds ``state.messages``
+        into :meth:`_Engine._normalize`).
+
+        ``extra_chat_kwargs`` lets the engine path bake per-call LLM knobs
+        (``max_tokens``, ``temperature``…) into the cached chat model so
+        they survive ``bind_tools``.
+        """
+        from langchain_core.messages import (  # type: ignore[import-not-found]
+            HumanMessage,
+            SystemMessage,
+            ToolMessage,
+        )
+
+        effective_model = self._engine._resolve_model(model)
+        chat = self._engine._get_or_build_chat(effective_model, extra_kwargs=extra_chat_kwargs)
+
+        messages: list = [
+            SystemMessage(content=self._system_prompt),
+            HumanMessage(content=question),
+        ]
+        ai_history: list = []
+        trajectory: list[Step] = []
+        last_ai: Optional[Any] = None
+
+        for step_idx in range(self._max_steps):
+            self._maybe_truncate(messages)
+
+            tool_choice = "none" if step_idx == self._max_steps - 1 else "auto"
+            bound = chat.bind_tools([self._search_tool], tool_choice=tool_choice)
+            invoke_messages = self._apply_cache_control(messages)
+
+            t0 = time.time()
+            try:
+                response = bound.invoke(invoke_messages)
+            except Exception as exc:  # noqa: BLE001
+                trajectory.append(
+                    Step(type="error", text=str(exc), latency_s=round(time.time() - t0, 3))
+                )
+                break
+            step_latency = round(time.time() - t0, 3)
+
+            ai_history.append(response)
+            last_ai = response
+            messages.append(response)
+
+            tool_calls = getattr(response, "tool_calls", None) or []
+            if not tool_calls:
+                trajectory.append(
+                    Step(
+                        type="answer",
+                        text=self._stringify(response.content),
+                        latency_s=step_latency,
+                    )
+                )
+                break
+
+            for tc in tool_calls:
+                args = tc.get("args") if isinstance(tc, dict) else {}
+                args = args if isinstance(args, dict) else {}
+                query = args.get("query")
+                trajectory.append(Step(type="search", query=query, latency_s=step_latency))
+
+                raw_result = self._invoke_search(args)
+                final_result = (
+                    self._compress(raw_result, query or question)
+                    if self._compress_snippets
+                    else raw_result
+                )
+                trajectory.append(
+                    Step(
+                        type="tool_result",
+                        chars=len(final_result),
+                        text=final_result,
+                    )
+                )
+
+                tool_call_id = tc.get("id") if isinstance(tc, dict) else None
+                messages.append(
+                    ToolMessage(
+                        content=final_result,
+                        tool_call_id=tool_call_id or "",
+                        name=getattr(self._search_tool, "name", "search_web"),
+                    )
+                )
+
+        return _LoopState(
+            messages=messages,
+            ai_history=ai_history,
+            trajectory=trajectory,
+            last_ai=last_ai,
+        )
+
+    def _apply_cache_control(self, messages: list) -> list:
+        """Stamp Anthropic ephemeral cache_control on the last message.
+
+        Mirrors ``AnthropicPromptCachingMiddleware`` for the bypass path —
+        the research agent does not go through ``create_agent`` so the
+        engine's middleware never runs. No-op for non-Anthropic providers.
+        """
+        provider = getattr(self._engine, "_provider", None)
+        if provider != "anthropic":
+            return messages
+        if not getattr(self._engine, "_enable_prompt_cache", False):
+            return messages
+        min_msgs = getattr(self._engine, "_prompt_cache_min_messages", 2)
+        if len(messages) < min_msgs:
+            return messages
+
+        ttl = getattr(self._engine, "_prompt_cache_ttl", "5m")
+        marker = {"type": "ephemeral", "ttl": ttl}
+        last = messages[-1]
+        content = getattr(last, "content", None)
+        if isinstance(content, str):
+            new_content: list = [{"type": "text", "text": content, "cache_control": marker}]
+        elif isinstance(content, list) and content:
+            new_content = list(content)
+            tail = new_content[-1]
+            if isinstance(tail, dict):
+                tail = dict(tail)
+                tail["cache_control"] = marker
+                new_content[-1] = tail
+            else:
+                new_content.append({"type": "text", "text": str(tail), "cache_control": marker})
+        else:
+            return messages
+
+        try:
+            patched = last.model_copy(update={"content": new_content})
+        except Exception:  # noqa: BLE001
+            patched = type(last)(content=new_content)
+        return [*messages[:-1], patched]
+
+    def _invoke_search(self, args: dict) -> str:
+        try:
+            out = self._search_tool.invoke(args)
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("research: search tool raised %s; agent will continue", exc)
+            return f"Search error: {exc}"
+        return self._stringify(out)
+
+    def _compress(self, text: str, query: str) -> str:
+        if not text or _estimate_tokens(text) < self._min_compress_tokens:
+            return text
+        client = self._engine._compresr_client
+        try:
+            resp = client.compress(
+                context=text,
+                query=query,
+                compression_model_name=self._compression_model,
+            )
+            data = getattr(resp, "data", None)
+            compressed = getattr(data, "compressed_context", None) if data is not None else None
+            return compressed if isinstance(compressed, str) and compressed else text
+        except Exception as exc:  # noqa: BLE001
+            logger.debug("research: compression failed (%s); using raw snippet", exc)
+            return text
+
+    def _maybe_truncate(self, messages: list) -> None:
+        if not self._max_context_tokens:
+            return
+        total = sum(_estimate_tokens(self._stringify(getattr(m, "content", ""))) for m in messages)
+        if total <= self._max_context_tokens:
+            return
+        guard = 0
+        while total > self._max_context_tokens and len(messages) >= 4 and guard < 4:
+            del messages[2:4]
+            total = sum(
+                _estimate_tokens(self._stringify(getattr(m, "content", ""))) for m in messages
+            )
+            guard += 1
+
+    def _aggregate_usage(
+        self,
+        ai_messages: Sequence[Any],
+        *,
+        search_calls: int = 0,
+    ) -> ResearchUsage:
+        from compresr.agents.engine import _aggregate_usage
+
+        agg = _aggregate_usage(list(ai_messages))
+        return ResearchUsage(
+            input_tokens=int(agg.get("input_tokens", 0) or 0),
+            output_tokens=int(agg.get("output_tokens", 0) or 0),
+            cache_read_tokens=int(agg.get("cache_read_input_tokens", 0) or 0),
+            cache_creation_tokens=int(agg.get("cache_creation_input_tokens", 0) or 0),
+            calls=len(ai_messages),
+            search_calls=int(search_calls or 0),
+        )
+
+    def _collect_citations(
+        self, parsed_urls: Sequence[str], trajectory: Sequence[Step]
+    ) -> list[Citation]:
+        urls: list[str] = []
+        for u in parsed_urls:
+            if u not in urls:
+                urls.append(u)
+        for step in trajectory:
+            if step.type != "tool_result" or not step.text:
+                continue
+            for url in re.findall(r"https?://[^\s,;<>\"')]+", step.text):
+                if url not in urls:
+                    urls.append(url)
+        return [Citation(url=u) for u in urls]
+
+    @staticmethod
+    def _stringify(content: Any) -> str:
+        if isinstance(content, str):
+            return content
+        if isinstance(content, list):
+            parts = []
+            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 ""

compresr-2.7.3/compresr/agents/research/facade.py

@@ -0,0 +1,94 @@
+"""``client.research`` facade — thin wrapper over :class:`ResearchAgent`."""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Optional
+
+from .agent import ResearchAgent
+from .types import ResearchResult
+
+_SEARCH_PROVIDER_ENV = {
+    "tavily": ("TAVILY_API_KEY",),
+    "brave": ("BRAVE_SEARCH_API_KEY", "BRAVE_API_KEY"),
+}
+
+
+class ResearchFacade:
+    def __init__(self, engine: Any) -> None:
+        self._engine = engine
+
+    def run(
+        self,
+        question: str,
+        *,
+        search: Any = "tavily",
+        max_steps: int = 10,
+        model: Optional[str] = None,
+        compress_snippets: bool = True,
+        compression_model: str = "latte_v1",
+        min_compress_tokens: int = 100,
+        max_context_tokens: int = 120_000,
+        system_prompt: Optional[str] = None,
+    ) -> ResearchResult:
+        """Multi-step research loop.
+
+        ``search`` is either a provider name (``"tavily"`` | ``"brave"``)
+        or a ready-made LangChain ``BaseTool``.
+        """
+        tool = self._resolve_search_tool(search)
+        agent = ResearchAgent(
+            engine=self._engine,
+            search_tool=tool,
+            max_steps=max_steps,
+            system_prompt=system_prompt,
+            compress_snippets=compress_snippets,
+            compression_model=compression_model,
+            min_compress_tokens=min_compress_tokens,
+            max_context_tokens=max_context_tokens,
+        )
+        return agent.run(question, model=model)
+
+    def search(
+        self,
+        question: str,
+        *,
+        search: Any = "tavily",
+        model: Optional[str] = None,
+        compress_snippets: bool = True,
+        compression_model: str = "latte_v1",
+        min_compress_tokens: int = 100,
+        max_context_tokens: int = 120_000,
+        system_prompt: Optional[str] = None,
+    ) -> ResearchResult:
+        """Single-shot: one search + forced answer (``max_steps=2``)."""
+        return self.run(
+            question,
+            search=search,
+            max_steps=2,
+            model=model,
+            compress_snippets=compress_snippets,
+            compression_model=compression_model,
+            min_compress_tokens=min_compress_tokens,
+            max_context_tokens=max_context_tokens,
+            system_prompt=system_prompt,
+        )
+
+    def _resolve_search_tool(self, search: Any) -> Any:
+        if not isinstance(search, str):
+            return search
+        provider = search.lower()
+        if provider not in _SEARCH_PROVIDER_ENV:
+            raise ValueError(
+                f"unsupported search provider {search!r}; expected one of "
+                f"{sorted(_SEARCH_PROVIDER_ENV)} or a LangChain BaseTool"
+            )
+        from ..tools.web_search import WebSearchTool
+
+        api_key: Optional[str] = None
+        for env_var in _SEARCH_PROVIDER_ENV[provider]:
+            v = os.environ.get(env_var)
+            if v:
+                api_key = v
+                break
+        return WebSearchTool(provider=provider, api_key=api_key)

compresr-2.7.3/compresr/agents/research/parser.py

@@ -0,0 +1,62 @@
+"""Parse the strict-format final response into structured fields."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass(frozen=True)
+class _Parsed:
+    answer: str
+    explanation: str
+    confidence: Optional[float]
+    citation_urls: list[str]
+
+
+_FIELD_PATTERNS = {
+    "explanation": r"(?im)^\s*explanation\s*:\s*(.+?)(?=^\s*(?:exact\s+answer|confidence|citations)\s*:|\Z)",
+    "answer": r"(?im)^\s*exact\s+answer\s*:\s*(.+?)(?=^\s*(?:explanation|confidence|citations)\s*:|\Z)",
+    "confidence": r"(?im)^\s*confidence\s*:\s*(.+?)(?=^\s*(?:explanation|exact\s+answer|citations)\s*:|\Z)",
+    "citations": r"(?im)^\s*citations\s*:\s*(.+?)\Z",
+}
+
+
+def parse_research_output(text: str) -> _Parsed:
+    """Extract Explanation / Exact Answer / Confidence / Citations from ``text``.
+
+    Missing fields default to empty / None. Confidence accepts ``"62"``,
+    ``"62%"``, or ``"0.62"`` and normalizes to a 0–1 float.
+    """
+    if not text:
+        return _Parsed(answer="", explanation="", confidence=None, citation_urls=[])
+
+    def _grab(name: str) -> str:
+        m = re.search(_FIELD_PATTERNS[name], text, re.DOTALL)
+        return m.group(1).strip() if m else ""
+
+    answer = _grab("answer")
+    explanation = _grab("explanation")
+    confidence_raw = _grab("confidence")
+    citations_raw = _grab("citations")
+
+    confidence: Optional[float] = None
+    if confidence_raw:
+        m = re.search(r"(\d+(?:\.\d+)?)", confidence_raw)
+        if m:
+            v = float(m.group(1))
+            confidence = v / 100 if v > 1 else v
+
+    citation_urls: list[str] = []
+    if citations_raw:
+        for url in re.findall(r"https?://[^\s,;<>\"']+", citations_raw):
+            if url not in citation_urls:
+                citation_urls.append(url)
+
+    return _Parsed(
+        answer=answer,
+        explanation=explanation,
+        confidence=confidence,
+        citation_urls=citation_urls,
+    )

compresr-2.7.3/compresr/agents/research/prompts.py

@@ -0,0 +1,35 @@
+"""System prompts for the research agent.
+
+Default prompt adapted from Perplexity ``search_evals`` (MIT,
+https://github.com/perplexityai/search_evals/blob/main/search_evals/agents/deep_research.py).
+"""
+
+DEFAULT_RESEARCH_SYSTEM_PROMPT = """\
+You are a research agent. The user will ask you a specific question whose answer cannot be reliably produced from your internal weights (hallucination risk is high), and that takes several steps of web research to resolve.
+
+## Tool
+search_web(query: str) — Search the web with a single query. Returns titles, URLs, and snippets.
+
+## Query format
+Write queries for a modern keyword/semantic search engine, not for an LLM:
+- Keep them focused — search is a limited budget.
+- Do not rely on quotes, brackets, or special syntax.
+- Natural language is fine; keyword strings are fine too.
+
+## Solution strategy
+You have a hard search budget. At each step, decrement the counter and plan ahead how you will spend what is left. Ask yourself: did this SERP bring me closer to the answer? If not, and rephrasing didn't help, explicitly say you're switching hypothesis and pursue a different direction.
+
+## General web-search recommendations
+- One query at a time.
+- Cross-verify across sources before committing.
+- If sources conflict, search more to resolve the conflict.
+- Never assert a claim you don't have a source for.
+
+## Response format (mandatory)
+When you are done researching, end your response with exactly these fields in this order:
+
+Explanation: <your research process and the key findings from each source>
+Exact Answer: <the precise final answer, or "I don't know" if you couldn't find it>
+Confidence: <0-100%>
+Citations: <comma-separated list of URLs you actually relied on>
+"""

compresr-2.7.3/compresr/agents/research/types.py

@@ -0,0 +1,69 @@
+"""Dataclasses returned by :class:`ResearchAgent.run`."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Literal, Optional
+
+StepKind = Literal["search", "tool_result", "answer", "error"]
+
+
+@dataclass(frozen=True)
+class Citation:
+    url: str
+    title: Optional[str] = None
+    snippet: Optional[str] = None
+
+
+@dataclass(frozen=True)
+class Step:
+    """One step in the agent trajectory."""
+
+    type: StepKind
+    query: Optional[str] = None
+    text: Optional[str] = None
+    chars: Optional[int] = None
+    latency_s: Optional[float] = None
+
+
+@dataclass(frozen=True)
+class ResearchUsage:
+    """Raw usage counts aggregated across the research loop.
+
+    The SDK exposes counts only — no USD pricing. Neither Anthropic / OpenAI
+    inference responses nor Brave / Tavily search responses carry a per-call
+    dollar field, so any cost rollup must be done by the caller against their
+    own (mutable) price table. Compresr's benchmark suite owns the canonical
+    table for its experiments; downstream apps are expected to do the same.
+
+    Fields:
+      * ``input_tokens`` / ``output_tokens`` — fresh tokens, as reported by
+        the provider's ``usage`` block.
+      * ``cache_read_tokens`` / ``cache_creation_tokens`` — Anthropic
+        ephemeral cache classes (0 elsewhere).
+      * ``calls`` — LLM round-trips (one per loop step that hit the model).
+      * ``search_calls`` — number of times the search tool fired. Independent
+        of ``calls`` because one LLM turn can request multiple tool calls.
+    """
+
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cache_read_tokens: int = 0
+    cache_creation_tokens: int = 0
+    calls: int = 0
+    search_calls: int = 0
+
+
+@dataclass(frozen=True)
+class ResearchResult:
+    """Final research output. ``text`` is the model's raw final response;
+    ``answer`` / ``explanation`` / ``confidence`` are parsed from it."""
+
+    answer: str
+    explanation: str
+    confidence: Optional[float]
+    text: str
+    citations: list[Citation] = field(default_factory=list)
+    trajectory: list[Step] = field(default_factory=list)
+    usage: ResearchUsage = field(default_factory=ResearchUsage)
+    raw: Any = None

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compresr
-Version: 2.7.2
+Version: 2.7.3
 Summary: Python SDK for Compresr - Intelligent prompt compression service
 Author-email: Compresr Team <founders@compresr.ai>
 License-Expression: Apache-2.0

{compresr-2.7.2 → compresr-2.7.3}/compresr.egg-info/SOURCES.txt

@@ -16,6 +16,12 @@ compresr/agents/facades/__init__.py
 compresr/agents/facades/anthropic.py
 compresr/agents/facades/native.py
 compresr/agents/facades/openai.py
+compresr/agents/research/__init__.py
+compresr/agents/research/agent.py
+compresr/agents/research/facade.py
+compresr/agents/research/parser.py
+compresr/agents/research/prompts.py
+compresr/agents/research/types.py
 compresr/agents/schemas/__init__.py
 compresr/agents/schemas/anthropic.py
 compresr/agents/schemas/openai.py

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "compresr"
-version = "2.7.2"
+version = "2.7.3"
 description = "Python SDK for Compresr - Intelligent prompt compression service"
 readme = "README.md"
 license = "Apache-2.0"
@@ -90,23 +90,14 @@ Documentation = "https://compresr.ai/docs"
 Repository = "https://github.com/Compresr-ai/Compresr-SDK"
 Issues = "https://github.com/Compresr-ai/Compresr-SDK/issues"
 
-[tool.setuptools]
-packages = [
-    "compresr",
-    "compresr.services",
-    "compresr.schemas",
-    "compresr.exceptions",
-    "compresr.integrations",
-    "compresr.integrations._shared",
-    "compresr.integrations.langchain",
-    "compresr.integrations.langgraph",
-    "compresr.integrations.llamaindex",
-    "compresr.integrations.litellm",
-    "compresr.agents",
-    "compresr.agents.tools",
-    "compresr.agents.facades",
-    "compresr.agents.schemas",
-]
+[tool.setuptools.packages.find]
+# Autodiscover every `compresr` subpackage so newly added ones (e.g.
+# `compresr.agents.research`) ship automatically. A previous hand-maintained
+# `packages = [...]` allowlist silently dropped packages that weren't added to
+# it by hand. The `compresr*` filter keeps sibling dirs (tests, tutorial,
+# litellm_shim) out of the distribution.
+where = ["."]
+include = ["compresr*"]
 
 [tool.setuptools.package-data]
 compresr = ["py.typed"]