echo-agent 0.2.2__tar.gz → 0.2.3__tar.gz

{echo_agent-0.2.2 → echo_agent-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: echo-agent
-Version: 0.2.2
+Version: 0.2.3
 Summary: A modular AI agent framework with multi-channel support
 Author: Echo Agent contributors
 License: MIT

{echo_agent-0.2.2 → echo_agent-0.2.3}/echo_agent/__init__.py

@@ -2,4 +2,4 @@
 
 from __future__ import annotations
 
-__version__ = "0.1.0"
+__version__ = "0.2.3"

{echo_agent-0.2.2 → echo_agent-0.2.3}/echo_agent/agent/loop.py

@@ -259,6 +259,7 @@ class AgentLoop:
             memory_snapshots=self._memory_snapshots,
             snapshot_enabled=self._snapshot_enabled,
             tool_definitions_fn=self.tools.get_definitions,
+            bus=bus,
         )
         self._inference_stage = InferenceStage(
             config=config,
@@ -730,9 +731,13 @@ class AgentLoop:
             return template
 
     def _should_stream_channel(self, channel: str) -> bool:
-        if channel.startswith("gateway:"):
-            return False
-        return channel in set(self.config.channels.stream_channels)
+        channels = set(self.config.channels.stream_channels)
+        if channel in channels:
+            return True
+        for pattern in channels:
+            if pattern.endswith(":*") and channel.startswith(pattern[:-1]):
+                return True
+        return False
 
     async def process_direct(self, content: str, session_key: str = "cli:direct") -> str:
         """Process a message directly (for CLI or testing)."""

{echo_agent-0.2.2 → echo_agent-0.2.3}/echo_agent/agent/pipeline/context_stage.py

@@ -15,7 +15,7 @@ from echo_agent.agent.context import (
     build_skills_context,
 )
 from echo_agent.agent.pipeline.types import PipelineContext
-from echo_agent.bus.events import InboundEvent
+from echo_agent.bus.events import InboundEvent, OutboundEvent
 from echo_agent.session.manager import Session
 
 if TYPE_CHECKING:
@@ -56,6 +56,7 @@ class ContextStage:
         memory_snapshots: OrderedDict,
         snapshot_enabled: bool,
         tool_definitions_fn: Any,
+        bus: Any = None,
     ):
         self._config = config
         self._sessions = sessions
@@ -71,6 +72,19 @@ class ContextStage:
         self._memory_snapshots = memory_snapshots
         self._snapshot_enabled = snapshot_enabled
         self._tool_definitions_fn = tool_definitions_fn
+        self._bus = bus
+
+    async def _emit_progress(self, event: InboundEvent, metadata: dict[str, Any]) -> None:
+        if not getattr(self._config.gateway, 'emit_progress_events', True):
+            return
+        out = OutboundEvent.text_reply(
+            channel=event.channel, chat_id=event.chat_id, text="", reply_to_id=event.reply_to_id,
+        )
+        out.is_final = False
+        out.message_kind = "progress"
+        out.metadata = {"_progress": True, "_inbound_event_id": event.event_id}
+        out.metadata.update(metadata)
+        await self._bus.publish_outbound(out)
 
     async def build(
         self,
@@ -155,6 +169,18 @@ class ContextStage:
                     "Relevant memory:\n"
                     + "\n".join(f"- {r.key}: {r.content}" for r, _ in scored)
                 )
+                if publish_response and self._bus:
+                    _debug = getattr(self._config.gateway, 'progress_debug', False)
+                    _mem_meta: dict[str, Any] = {
+                        "progress_type": "memory_retrieved",
+                        "count": len(scored),
+                    }
+                    if _debug:
+                        _mem_meta["entries"] = [
+                            {"key": r.key, "content_preview": r.content[:100]}
+                            for r, _ in scored[:5]
+                        ]
+                    await self._emit_progress(event, _mem_meta)
 
         if self._knowledge:
             knowledge_results = self._knowledge.search(
@@ -165,6 +191,18 @@ class ContextStage:
             knowledge_context = self._knowledge.format_results(knowledge_results)
             if knowledge_context:
                 retrieval_parts.append(knowledge_context)
+                if publish_response and self._bus:
+                    _debug = getattr(self._config.gateway, 'progress_debug', False)
+                    _know_meta: dict[str, Any] = {
+                        "progress_type": "knowledge_cited",
+                        "count": len(knowledge_results) if knowledge_results else 0,
+                    }
+                    if _debug:
+                        _know_meta["citations"] = [
+                            {"path": getattr(r, 'path', ''), "chunk_preview": getattr(r, 'text', '')[:200], "score": getattr(r, 'score', 0.0)}
+                            for r in (knowledge_results[:5] if knowledge_results else [])
+                        ]
+                    await self._emit_progress(event, _know_meta)
 
         task_type = self._infer_task_type(event.text)
 

{echo_agent-0.2.2 → echo_agent-0.2.3}/echo_agent/agent/pipeline/inference_stage.py

@@ -92,6 +92,20 @@ class InferenceStage:
             out.metadata.update({"_progress": True, "_tool_hint": tool_hint, "_inbound_event_id": event.event_id})
             await self._bus.publish_outbound(out)
 
+        async def _emit_tool_event(metadata: dict[str, Any]) -> None:
+            if not ctx.publish_response:
+                return
+            if not getattr(self._config.gateway, 'emit_progress_events', True):
+                return
+            out = OutboundEvent.text_reply(
+                channel=event.channel, chat_id=event.chat_id, text="", reply_to_id=event.reply_to_id,
+            )
+            out.is_final = False
+            out.message_kind = "progress"
+            out.metadata = {"_progress": True, "_inbound_event_id": event.event_id}
+            out.metadata.update(metadata)
+            await self._bus.publish_outbound(out)
+
         # Standard inference loop
         response_text = ""
         should_review_skills = False
@@ -272,6 +286,19 @@ class InferenceStage:
                         if _hook_cancelled:
                             continue
 
+                    import time as _time
+                    _tool_start_ts = _time.monotonic()
+
+                    _debug_progress = getattr(self._config.gateway, 'progress_debug', False)
+                    _tool_start_meta: dict[str, Any] = {
+                        "progress_type": "tool_call",
+                        "tool": tool_call.name,
+                        "status": "started",
+                    }
+                    if _debug_progress:
+                        _tool_start_meta["args"] = str(tool_call.arguments)[:500]
+                    await _emit_tool_event(_tool_start_meta)
+
                     result = await self._tools.execute(tool_call.name, tool_call.arguments, tool_exec_ctx)
 
                     # post_tool_call hook
@@ -280,6 +307,17 @@ class InferenceStage:
                             "post_tool_call", result, tool_call.name, tool_call.arguments, tool_exec_ctx,
                         )
 
+                    _tool_duration_ms = int((_time.monotonic() - _tool_start_ts) * 1000)
+                    _tool_result_meta: dict[str, Any] = {
+                        "progress_type": "tool_result",
+                        "tool": tool_call.name,
+                        "duration_ms": _tool_duration_ms,
+                        "status": "done" if result.success else "error",
+                    }
+                    if _debug_progress:
+                        _tool_result_meta["result_preview"] = result.text[:500]
+                    await _emit_tool_event(_tool_result_meta)
+
                     result_text = result.text
                     if len(result_text) > self._MAX_TOOL_RESULT_CHARS:
                         result_text = result_text[:self._MAX_TOOL_RESULT_CHARS] + "\n...(truncated)"

{echo_agent-0.2.2 → echo_agent-0.2.3}/echo_agent/app.py

@@ -230,10 +230,11 @@ class AppRuntime:
     the storage close — from running.
     """
 
-    def __init__(self, ctx: BootstrapResult):
+    def __init__(self, ctx: BootstrapResult, shutdown_event: asyncio.Event | None = None):
         self._ctx = ctx
         self._gateway: Any = None
         self._started = False
+        self._shutdown_event = shutdown_event
 
     @property
     def gateway(self) -> Any:
@@ -271,6 +272,8 @@ class AppRuntime:
                 agent_loop=ctx.agent,
                 a2a_config=ctx.config.a2a,
             )
+            if self._shutdown_event:
+                self._gateway.set_shutdown_event(self._shutdown_event)
             await self._gateway.start()
             logger.info("Gateway started on {}:{}", ctx.config.gateway.host, ctx.config.gateway.port)
         return True
@@ -313,7 +316,7 @@ async def run(config_path: str | None = None, workspace: str | None = None) -> N
     logger.info("Echo Agent starting — workspace: {}", ctx.workspace)
 
     install_signal_handler(shutdown)
-    runtime = AppRuntime(ctx)
+    runtime = AppRuntime(ctx, shutdown_event=shutdown)
     try:
         if not await runtime.start():
             return
@@ -347,7 +350,7 @@ async def run_gateway(
         ctx.config.gateway.port = port
 
     install_signal_handler(shutdown)
-    runtime = AppRuntime(ctx)
+    runtime = AppRuntime(ctx, shutdown_event=shutdown)
     try:
         if not await runtime.start():
             return

{echo_agent-0.2.2 → echo_agent-0.2.3}/echo_agent/config/schema.py

@@ -159,7 +159,7 @@ class ChannelsConfig(_Base):
     matrix: MatrixChannelConfig = Field(default_factory=MatrixChannelConfig)
     send_progress: bool = True
     send_tool_hints: bool = True
-    stream_channels: list[str] = Field(default_factory=lambda: ["cli", "telegram", "discord", "slack"])
+    stream_channels: list[str] = Field(default_factory=lambda: ["cli", "telegram", "discord", "slack", "gateway:*"])
     stream_flush_chars: int = 180
     stream_flush_interval_ms: int = 1500
     stream_paragraph_mode: bool = True
@@ -528,6 +528,8 @@ class GatewayConfig(_Base):
     media_cache_max_mb: int = 500
     max_agent_cache_size: int = 50
     enable_progressive_edit: bool = True
+    emit_progress_events: bool = True
+    progress_debug: bool = False
     hooks_dir: str = ""
 
 

{echo_agent-0.2.2 → echo_agent-0.2.3}/echo_agent/gateway/api/__init__.py

@@ -20,12 +20,14 @@ def register_management_routes(app: web.Application, prefix: str, server: Gatewa
     from echo_agent.gateway.api.channels import ChannelsAPI
     from echo_agent.gateway.api.knowledge import KnowledgeAPI
     from echo_agent.gateway.api.config import ConfigAPI
+    from echo_agent.gateway.api.lifecycle import LifecycleAPI
 
     memory_api = MemoryAPI(server)
     skills_api = SkillsAPI(server)
     channels_api = ChannelsAPI(server)
     knowledge_api = KnowledgeAPI(server)
     config_api = ConfigAPI(server)
+    lifecycle_api = LifecycleAPI(server)
 
     app.router.add_get(f"{prefix}/memory", memory_api.list_entries)
     app.router.add_get(f"{prefix}/memory/stats", memory_api.stats)
@@ -48,3 +50,5 @@ def register_management_routes(app: web.Application, prefix: str, server: Gatewa
 
     app.router.add_get(f"{prefix}/config", config_api.get_config)
     app.router.add_get(f"{prefix}/config/models", config_api.get_models)
+
+    app.router.add_post(f"{prefix}/shutdown", lifecycle_api.shutdown)

echo_agent-0.2.3/echo_agent/gateway/api/lifecycle.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from aiohttp import web
+
+if TYPE_CHECKING:
+    from echo_agent.gateway.server import GatewayServer
+
+
+class LifecycleAPI:
+    def __init__(self, server: GatewayServer):
+        self._server = server
+
+    def _guard(self, request: web.Request, action: str) -> web.Response | None:
+        return self._server._require_api_token(request, action=action)
+
+    async def shutdown(self, request: web.Request) -> web.Response:
+        guard = self._guard(request, "shutdown")
+        if guard:
+            return guard
+
+        if not self._server._shutdown_event:
+            return web.json_response({
+                "error": "shutdown not available",
+                "message": "Gateway was not started with lifecycle management support",
+            }, status=503)
+
+        self._server.request_shutdown()
+
+        return web.json_response({
+            "status": "shutting_down",
+            "drain_timeout_seconds": 10,
+            "message": "Agent will shut down after draining in-flight requests (max 10s)",
+        }, status=202)
+
+    async def health(self, request: web.Request) -> web.Response:
+        """Extended health endpoint for lifecycle management."""
+        data = await self._server.health.check()
+        status_code = 200 if data["status"] != "unhealthy" else 503
+        return web.json_response(data, status=status_code)

{echo_agent-0.2.2 → echo_agent-0.2.3}/echo_agent/gateway/health.py

@@ -39,10 +39,18 @@ class GatewayHealthProvider:
         if is_running and not channel_status:
             status = "degraded"
 
+        provider_status = "ok"
+        if self._gw._agent_loop:
+            provider = getattr(self._gw._agent_loop, 'provider', None)
+            if provider and getattr(provider, 'is_stub', False) is True:
+                status = "degraded"
+                provider_status = "stub"
+
         return {
             "status": status,
             "server_running": is_running,
             "active_channels": channel_status,
+            "provider": provider_status,
             "rate_limiter": rate_stats,
             "media_cache_mb": round(media_size, 1),
             "active_sessions": session_count,

{echo_agent-0.2.2 → echo_agent-0.2.3}/echo_agent/gateway/server.py

@@ -70,6 +70,8 @@ class GatewayServer:
         self._pending_http: dict[str, asyncio.Future[dict[str, Any]]] = {}
         self._MAX_PENDING_HTTP = 500
         self._running = False
+        self._actual_port: int | None = None
+        self._shutdown_event: asyncio.Event | None = None
 
         data_dir = workspace / "data"
         self.auth = GatewayAuth(config.auth, data_dir)
@@ -98,6 +100,20 @@ class GatewayServer:
     def is_running(self) -> bool:
         return self._running
 
+    @property
+    def actual_port(self) -> int:
+        """Return the actual bound port (useful when configured port is 0)."""
+        if self._actual_port is not None:
+            return self._actual_port
+        return self._config.port
+
+    def set_shutdown_event(self, event: asyncio.Event) -> None:
+        self._shutdown_event = event
+
+    def request_shutdown(self) -> None:
+        if self._shutdown_event:
+            self._shutdown_event.set()
+
     # ── Lifecycle ────────────────────────────────────────────────────────────
 
     async def start(self) -> None:
@@ -113,12 +129,25 @@ class GatewayServer:
             self._config.port,
         )
         await self._site.start()
+
+        actual_port = self._config.port
+        if self._runner.addresses:
+            actual_port = self._runner.addresses[0][1]
+        self._actual_port = actual_port
+
         self._running = True
 
+        import sys
+        print(
+            f"ECHO_AGENT_READY port={actual_port} ws={self._config.ws_path} health={self._config.api_prefix}/health",
+            flush=True,
+            file=sys.stdout,
+        )
+
         await self.hooks.emit("gateway_start")
         logger.info(
             "Gateway listening on {}:{}",
-            self._config.host, self._config.port,
+            self._config.host, actual_port,
         )
 
     def _check_bind_safety(self) -> None:

{echo_agent-0.2.2 → echo_agent-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "echo-agent"
-version = "0.2.2"
+version = "0.2.3"
 description = "A modular AI agent framework with multi-channel support"
 readme = "README.md"
 requires-python = ">=3.11"