echo-agent 0.1.0__py3-none-any.whl

echo_agent/a2a/client.py

@@ -0,0 +1,66 @@
+"""A2A client — discover and delegate to remote agents."""
+
+from __future__ import annotations
+
+import aiohttp
+
+from echo_agent.a2a.models import AgentCard, A2ATask, A2AMessage
+
+
+class A2AClient:
+    def __init__(self, timeout: float = 60):
+        self._timeout = timeout
+
+    async def discover(self, base_url: str) -> AgentCard:
+        url = f"{base_url.rstrip('/')}/.well-known/agent.json"
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url, timeout=aiohttp.ClientTimeout(total=self._timeout)) as resp:
+                data = await resp.json()
+                return AgentCard(
+                    name=data.get("name", ""),
+                    description=data.get("description", ""),
+                    url=base_url,
+                    version=data.get("version", ""),
+                    capabilities=[],
+                )
+
+    async def send_task(self, base_url: str, message: str, task_id: str = "") -> A2ATask:
+        url = f"{base_url.rstrip('/')}/a2a"
+        payload = {
+            "jsonrpc": "2.0",
+            "id": "1",
+            "method": "tasks/send",
+            "params": {
+                "id": task_id,
+                "message": A2AMessage.text("user", message).to_dict(),
+            },
+        }
+        async with aiohttp.ClientSession() as session:
+            async with session.post(url, json=payload, timeout=aiohttp.ClientTimeout(total=self._timeout)) as resp:
+                data = await resp.json()
+                result = data.get("result", {})
+                return A2ATask.from_dict(result)
+
+    async def get_task(self, base_url: str, task_id: str) -> A2ATask:
+        url = f"{base_url.rstrip('/')}/a2a"
+        payload = {
+            "jsonrpc": "2.0", "id": "1",
+            "method": "tasks/get",
+            "params": {"id": task_id},
+        }
+        async with aiohttp.ClientSession() as session:
+            async with session.post(url, json=payload, timeout=aiohttp.ClientTimeout(total=self._timeout)) as resp:
+                data = await resp.json()
+                return A2ATask.from_dict(data.get("result", {}))
+
+    async def cancel_task(self, base_url: str, task_id: str) -> A2ATask:
+        url = f"{base_url.rstrip('/')}/a2a"
+        payload = {
+            "jsonrpc": "2.0", "id": "1",
+            "method": "tasks/cancel",
+            "params": {"id": task_id},
+        }
+        async with aiohttp.ClientSession() as session:
+            async with session.post(url, json=payload, timeout=aiohttp.ClientTimeout(total=self._timeout)) as resp:
+                data = await resp.json()
+                return A2ATask.from_dict(data.get("result", {}))

echo_agent/a2a/models.py

@@ -0,0 +1,98 @@
+"""A2A protocol data models — Agent Card, Task, Message, Artifact."""
+
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Any
+
+
+class TaskState(str, Enum):
+    SUBMITTED = "submitted"
+    WORKING = "working"
+    INPUT_REQUIRED = "input-required"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELED = "canceled"
+
+
+@dataclass
+class A2AMessage:
+    role: str  # "user" or "agent"
+    parts: list[dict[str, Any]] = field(default_factory=list)
+
+    @classmethod
+    def text(cls, role: str, content: str) -> A2AMessage:
+        return cls(role=role, parts=[{"type": "text", "text": content}])
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"role": self.role, "parts": self.parts}
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> A2AMessage:
+        return cls(role=data.get("role", "user"), parts=data.get("parts", []))
+
+    @property
+    def text_content(self) -> str:
+        return " ".join(p.get("text", "") for p in self.parts if p.get("type") == "text")
+
+
+@dataclass
+class Artifact:
+    name: str = ""
+    content_type: str = "text/plain"
+    data: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"name": self.name, "contentType": self.content_type, "data": self.data}
+
+
+@dataclass
+class A2ATask:
+    id: str = field(default_factory=lambda: uuid.uuid4().hex[:16])
+    state: TaskState = TaskState.SUBMITTED
+    messages: list[A2AMessage] = field(default_factory=list)
+    artifacts: list[Artifact] = field(default_factory=list)
+    created_at: str = field(default_factory=lambda: datetime.now().isoformat())
+    updated_at: str = field(default_factory=lambda: datetime.now().isoformat())
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "id": self.id, "state": self.state.value,
+            "messages": [m.to_dict() for m in self.messages],
+            "artifacts": [a.to_dict() for a in self.artifacts],
+            "metadata": self.metadata,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> A2ATask:
+        return cls(
+            id=data.get("id", uuid.uuid4().hex[:16]),
+            state=TaskState(data.get("state", "submitted")),
+            messages=[A2AMessage.from_dict(m) for m in data.get("messages", [])],
+            artifacts=[],
+            metadata=data.get("metadata", {}),
+        )
+
+
+@dataclass
+class AgentCard:
+    name: str = "echo-agent"
+    description: str = "A modular AI agent framework"
+    url: str = ""
+    version: str = "0.1.0"
+    capabilities: list[str] = field(default_factory=lambda: ["chat", "tool_use"])
+    skills: list[str] = field(default_factory=list)
+    authentication: dict[str, Any] = field(default_factory=lambda: {"schemes": ["bearer"]})
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "name": self.name, "description": self.description,
+            "url": self.url, "version": self.version,
+            "capabilities": {"streaming": True, "pushNotifications": False},
+            "skills": [{"id": s, "name": s} for s in self.skills],
+            "authentication": self.authentication,
+        }

echo_agent/a2a/protocol.py

@@ -0,0 +1,85 @@
+"""A2A JSON-RPC protocol handler."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Callable, Awaitable
+
+from loguru import logger
+
+from echo_agent.a2a.models import A2ATask, A2AMessage, TaskState
+
+# JSON-RPC 2.0 标准错误码
+_JSONRPC_PARSE_ERROR = -32700
+_JSONRPC_METHOD_NOT_FOUND = -32601
+_JSONRPC_INTERNAL_ERROR = -32603
+
+
+class A2AProtocol:
+    """Handles A2A JSON-RPC methods: tasks/send, tasks/get, tasks/cancel."""
+
+    def __init__(self, process_fn: Callable[[A2ATask], Awaitable[A2ATask]]):
+        self._process = process_fn
+        self._tasks: dict[str, A2ATask] = {}
+
+    async def handle(self, request: dict[str, Any]) -> dict[str, Any]:
+        """分发 JSON-RPC 请求到对应的处理方法。
+
+        支持的方法: tasks/send（发送任务）, tasks/get（查询任务）, tasks/cancel（取消任务）。
+        """
+        method = request.get("method", "")
+        params = request.get("params", {})
+        req_id = request.get("id")
+
+        try:
+            if method == "tasks/send":
+                result = await self._handle_send(params)
+            elif method == "tasks/get":
+                result = self._handle_get(params)
+            elif method == "tasks/cancel":
+                result = self._handle_cancel(params)
+            else:
+                return self._error(req_id, _JSONRPC_METHOD_NOT_FOUND, f"Method not found: {method}")
+            return {"jsonrpc": "2.0", "id": req_id, "result": result}
+        except Exception as e:
+            logger.error("A2A protocol error: {}", e)
+            return self._error(req_id, _JSONRPC_INTERNAL_ERROR, str(e))
+
+    async def _handle_send(self, params: dict[str, Any]) -> dict[str, Any]:
+        """处理任务发送请求。如果任务 ID 已存在则追加消息，否则创建新任务。"""
+        task_id = params.get("id", "")
+        message = params.get("message", {})
+
+        if task_id and task_id in self._tasks:
+            task = self._tasks[task_id]
+            task.messages.append(A2AMessage.from_dict(message))
+        else:
+            task = A2ATask()
+            if task_id:
+                task.id = task_id
+            task.messages.append(A2AMessage.from_dict(message))
+            self._tasks[task.id] = task
+
+        task.state = TaskState.WORKING
+        task = await self._process(task)
+        self._tasks[task.id] = task
+        return task.to_dict()
+
+    def _handle_get(self, params: dict[str, Any]) -> dict[str, Any]:
+        task_id = params.get("id", "")
+        task = self._tasks.get(task_id)
+        if not task:
+            raise ValueError(f"Task not found: {task_id}")
+        return task.to_dict()
+
+    def _handle_cancel(self, params: dict[str, Any]) -> dict[str, Any]:
+        task_id = params.get("id", "")
+        task = self._tasks.get(task_id)
+        if not task:
+            raise ValueError(f"Task not found: {task_id}")
+        task.state = TaskState.CANCELED
+        return task.to_dict()
+
+    @staticmethod
+    def _error(req_id: Any, code: int, message: str) -> dict[str, Any]:
+        return {"jsonrpc": "2.0", "id": req_id, "error": {"code": code, "message": message}}

echo_agent/a2a/server.py

@@ -0,0 +1,71 @@
+"""A2A HTTP server — agent card, task handling, SSE streaming."""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING
+
+from aiohttp import web
+from loguru import logger
+
+from echo_agent.a2a.models import AgentCard, A2ATask, A2AMessage, TaskState
+from echo_agent.a2a.protocol import A2AProtocol
+
+if TYPE_CHECKING:
+    from echo_agent.agent.loop import AgentLoop
+
+
+class A2AServer:
+    def __init__(self, agent_loop: AgentLoop, agent_card: AgentCard):
+        self._loop = agent_loop
+        self._card = agent_card
+        self._protocol = A2AProtocol(self._process_task)
+
+    def register_routes(self, app: web.Application) -> None:
+        app.router.add_get("/.well-known/agent.json", self._handle_agent_card)
+        app.router.add_post("/a2a", self._handle_rpc)
+        logger.info("A2A routes registered: /.well-known/agent.json, /a2a")
+
+    async def _handle_agent_card(self, request: web.Request) -> web.Response:
+        return web.json_response(self._card.to_dict())
+
+    async def _handle_rpc(self, request: web.Request) -> web.Response:
+        try:
+            body = await request.json()
+        except json.JSONDecodeError:
+            return web.json_response(
+                {"jsonrpc": "2.0", "id": None, "error": {"code": -32700, "message": "Parse error"}},
+                status=400,
+            )
+        result = await self._protocol.handle(body)
+        return web.json_response(result)
+
+    async def _process_task(self, task: A2ATask) -> A2ATask:
+        """Process an A2A task by routing through the agent loop."""
+        user_text = ""
+        for msg in task.messages:
+            if msg.role == "user":
+                user_text = msg.text_content
+                break
+
+        if not user_text:
+            task.state = TaskState.FAILED
+            task.messages.append(A2AMessage.text("agent", "No user message found"))
+            return task
+
+        try:
+            from echo_agent.bus.events import InboundEvent
+            event = InboundEvent.text_message(
+                channel="a2a", sender_id="a2a-client",
+                chat_id=f"a2a:{task.id}", text=user_text,
+            )
+            import uuid
+            result = await self._loop._process_event(event, trace_id=uuid.uuid4().hex[:12])
+            task.state = TaskState.COMPLETED
+            task.messages.append(A2AMessage.text("agent", result.response_text or ""))
+        except Exception as e:
+            logger.error("A2A task processing failed: {}", e)
+            task.state = TaskState.FAILED
+            task.messages.append(A2AMessage.text("agent", f"Error: {e}"))
+
+        return task

echo_agent/agent/approval_gate.py

@@ -0,0 +1,326 @@
+"""Approval and security gate for tool calls."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from loguru import logger
+
+from echo_agent.agent.tools.base import ToolResult
+from echo_agent.bus.events import InboundEvent, OutboundEvent
+from echo_agent.bus.queue import MessageBus
+from echo_agent.config.schema import Config
+from echo_agent.models.inference import InferenceController
+from echo_agent.permissions.allowlist import ApprovalAllowlist, ApprovalLevel, build_pattern_key
+from echo_agent.permissions.manager import ApprovalManager, ApprovalStatus
+from echo_agent.security.guards import GuardDecision, evaluate_tool_call
+from echo_agent.security.risk_classifier import RiskLevel, classify_risk
+
+
+@dataclass
+class ApprovalCheck:
+    denial: ToolResult | None = None
+    approved_actions: frozenset[str] = frozenset()
+
+
+class ApprovalGate:
+    """Combines risk classification, channel trust, smart approval, and manual approval."""
+
+    def __init__(
+        self,
+        *,
+        config: Config,
+        approval: ApprovalManager,
+        inference: InferenceController,
+        bus: MessageBus,
+        provider: Any = None,
+        allowlist: ApprovalAllowlist | None = None,
+    ):
+        self._config = config
+        self._approval = approval
+        self._inference = inference
+        self._bus = bus
+        self._provider = provider
+        self._allowlist = allowlist or ApprovalAllowlist()
+
+    async def check(
+        self,
+        tool_name: str,
+        arguments: dict[str, Any],
+        sender_id: str,
+        *,
+        channel: str = "",
+        event: InboundEvent | None = None,
+        running: bool = True,
+    ) -> ApprovalCheck:
+        approval_cfg = self._config.permissions.approval
+
+        # Step 1: Static guard (hard block dangerous patterns)
+        guard = evaluate_tool_call(self._config, tool_name, arguments)
+        if guard.denied:
+            return ApprovalCheck(ToolResult(
+                success=False,
+                error=f"Tool '{tool_name}' blocked by security policy: {guard.reason}",
+                metadata={"guard_pattern": guard.pattern_key},
+            ))
+
+        # Step 2: Elevated rights check
+        if self._requires_elevated(tool_name) and not self._elevated_allowed(channel, sender_id):
+            return ApprovalCheck(ToolResult(
+                success=False,
+                error=(
+                    f"Tool '{tool_name}' requires elevated execution rights for the configured "
+                    "executor/security policy."
+                ),
+                metadata={"requires_elevated": True},
+            ))
+
+        # Step 3: Risk classification
+        risk = classify_risk(tool_name, arguments)
+
+        # Approved-pass: any path that lets the call through must tell the tool
+        # which actions were approved. The tool's own guard (e.g. CodeExecTool)
+        # re-checks exec/code policy and blocks unless ctx.approved_actions
+        # contains the action — so returning an empty ApprovalCheck() here would
+        # silently fail EXEC tools even though the gate "approved" them.
+        def _approved() -> ApprovalCheck:
+            return ApprovalCheck(approved_actions=self._approved_actions(tool_name, guard))
+
+        # Step 4: READ_ONLY and WRITE always pass — they are protected by sandbox/path restrictions
+        if risk in (RiskLevel.READ_ONLY, RiskLevel.WRITE):
+            return _approved()
+
+        # Step 5: Explicit auto_approve list
+        if tool_name in approval_cfg.auto_approve:
+            return _approved()
+
+        # Step 6: CLI auto-approve (all levels)
+        if self._should_auto_approve_cli(channel):
+            return _approved()
+
+        # Step 7: Channel trust — EXEC level auto-approved on trusted channels
+        if risk == RiskLevel.EXEC and self._is_trusted_channel(channel):
+            return _approved()
+
+        # Step 8: Approval mode "off" — bypass everything except hard blocks
+        if approval_cfg.mode == "off":
+            return _approved()
+
+        # Step 9: Check if this tool actually requires approval
+        if not self._approval_required(tool_name, guard, risk):
+            return _approved()
+
+        # Step 10: Allowlist check (EXEC level)
+        session_key = event.session_key if event else ""
+        pattern_key = build_pattern_key(tool_name, arguments)
+        if risk == RiskLevel.EXEC and self._allowlist.is_approved(session_key, pattern_key):
+            return _approved()
+
+        # Step 11: Unattended mode check
+        if self._is_unattended(event, channel):
+            return self._resolve_unattended(tool_name, risk, session_key, pattern_key, guard)
+
+        # Step 12: Smart approval (EXEC level only)
+        if risk == RiskLevel.EXEC and approval_cfg.mode == "smart" and self._provider:
+            verdict = await self._run_smart_approval(tool_name, arguments, guard)
+            if verdict == "approve":
+                self._allowlist.approve(session_key, pattern_key, ApprovalLevel.SESSION)
+                return _approved()
+            if verdict == "deny":
+                return ApprovalCheck(ToolResult(
+                    success=False,
+                    error=f"Smart approval denied '{tool_name}': {guard.reason or 'assessed as dangerous'}",
+                ))
+
+        # Step 13: Manual approval flow
+        approved_actions = self._approved_actions(tool_name, guard)
+        return await self._manual_approval_flow(
+            tool_name, arguments, sender_id, channel, event, running,
+            guard, approved_actions, session_key, pattern_key,
+        )
+
+    # PLACEHOLDER_METHODS
+
+    async def _run_smart_approval(
+        self, tool_name: str, arguments: dict[str, Any], guard: GuardDecision,
+    ) -> str:
+        from echo_agent.security.smart_approval import smart_approve
+        command = str(arguments.get("command", "") or arguments.get("code", "") or arguments)
+        description = guard.reason or f"tool '{tool_name}' requires approval"
+        model = self._config.permissions.approval.smart_model
+        return await smart_approve(tool_name, command, description, self._provider, model=model)
+
+    async def _manual_approval_flow(
+        self,
+        tool_name: str,
+        arguments: dict[str, Any],
+        sender_id: str,
+        channel: str,
+        event: InboundEvent | None,
+        running: bool,
+        guard: GuardDecision,
+        approved_actions: frozenset[str],
+        session_key: str,
+        pattern_key: str,
+    ) -> ApprovalCheck:
+        approval_req = self._approval.request_approval(
+            tool_name, tool_name=tool_name, params=arguments, user_id=sender_id,
+        )
+        if approval_req.status == ApprovalStatus.DENIED:
+            return ApprovalCheck(ToolResult(
+                success=False,
+                error=f"Tool '{tool_name}' denied by approval policy: {approval_req.reason}",
+            ))
+        if approval_req.status == ApprovalStatus.APPROVED:
+            return ApprovalCheck(approved_actions=approved_actions)
+
+        if event is not None:
+            await self._publish_approval_request(event, approval_req.id, tool_name, guard, pattern_key)
+
+        if not running and channel in {"cli", "direct", ""}:
+            return ApprovalCheck(ToolResult(
+                success=False,
+                error=(
+                    f"Approval required before executing '{tool_name}'. "
+                    f"Request id: {approval_req.id}."
+                ),
+                metadata={"approval_request_id": approval_req.id},
+            ))
+
+        decided = await self._approval.wait_for_decision(
+            approval_req.id,
+            timeout_seconds=self._config.permissions.approval.wait_timeout_seconds,
+        )
+        if decided and decided.status == ApprovalStatus.APPROVED:
+            level = self._parse_approval_level(decided.reason)
+            self._allowlist.approve(session_key, pattern_key, level)
+            return ApprovalCheck(approved_actions=approved_actions)
+        if decided and decided.status == ApprovalStatus.DENIED:
+            return ApprovalCheck(ToolResult(
+                success=False,
+                error=f"Tool '{tool_name}' denied: {decided.reason}",
+                metadata={"approval_request_id": approval_req.id},
+            ))
+        return ApprovalCheck(ToolResult(
+            success=False,
+            error=(
+                f"Approval timed out for '{tool_name}'. "
+                f"Request id: {approval_req.id}. "
+                f"Reply `/approve {approval_req.id}` or `/deny {approval_req.id} <reason>`."
+            ),
+            metadata={"approval_request_id": approval_req.id},
+        ))
+
+    # PLACEHOLDER_HELPERS
+
+    async def _publish_approval_request(
+        self,
+        event: InboundEvent,
+        request_id: str,
+        tool_name: str,
+        guard: GuardDecision,
+        pattern_key: str,
+    ) -> None:
+        reason = guard.reason or "approval policy requires confirmation"
+        text = (
+            f"⚠️ 需要确认执行: {tool_name}\n"
+            f"原因: {reason}\n\n"
+            f"回复:\n"
+            f"  /approve {request_id} — 允许本次\n"
+            f"  /approve {request_id} session — 本会话内允许同类操作\n"
+            f"  /approve {request_id} always — 永久允许同类操作\n"
+            f"  /deny {request_id} [原因] — 拒绝"
+        )
+        out = OutboundEvent.text_reply(
+            channel=event.channel,
+            chat_id=event.chat_id,
+            text=text,
+            reply_to_id=event.reply_to_id,
+        )
+        out.metadata = dict(event.metadata)
+        out.metadata["_approval_request"] = True
+        out.metadata["_inbound_event_id"] = event.event_id
+        await self._bus.publish_outbound(out)
+
+    def _approval_required(self, tool_name: str, guard: GuardDecision, risk: RiskLevel) -> bool:
+        approval_cfg = self._config.permissions.approval
+        if tool_name in approval_cfg.auto_deny:
+            return True
+        if guard.needs_approval:
+            return True
+        if self._inference.needs_confirmation(tool_name):
+            return True
+        if tool_name in approval_cfg.require_approval:
+            return True
+        if risk == RiskLevel.DANGEROUS:
+            return True
+        return False
+
+    def _should_auto_approve_cli(self, channel: str) -> bool:
+        approval_cfg = self._config.permissions.approval
+        return (
+            self._config.security.profile == "personal_cli"
+            and approval_cfg.cli_auto_approve
+            and channel in {"cli", "direct", ""}
+        )
+
+    def _is_trusted_channel(self, channel: str) -> bool:
+        return channel in self._config.permissions.approval.trusted_channels
+
+    def _is_unattended(self, event: InboundEvent | None, channel: str) -> bool:
+        if event and event.metadata.get("_unattended"):
+            return True
+        return channel in {"cron", "scheduler"}
+
+    def _resolve_unattended(
+        self, tool_name: str, risk: RiskLevel, session_key: str, pattern_key: str, guard: GuardDecision,
+    ) -> ApprovalCheck:
+        policy = self._config.permissions.approval.unattended_policy
+        approved = self._approved_actions(tool_name, guard)
+        if policy == "allow_safe":
+            if risk == RiskLevel.WRITE:
+                return ApprovalCheck(approved_actions=approved)
+            if risk == RiskLevel.EXEC and self._allowlist.is_approved(session_key, pattern_key):
+                return ApprovalCheck(approved_actions=approved)
+        return ApprovalCheck(ToolResult(
+            success=False,
+            error=f"Tool '{tool_name}' requires approval but no user is available (unattended mode).",
+        ))
+
+    @staticmethod
+    def _approved_actions(tool_name: str, guard: GuardDecision) -> frozenset[str]:
+        actions = {tool_name}
+        if guard.pattern_key:
+            actions.add(guard.pattern_key)
+        if guard.approval_action:
+            actions.add(guard.approval_action)
+        return frozenset(actions)
+
+    @staticmethod
+    def _parse_approval_level(reason: str) -> ApprovalLevel:
+        if reason:
+            lower = reason.strip().lower()
+            if lower == "always":
+                return ApprovalLevel.ALWAYS
+            if lower == "session":
+                return ApprovalLevel.SESSION
+        return ApprovalLevel.ONCE
+
+    def _requires_elevated(self, tool_name: str) -> bool:
+        if tool_name not in {"exec", "execute_code", "process"}:
+            return False
+        host = self._config.tools.exec.host
+        if host == "auto":
+            host = self._config.execution.default_executor
+        return host in {"local", "remote"} or self._config.tools.exec.security == "full"
+
+    def _elevated_allowed(self, channel: str, sender_id: str) -> bool:
+        elevated = self._config.permissions.elevated
+        if not elevated.enabled:
+            return False
+        allow_from = elevated.allow_from or {}
+        candidates = set(allow_from.get("*", [])) | set(allow_from.get(channel, []))
+        if "*" in candidates or sender_id in candidates:
+            return True
+        return sender_id in (self._config.permissions.admin_users or [])

echo_agent/agent/compression/__init__.py

@@ -0,0 +1,14 @@
+"""Context compression engine — multi-phase intelligent context management."""
+
+from __future__ import annotations
+
+from echo_agent.agent.compression.compressor import ConversationCompressor
+from echo_agent.agent.compression.engine import ContextEngine
+from echo_agent.agent.compression.types import CompressionResult, CompressionStats
+
+__all__ = [
+    "ContextEngine",
+    "ConversationCompressor",
+    "CompressionResult",
+    "CompressionStats",
+]