compresr 2.8.2__tar.gz → 2.9.0__tar.gz

{compresr-2.8.2 → compresr-2.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compresr
-Version: 2.8.2
+Version: 2.9.0
 Summary: Python SDK for Compresr - Intelligent prompt compression service
 Author-email: Compresr Team <founders@compresr.ai>
 License-Expression: Apache-2.0
@@ -13,24 +13,24 @@ Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 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>=1.0
-Requires-Dist: langchain-openai>=0.3
-Requires-Dist: langchain-google-genai>=4.0
-Requires-Dist: langchain-tavily>=0.1
-Requires-Dist: langchain-community>=0.3
+Provides-Extra: agents
+Requires-Dist: langchain>=1.0; extra == "agents"
+Requires-Dist: langchain-core>=0.3; extra == "agents"
+Requires-Dist: langchain-anthropic>=1.0; extra == "agents"
+Requires-Dist: langchain-openai>=0.3; extra == "agents"
+Requires-Dist: langchain-google-genai>=4.0; extra == "agents"
+Requires-Dist: langchain-tavily>=0.1; extra == "agents"
+Requires-Dist: langchain-community>=0.3; extra == "agents"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
@@ -38,7 +38,7 @@ Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
 Requires-Dist: pytest-timeout>=2.1.0; extra == "dev"
 Requires-Dist: black>=23.0.0; extra == "dev"
 Requires-Dist: isort>=5.12.0; extra == "dev"
-Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: ruff<0.16,>=0.1.0; extra == "dev"
 Requires-Dist: mypy>=1.0.0; extra == "dev"
 Requires-Dist: python-dotenv>=1.0.0; extra == "dev"
 Provides-Extra: langgraph
@@ -50,20 +50,28 @@ Requires-Dist: litellm[proxy]>=1.79; extra == "litellm"
 Provides-Extra: agentcore
 Requires-Dist: mcp>=1.0; extra == "agentcore"
 Requires-Dist: nest-asyncio>=1.6; extra == "agentcore"
+Provides-Extra: hermes
 Provides-Extra: all
+Requires-Dist: compresr[agents]; extra == "all"
 Requires-Dist: langgraph>=0.2; extra == "all"
 Requires-Dist: llama-index-core>=0.11; extra == "all"
 Requires-Dist: litellm[proxy]>=1.79; extra == "all"
 Requires-Dist: mcp>=1.0; extra == "all"
 Requires-Dist: nest-asyncio>=1.6; extra == "all"
 Provides-Extra: langchain
-Provides-Extra: agents
+Requires-Dist: compresr[agents]; extra == "langchain"
 Provides-Extra: agents-anthropic
+Requires-Dist: compresr[agents]; extra == "agents-anthropic"
 Provides-Extra: agents-openai
+Requires-Dist: compresr[agents]; extra == "agents-openai"
 Provides-Extra: agents-gemini
+Requires-Dist: compresr[agents]; extra == "agents-gemini"
 Provides-Extra: agents-tavily
+Requires-Dist: compresr[agents]; extra == "agents-tavily"
 Provides-Extra: agents-brave
+Requires-Dist: compresr[agents]; extra == "agents-brave"
 Provides-Extra: agents-all
+Requires-Dist: compresr[agents]; extra == "agents-all"
 Dynamic: license-file
 
 # Compresr Python SDK

{compresr-2.8.2 → compresr-2.9.0}/compresr/config.py

@@ -23,6 +23,7 @@ class Endpoints:
     COMPRESS: str = "/api/compress/question-specific/"
     COMPRESS_STREAM: str = "/api/compress/question-specific/stream"
     COMPRESS_BATCH: str = "/api/compress/question-specific/batch"
+    COMPRESS_TOOL_OUTPUT: str = "/api/compress/tool-output/"
 
 
 @dataclass(frozen=True)

compresr-2.9.0/compresr/integrations/hermes/__init__.py

@@ -0,0 +1,35 @@
+"""Compresr × Hermes agent integration.
+
+Two surfaces, both fail-open and opt-in:
+
+- :class:`CompresrContextEngine` — drop-in replacement for Hermes's built-in
+  ``compressor`` context engine (``context.engine: compresr``).
+- :class:`ToolOutputCompressor` — ``transform_tool_result`` hook that shrinks
+  large tool outputs and caches the verbatim original for recovery.
+
+:func:`register` is the Hermes plugin entry point wiring both.
+
+Requires the Hermes agent runtime (this package is loaded as a Hermes plugin,
+inside Hermes's Python process). Importing :mod:`compresr` itself never pulls
+Hermes in — resolution is deferred until these names are accessed.
+"""
+
+from typing import Any
+
+__all__ = ["CompresrContextEngine", "ToolOutputCompressor", "register"]
+
+
+def __getattr__(name: str) -> Any:
+    if name == "CompresrContextEngine":
+        from .engine import CompresrContextEngine as _engine_cls
+
+        return _engine_cls
+    if name == "ToolOutputCompressor":
+        from .tool_output import ToolOutputCompressor as _hook_cls
+
+        return _hook_cls
+    if name == "register":
+        from .plugin import register as _fn
+
+        return _fn
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

compresr-2.9.0/compresr/integrations/hermes/_config.py

@@ -0,0 +1,68 @@
+"""Config resolution for the Hermes integration: env var > config.yaml > default.
+
+All coercions are tolerant — a typo'd value falls back to the default instead
+of raising in a plugin ``__init__`` and silently disabling the feature.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def read_config_block(key: str = "compresr") -> Dict[str, Any]:
+    """Best-effort read of a top-level *key* block from Hermes's config.yaml. Never raises."""
+    try:
+        from hermes_constants import get_hermes_home
+
+        cfg_path = get_hermes_home() / "config.yaml"
+    except Exception:
+        return {}
+    if not cfg_path.exists():
+        return {}
+    try:
+        import yaml
+
+        with open(cfg_path, encoding="utf-8-sig") as f:
+            data = yaml.safe_load(f) or {}
+        block = data.get(key, {})
+        return block if isinstance(block, dict) else {}
+    except Exception as e:
+        logger.debug("compresr: could not read config block %r: %s", key, e)
+        return {}
+
+
+def opt(cfg: Dict[str, Any], env_key: str, cfg_key: str, default: Any) -> Any:
+    val = os.environ.get(env_key)
+    if val is not None and val != "":
+        return val
+    if cfg_key in cfg and cfg[cfg_key] not in (None, ""):
+        return cfg[cfg_key]
+    return default
+
+
+def as_bool(v: Any) -> bool:
+    return str(v).lower() in ("1", "true", "yes", "on")
+
+
+def as_int(v: Any, default: int) -> int:
+    try:
+        return int(v)
+    except (TypeError, ValueError):
+        logger.warning("compresr: invalid numeric value %r, using %s", v, default)
+        return default
+
+
+def as_float(v: Any, default: Optional[float]) -> Optional[float]:
+    try:
+        return float(v)
+    except (TypeError, ValueError):
+        if v not in (None, ""):
+            logger.warning("compresr: invalid numeric value %r, using %s", v, default)
+        return default
+
+
+__all__ = ["read_config_block", "opt", "as_bool", "as_int", "as_float"]

compresr-2.9.0/compresr/integrations/hermes/_security.py

@@ -0,0 +1,142 @@
+"""Base-URL / host validation and secret sanitization for the Hermes integration."""
+
+from __future__ import annotations
+
+import ipaddress
+import logging
+import re
+import socket
+from typing import Any, Optional, Tuple
+from urllib.parse import urlparse
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_BASE_URL = "https://api.compresr.ai"
+
+_SECRET_CTL_RE = re.compile(r"[\r\n\x00]")
+_NUMERIC_ONLY_HOST_RE = re.compile(r"\A(?:0x[0-9a-fA-F]+|[0-9]+)\Z")
+
+_BLOCKED_METADATA_HOST_NAMES = frozenset({"metadata.google.internal", "metadata.goog", "metadata"})
+_BLOCKED_NETWORKS = tuple(
+    ipaddress.ip_network(n)
+    for n in (
+        "169.254.0.0/16",
+        "fd00::/8",
+        "fe80::/10",
+        "100.100.100.200/32",
+        "168.63.129.16/32",
+        "10.0.0.0/8",
+        "172.16.0.0/12",
+        "192.168.0.0/16",
+        "100.64.0.0/10",
+    )
+)
+_LOCALHOST_NAMES = frozenset({"localhost", "127.0.0.1", "::1", "[::1]"})
+
+
+def sanitize_secret(raw: str, label: str) -> str:
+    """Strip whitespace; reject CR/LF/NUL. Returns "" on rejection, never the value."""
+    if not raw:
+        return ""
+    stripped = raw.strip()
+    if _SECRET_CTL_RE.search(stripped):
+        logger.error("compresr: %s contained CR/LF/NUL and was rejected", label)
+        return ""
+    return stripped
+
+
+def _resolve_host_ips(host: str) -> Tuple:
+    if not host:
+        return ()
+    ips: list = []
+    try:
+        ip = ipaddress.ip_address(host)
+        mapped = getattr(ip, "ipv4_mapped", None)
+        ips.append(mapped if mapped is not None else ip)
+        return tuple(ips)
+    except ValueError:
+        pass
+    try:
+        infos = socket.getaddrinfo(host, None, proto=socket.IPPROTO_TCP)
+    except (socket.gaierror, socket.herror, UnicodeError, OSError):
+        return ()
+    for _, _, _, _, sockaddr in infos:
+        try:
+            ip = ipaddress.ip_address(str(sockaddr[0]).split("%", 1)[0])
+        except ValueError:
+            continue
+        mapped = getattr(ip, "ipv4_mapped", None)
+        ips.append(mapped if mapped is not None else ip)
+    return tuple(ips)
+
+
+def _is_blocked_host(host: str) -> bool:
+    """Canonical localhost forms are allow-listed before this check runs; any
+    other loopback representation (127.0.0.2, octal/hex shorthand) is blocked."""
+    h = (host or "").rstrip(".").lower()
+    if h in _BLOCKED_METADATA_HOST_NAMES:
+        return True
+    return any(
+        ip.is_loopback or any(ip in net for net in _BLOCKED_NETWORKS) for ip in _resolve_host_ips(h)
+    )
+
+
+def _safe_url_repr(parsed: Any) -> str:
+    if parsed is None:
+        return "?"
+    try:
+        return f"{parsed.scheme or '?'}://{parsed.hostname or '?'}"
+    except Exception:
+        return "?"
+
+
+def secure_base_url(url: str, default: str = DEFAULT_BASE_URL) -> str:
+    """Reject non-HTTPS (except localhost), numeric-shorthand IPv4 literals,
+    cloud-metadata hosts, and hosts resolving to private/link-local nets.
+    Logs only scheme://host — the raw URL may carry userinfo credentials."""
+    try:
+        parsed = urlparse(url)
+    except Exception:
+        parsed = None
+    host = (parsed.hostname or "").lower() if parsed else ""
+    safe = _safe_url_repr(parsed)
+
+    if parsed and host and _NUMERIC_ONLY_HOST_RE.match(host):
+        logger.warning("compresr: refusing numeric-shorthand IPv4 host %s; using %s", safe, default)
+        return default
+    if parsed and parsed.scheme in ("http", "https") and host in _LOCALHOST_NAMES:
+        return url
+    if parsed and _is_blocked_host(host):
+        logger.warning(
+            "compresr: refusing base_url %s (metadata/private host); using %s",
+            safe,
+            default,
+        )
+        return default
+    if parsed and parsed.scheme == "https":
+        return url
+    logger.warning(
+        "compresr: ignoring insecure base_url %s (must be https); using %s",
+        safe,
+        default,
+    )
+    return default
+
+
+def resolve_base_url(raw: Optional[str]) -> Optional[str]:
+    """Validate a user-supplied base URL for the SDK client; None when unset.
+    A trailing /api is stripped — SDK endpoint paths already carry it."""
+    if raw is None or not str(raw).strip():
+        return None
+    url = secure_base_url(str(raw).strip().rstrip("/"))
+    if url.endswith("/api"):
+        url = url[: -len("/api")]
+    return url
+
+
+__all__ = [
+    "DEFAULT_BASE_URL",
+    "sanitize_secret",
+    "secure_base_url",
+    "resolve_base_url",
+]

compresr-2.9.0/compresr/integrations/hermes/cache.py

@@ -0,0 +1,273 @@
+"""Persist original tool outputs under ``HERMES_HOME/cache/compresr/tool-output``
+so recovery references resolve. Paths are handed out only when the active
+backend can prove it can read them; otherwise callers fail open.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+import shlex
+import threading
+import time
+import uuid
+from pathlib import Path
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+_CACHE_SUBDIR = Path("cache") / "compresr" / "tool-output"
+# Canonical string form of the cache subdir. Exposed so out-of-tree callers
+# (e.g. a host plugin shim) import one source of truth instead of duplicating
+# the literal and risking drift.
+CACHE_SUBPATH = _CACHE_SUBDIR.as_posix()
+_CONTAINER_HERMES_HOME = "/root/.hermes"
+_DIR_MODE = 0o700
+_FILE_MODE = 0o600
+_MB = 1024 * 1024
+
+_STORE_LOCK = threading.Lock()
+
+# Recently-written entries are pinned against eviction so a footer path just
+# handed to the model survives a parallel prune.
+_PRUNE_PIN_SECONDS = 300.0
+
+
+def cache_relpath() -> str:
+    """Cache dir relative to HERMES_HOME, for host mount registration."""
+    return CACHE_SUBPATH
+
+
+def get_cache_root() -> Path:
+    from hermes_constants import get_hermes_home
+
+    return Path(get_hermes_home()) / _CACHE_SUBDIR
+
+
+def ensure_cache_root() -> Path:
+    root = get_cache_root()
+    root.mkdir(parents=True, exist_ok=True, mode=_DIR_MODE)
+    try:
+        os.chmod(root, _DIR_MODE)
+    except OSError:
+        pass
+    return root
+
+
+def cache_file_path(cache_id: str) -> Path:
+    return get_cache_root() / cache_id
+
+
+def _get_active_env(task_id: str) -> Any:
+    try:
+        from tools.terminal_tool import get_active_env as _get
+
+        return _get(task_id)
+    except Exception:
+        return None
+
+
+def _container_file_visible(active_env: Any, container_path: str, host_path: Path) -> bool:
+    """Prove the running container can read *container_path*: Docker bind-mounts
+    are fixed at container creation, so a reused container may lack the mount
+    even when path translation succeeds."""
+    execute = getattr(active_env, "execute", None)
+    if not callable(execute):
+        return False
+    try:
+        expected = host_path.stat().st_size
+    except OSError:
+        return False
+    try:
+        res = execute(f"wc -c < {shlex.quote(str(container_path))}")
+    except Exception as e:
+        logger.debug("compresr: container visibility probe failed: %s", e)
+        return False
+    if not isinstance(res, dict) or res.get("returncode", 1) != 0:
+        return False
+    match = re.search(r"\d+", str(res.get("output", "")))
+    return match is not None and int(match.group()) == expected
+
+
+def _agent_visible_cache_path(cache_path: Path, task_id: str) -> Optional[str]:
+    """Translate *cache_path* to a path the active backend can read, or None."""
+    active_env = _get_active_env(task_id)
+    probe_container = False
+
+    if active_env is not None:
+        env_name = active_env.__class__.__name__
+        if env_name == "LocalEnvironment":
+            try:
+                return str(cache_path.resolve())
+            except OSError:
+                return str(cache_path)
+        if env_name == "SingularityEnvironment" or "singularity" in env_name.lower():
+            return None
+
+        remote_home = getattr(active_env, "_remote_home", None)
+        if isinstance(remote_home, str) and remote_home.strip():
+            container_base = f"{remote_home.rstrip('/')}/.hermes"
+        elif env_name in {"DockerEnvironment", "ModalEnvironment"}:
+            container_base = _CONTAINER_HERMES_HOME
+            probe_container = env_name == "DockerEnvironment"
+        else:
+            return None
+    else:
+        backend = (os.getenv("TERMINAL_ENV") or "local").strip().lower() or "local"
+        if backend == "local":
+            try:
+                return str(cache_path.resolve())
+            except OSError:
+                return str(cache_path)
+        if backend in {"docker", "modal"}:
+            container_base = _CONTAINER_HERMES_HOME
+        else:
+            return None
+
+    try:
+        from tools.credential_files import map_cache_path_to_container
+
+        translated = map_cache_path_to_container(str(cache_path), container_base=container_base)
+        translated = str(translated) if translated else None
+    except Exception as e:
+        logger.debug("compresr: cache path mapping failed: %s", e)
+        return None
+
+    if (
+        translated
+        and probe_container
+        and not _container_file_visible(active_env, translated, cache_path)
+    ):
+        logger.warning(
+            "compresr: container cannot read cache path %s — failing open",
+            translated,
+        )
+        return None
+    return translated
+
+
+def _force_sync_visible_cache(cache_path: Path, task_id: str) -> bool:
+    active_env = _get_active_env(task_id)
+    if active_env is None:
+        return True
+
+    env_name = active_env.__class__.__name__
+    if env_name == "LocalEnvironment":
+        return True
+    if env_name == "SingularityEnvironment" or "singularity" in env_name.lower():
+        return True
+
+    sync_manager = None
+    for attr in ("_sync_manager", "sync_manager", "_file_sync_manager"):
+        candidate = getattr(active_env, attr, None)
+        if candidate is not None and callable(getattr(candidate, "sync", None)):
+            sync_manager = candidate
+            break
+    if sync_manager is None:
+        return True
+
+    try:
+        try:
+            sync_manager.sync(force=True, raise_on_error=True)
+        except TypeError:
+            sync_manager.sync(force=True)
+        return True
+    except Exception as e:
+        logger.warning("compresr: force sync failed for %s: %s", cache_path, e)
+        return False
+
+
+def _prune_cache_dir(cache_dir: str, max_bytes: int, keep_path: str) -> None:
+    if max_bytes <= 0:
+        return
+    root = Path(cache_dir)
+    keep = Path(keep_path)
+    now = time.time()
+    try:
+        entries = []
+        total = 0
+        for path in root.iterdir():
+            if not path.is_file():
+                continue
+            try:
+                stat = path.stat()
+            except OSError:
+                continue
+            size = int(stat.st_size)
+            total += size
+            entries.append((float(stat.st_mtime), path, size))
+        if total <= max_bytes:
+            return
+        for mtime, path, size in sorted(entries):
+            try:
+                if path.resolve() == keep.resolve():
+                    continue
+                if now - mtime < _PRUNE_PIN_SECONDS:
+                    continue
+                path.unlink()
+                total -= size
+            except OSError:
+                continue
+            if total <= max_bytes:
+                break
+    except Exception as e:
+        logger.debug("compresr: cache prune failed for %s: %s", cache_dir, e)
+
+
+def store_original(
+    cache_id: str,
+    content: str,
+    task_id: str = "default",
+    max_cache_mb: int = 256,
+) -> Optional[str]:
+    """Persist ``content`` under ``cache_id``; return an agent-visible path or
+    None (caller must fail open)."""
+    root = ensure_cache_root()
+    cache_path = cache_file_path(cache_id)
+    # O_NOFOLLOW + os.replace: symlink-safe, and concurrent readers see either
+    # full old or full new bytes. Temp name is unique per call: identical
+    # content-addressed ids written from two threads must never share a path.
+    tmp_path = cache_path.with_name(
+        f".{cache_path.name}.{os.getpid()}.{threading.get_ident()}.{uuid.uuid4().hex}.tmp"
+    )
+    try:
+        fd = os.open(
+            str(tmp_path),
+            os.O_WRONLY | os.O_CREAT | os.O_TRUNC | os.O_NOFOLLOW,
+            _FILE_MODE,
+        )
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            f.write(content)
+        try:
+            os.chmod(tmp_path, _FILE_MODE)
+        except OSError:
+            pass
+        os.replace(str(tmp_path), str(cache_path))
+    except Exception as e:
+        logger.warning("compresr: cache write failed for %s: %s", cache_path, e)
+        try:
+            tmp_path.unlink(missing_ok=True)
+        except OSError:
+            pass
+        return None
+
+    sync_ok = _force_sync_visible_cache(cache_path, task_id)
+    visible_path = _agent_visible_cache_path(cache_path, task_id) if sync_ok else None
+
+    # Prune even when the path isn't visible so non-visible backends can't grow
+    # the cache without bound. Never unlink on visibility failure: cache ids are
+    # content-addressed and a sibling may already hold this path.
+    try:
+        with _STORE_LOCK:
+            _prune_cache_dir(str(root), max(0, int(max_cache_mb)) * _MB, str(cache_path))
+    except Exception as e:
+        logger.debug("compresr: cache prune failed: %s", e)
+
+    if visible_path is None:
+        logger.warning(
+            "compresr: cache path not visible to the active backend: %s",
+            cache_path,
+        )
+        return None
+    return visible_path