compresr 2.7.3__tar.gz → 2.7.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compresr
-Version: 2.7.3
+Version: 2.7.6
 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-2.7.6}/compresr/agents/engine.py

@@ -23,11 +23,6 @@ from .normalized import Citation, CompresrStats, NormalizedResult
 logger = logging.getLogger(__name__)
 
 
-# ---------------------------------------------------------------------------
-# Lazy imports — keep `import compresr.agents` cheap.
-# ---------------------------------------------------------------------------
-
-
 def _import_lc() -> tuple[Any, Any, Any]:
     """Resolve ``init_chat_model``, ``create_agent``, and middleware lazily."""
     try:
@@ -56,28 +51,9 @@ def _CompresrToolMiddleware(*args: Any, **kwargs: Any) -> Any:
     return _mw(*args, **kwargs)
 
 
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-
 _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.
@@ -163,6 +139,13 @@ _LLM_BIND_KWARGS = frozenset(
     }
 )
 
+# Constructor-only kwargs — transport, not per-call LLM knobs. Baked into the
+# chat model at build time so a custom httpx client (corporate proxy / custom
+# CA bundle / verify=False) reaches the provider SDK. Requires langchain-anthropic
+# >= the release that adds ``http_client``/``http_async_client`` to ChatAnthropic;
+# langchain-openai already supports both.
+_LLM_CONSTRUCTOR_KWARGS = frozenset({"http_client", "http_async_client"})
+
 
 def _parse_llm(llm: str) -> tuple[str, Optional[str]]:
     """Split ``"provider[:model]"`` (or ``"provider[/model]"``) into
@@ -259,7 +242,6 @@ def _extract_citations(msg: Any) -> list:
     for block in blocks:
         if not isinstance(block, dict):
             continue
-        # Anthropic: text block with `citations` list
         for cit in block.get("citations", []) or []:
             if not isinstance(cit, dict):
                 continue
@@ -275,7 +257,6 @@ def _extract_citations(msg: Any) -> list:
                         provider_metadata=dict(cit),
                     )
                 )
-        # OpenAI Responses: annotations[] with type="url_citation"
         for ann in block.get("annotations", []) or []:
             if not isinstance(ann, dict):
                 continue
@@ -291,7 +272,6 @@ def _extract_citations(msg: Any) -> list:
                         provider_metadata=dict(ann),
                     )
                 )
-    # Gemini: grounding_metadata on response_metadata
     response_metadata = getattr(msg, "response_metadata", None) or {}
     grounding = response_metadata.get("grounding_metadata") or {}
     for chunk in grounding.get("grounding_chunks", []) or []:
@@ -446,11 +426,6 @@ def _last_ai_message(messages: list) -> Any:
     return messages[-1] if messages else None
 
 
-# ---------------------------------------------------------------------------
-# _Engine
-# ---------------------------------------------------------------------------
-
-
 class _Engine:
     """Private engine shared by the provider-shape facades.
 
@@ -478,6 +453,8 @@ class _Engine:
         prompt_cache_ttl: str = "5m",
         prompt_cache_min_messages: int = 2,
         openai_prompt_cache_key: Optional[str] = None,
+        llm_http_client: Any = None,
+        llm_http_async_client: Any = None,
     ) -> None:
         self._compresr_client = compresr_client
         self._provider, self._default_model_name = _parse_llm(llm)
@@ -487,6 +464,11 @@ class _Engine:
         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
+        # Custom httpx clients for the LLM provider transport (corporate proxy /
+        # custom CA / verify settings). Baked into every chat-model build; a
+        # per-call http_client passed to run() overrides these.
+        self._llm_http_client = llm_http_client
+        self._llm_http_async_client = llm_http_async_client
         # 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.
@@ -494,10 +476,6 @@ class _Engine:
         # combinations get their own cached chat model.
         self._chat_models: dict[tuple[str, tuple], Any] = {}
 
-    # ------------------------------------------------------------------
-    # Public, read-only accessors
-    # ------------------------------------------------------------------
-
     @property
     def provider(self) -> str:
         return self._provider
@@ -516,10 +494,6 @@ class _Engine:
         """
         return self._default_model_name
 
-    # ------------------------------------------------------------------
-    # Build helpers
-    # ------------------------------------------------------------------
-
     def _get_or_build_chat(self, model_name: str, extra_kwargs: Optional[dict] = None) -> Any:
         """Return a cached chat model for ``model_name`` + ``extra_kwargs``,
         building on miss.
@@ -544,6 +518,14 @@ class _Engine:
         kwargs: dict = dict(extra_kwargs)
         if self._llm_api_key is not None:
             kwargs.setdefault("api_key", self._llm_api_key)
+        # Client-level custom httpx clients. setdefault so a per-call override
+        # from run(http_client=...) wins. Only Anthropic and OpenAI chat models
+        # accept these kwargs; google_genai uses a different transport.
+        if self._provider in ("anthropic", "openai"):
+            if self._llm_http_client is not None:
+                kwargs.setdefault("http_client", self._llm_http_client)
+            if self._llm_http_async_client is not None:
+                kwargs.setdefault("http_async_client", self._llm_http_async_client)
         # OpenAI caching is server-side; we only pass ``prompt_cache_key``
         # and ``prompt_cache_retention`` via ``model_kwargs`` so they survive
         # ``bind_tools``.
@@ -564,8 +546,50 @@ class _Engine:
                 )
             except TypeError:  # pragma: no cover - older langchain-openai
                 logger.debug("init_chat_model rejected output_version; falling back without it")
+        if self._provider == "anthropic":
+            return self._build_anthropic_chat(model_name, kwargs)
         return init_chat_model(f"{self._provider}:{model_name}", **kwargs)
 
+    def _build_anthropic_chat(self, model_name: str, kwargs: dict) -> Any:
+        """Build an Anthropic chat model, shimming ``http_client`` support on
+        versions of langchain-anthropic that predate the native field.
+
+        Native field present (PR merged / future release) → pass through. Absent
+        (current PyPI) → strip the unknown kwargs so the constructor doesn't drop
+        them silently, then swap the cached anthropic SDK client for one built
+        with the caller's httpx client. The shim is a no-op once native support
+        ships, so it can be removed then. See langchain issue #36056."""
+        from langchain_anthropic import ChatAnthropic
+
+        native = "http_client" in ChatAnthropic.model_fields
+        sync_client = kwargs.get("http_client")
+        async_client = kwargs.get("http_async_client")
+        if not native:
+            kwargs.pop("http_client", None)
+            kwargs.pop("http_async_client", None)
+
+        chat = init_chat_model(f"anthropic:{model_name}", **kwargs)
+
+        if not native and (sync_client is not None or async_client is not None):
+            self._inject_anthropic_http_client(chat, sync_client, async_client)
+        return chat
+
+    @staticmethod
+    def _inject_anthropic_http_client(chat: Any, sync_client: Any, async_client: Any) -> None:
+        """Replace ChatAnthropic's cached SDK clients with ones built around the
+        caller's httpx client, reusing langchain's own ``_client_params`` so
+        api_key / base_url / retries / headers stay correct. Writes through
+        ``__dict__`` to seed the ``cached_property`` before first access."""
+        import anthropic
+
+        params = dict(chat._client_params)
+        if sync_client is not None:
+            chat.__dict__["_client"] = anthropic.Anthropic(**{**params, "http_client": sync_client})
+        if async_client is not None:
+            chat.__dict__["_async_client"] = anthropic.AsyncClient(
+                **{**params, "http_client": async_client}
+            )
+
     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
@@ -669,7 +693,7 @@ class _Engine:
         """
         bind_kwargs: dict = {}
         for key in list(kw):
-            if key in _LLM_BIND_KWARGS:
+            if key in _LLM_BIND_KWARGS or key in _LLM_CONSTRUCTOR_KWARGS:
                 bind_kwargs[key] = kw.pop(key)
         if max_tokens is not None:
             # Explicit signature param always reflects customer intent.
@@ -720,10 +744,6 @@ class _Engine:
         # facades layer; for now just keep the original messages.
         return list(messages)
 
-    # ------------------------------------------------------------------
-    # run / arun
-    # ------------------------------------------------------------------
-
     def run(
         self,
         *,
@@ -840,10 +860,6 @@ class _Engine:
         )
         return self._normalize({"messages": state.messages})
 
-    # ------------------------------------------------------------------
-    # Normalization
-    # ------------------------------------------------------------------
-
     def _normalize(self, agent_result: Any) -> NormalizedResult:
         """Reshape ``{"messages": [...]}`` into a :class:`NormalizedResult`.
 

{compresr-2.7.3 → compresr-2.7.6}/compresr/agents/research/types.py

@@ -28,23 +28,7 @@ class Step:
 
 @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.
-    """
+    """Token + tool-call counts across the research loop."""
 
     input_tokens: int = 0
     output_tokens: int = 0

{compresr-2.7.3 → compresr-2.7.6}/compresr/exceptions/__init__.py

@@ -5,7 +5,7 @@ Exact copies of exceptions from backend.
 Single source of truth maintained in backend.
 """
 
-from .exceptions import (  # Response models; Exception classes
+from .exceptions import (
     ApiKeyBudgetError,
     AuthenticationError,
     AuthenticationErrorResponse,
@@ -40,7 +40,6 @@ ConnectionError = CompresrConnectionError
 TimeoutError = CompresrTimeoutError
 
 __all__ = [
-    # Response models
     "ErrorResponse",
     "ValidationErrorResponse",
     "AuthenticationErrorResponse",
@@ -49,7 +48,6 @@ __all__ = [
     "ServerErrorResponse",
     "NotFoundErrorResponse",
     "ConnectionErrorResponse",
-    # Exception classes
     "CompresrError",
     "AuthenticationError",
     "TargetAuthenticationError",
@@ -59,16 +57,13 @@ __all__ = [
     "ServerError",
     "NotFoundError",
     "CompresrConnectionError",
-    # Budget & Credits
     "InsufficientCreditsError",
     "BudgetLimitError",
     "DailyLimitError",
     "ApiKeyBudgetError",
-    # Model & Input
     "ModelNotFoundError",
     "ContextWindowExceededError",
     "ContentPolicyError",
-    # Service
     "CompresrTimeoutError",
     "ServiceUnavailableError",
 ]

{compresr-2.7.3 → compresr-2.7.6}/compresr/exceptions/exceptions.py

@@ -8,8 +8,6 @@ from typing import Optional
 
 from pydantic import BaseModel
 
-# Response Models (for documentation)
-
 
 class ErrorResponse(BaseModel):
     """Generic error response."""
@@ -78,9 +76,6 @@ class ConnectionErrorResponse(BaseModel):
     code: str = "connection_error"
 
 
-# Exception Classes
-
-
 class CompresrError(Exception):
     """Base exception for all Compresr errors."""
 
@@ -167,9 +162,6 @@ class CompresrConnectionError(CompresrError):
         self.service = service
 
 
-# Budget & Credits Errors
-
-
 class InsufficientCreditsError(CompresrError):
     """User has insufficient credits to complete the request."""
 
@@ -230,9 +222,6 @@ class ApiKeyBudgetError(CompresrError):
         self.api_key_used = api_key_used
 
 
-# Model & Input Errors
-
-
 class ModelNotFoundError(CompresrError):
     """Requested model does not exist."""
 
@@ -276,9 +265,6 @@ class ContentPolicyError(CompresrError):
         self.provider = provider
 
 
-# Service Errors
-
-
 class CompresrTimeoutError(CompresrError):
     """Request timed out."""
 

{compresr-2.7.3 → compresr-2.7.6}/compresr/integrations/langchain/middleware.py

@@ -195,11 +195,6 @@ class CompresrToolMiddleware(_CompresrMiddlewareBase):
         return _build_tool_message(new, result) if new != result.content else result
 
 
-# ---------------------------------------------------------------------------
-# Summarization-style history compression
-# ---------------------------------------------------------------------------
-
-
 SUMMARY_PREFIX = "[Earlier conversation summary]\n\n"
 
 
@@ -297,7 +292,6 @@ class CompresrSummarizationMiddleware(_CompresrMiddlewareBase):
         if total < self._max_tokens:
             return None
 
-        # Split: everything but the last `keep` is "old".
         to_summarize = messages[: -self._keep]
         recent = messages[-self._keep :]
         if not to_summarize:
@@ -337,11 +331,6 @@ class CompresrSummarizationMiddleware(_CompresrMiddlewareBase):
         }
 
 
-# ---------------------------------------------------------------------------
-# CompresrPromptMiddleware — outbound prompt budget cap
-# ---------------------------------------------------------------------------
-
-
 def _rebuild_with_content(msg: "BaseMessage", new_content: str) -> "BaseMessage":
     """Recreate a message of the same class with new string content."""
     kwargs: dict = {"content": new_content}
@@ -530,14 +519,12 @@ def _rebuild_request(request: Any, messages: list) -> Any:
     side-effect free. Falls back to mutation only if neither the Pydantic
     ``model_copy`` path nor the ``__dict__`` copy path is available.
     """
-    # Pydantic v2 models expose ``model_copy(update=...)``.
     model_copy = getattr(request, "model_copy", None)
     if callable(model_copy):
         try:
             return model_copy(update={"messages": messages})
         except Exception:  # noqa: BLE001 — fall through to dict path
             pass
-    # Generic objects: clone via ``__class__`` + ``__dict__`` where possible.
     cls = type(request)
     try:
         clone = cls.__new__(cls)  # type: ignore[call-overload]

compresr-2.7.6/compresr/integrations/litellm/__init__.py

@@ -0,0 +1,54 @@
+"""LiteLLM integration for Compresr (proxy guardrail)."""
+
+from __future__ import annotations
+
+import os
+
+try:
+    import litellm  # noqa: F401
+except ImportError as exc:  # pragma: no cover
+    raise ImportError(
+        "compresr LiteLLM integration requires litellm. "
+        "Install with: pip install compresr[litellm]"
+    ) from exc
+
+from .guardrail import (
+    CompresrGuardrail,
+    CompresrGuardrailError,
+    CompresrGuardrailMissingSecrets,
+)
+from .initializer import (
+    guardrail_class_registry,
+    guardrail_initializer_registry,
+    initialize_guardrail,
+)
+from .types import (
+    CompresrGuardrailConfigModel,
+    CompresrGuardrailConfigModelOptionalParams,
+)
+
+
+def _maybe_auto_install_shim() -> None:
+    if os.environ.get("COMPRESR_AUTO_INSTALL_SHIM", "").lower() not in ("1", "true", "yes"):
+        return
+    try:
+        from .shim_installer import install
+
+        install(verbose=False)
+    except Exception:  # pragma: no cover - best-effort
+        pass
+
+
+_maybe_auto_install_shim()
+
+
+__all__ = [
+    "CompresrGuardrail",
+    "CompresrGuardrailConfigModel",
+    "CompresrGuardrailConfigModelOptionalParams",
+    "CompresrGuardrailError",
+    "CompresrGuardrailMissingSecrets",
+    "guardrail_class_registry",
+    "guardrail_initializer_registry",
+    "initialize_guardrail",
+]

compresr-2.7.6/compresr/integrations/litellm/cli.py

@@ -0,0 +1,41 @@
+"""``compresr-litellm`` — stock ``litellm`` CLI with the Compresr guardrail pre-registered."""
+
+from __future__ import annotations
+
+import sys
+
+
+def register() -> None:
+    """Inject the Compresr guardrail into LiteLLM's in-memory registries."""
+    try:
+        from litellm.proxy.guardrails.guardrail_registry import (
+            guardrail_class_registry,
+            guardrail_initializer_registry,
+        )
+    except ImportError as exc:  # pragma: no cover
+        raise SystemExit(
+            "compresr-litellm requires the LiteLLM proxy. "
+            "Install with: pip install 'compresr[litellm]'"
+        ) from exc
+
+    from . import CompresrGuardrail, initialize_guardrail
+
+    guardrail_initializer_registry["compresr"] = initialize_guardrail
+    guardrail_class_registry["compresr"] = CompresrGuardrail
+
+
+def main() -> None:
+    register()
+    try:
+        from litellm.proxy.proxy_cli import run_server
+    except ImportError as exc:  # pragma: no cover
+        raise SystemExit(
+            "compresr-litellm requires the LiteLLM proxy. "
+            "Install with: pip install 'compresr[litellm]'"
+        ) from exc
+    run_server()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()
+    sys.exit(0)