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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: echo-agent
-Version: 0.2.1
+Version: 0.2.3
 Summary: A modular AI agent framework with multi-channel support
 Author: Echo Agent contributors
 License: MIT
@@ -25,6 +25,7 @@ Requires-Dist: anthropic>=0.40; extra == 'all'
 Requires-Dist: boto3>=1.34; extra == 'all'
 Requires-Dist: cryptography>=41.0; extra == 'all'
 Requires-Dist: faiss-cpu>=1.7; extra == 'all'
+Requires-Dist: fal-client>=0.5; extra == 'all'
 Requires-Dist: google-generativeai>=0.8; extra == 'all'
 Requires-Dist: openai>=1.30; extra == 'all'
 Requires-Dist: psutil>=5.9; extra == 'all'
@@ -45,6 +46,8 @@ Provides-Extra: dev
 Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
 Requires-Dist: pytest>=8.0; extra == 'dev'
 Requires-Dist: ruff>=0.4; extra == 'dev'
+Provides-Extra: fal
+Requires-Dist: fal-client>=0.5; extra == 'fal'
 Provides-Extra: gemini
 Requires-Dist: google-generativeai>=0.8; extra == 'gemini'
 Provides-Extra: openai

{echo_agent-0.2.1 → 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.1 → 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.1 → 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.1 → 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.1 → echo_agent-0.2.3}/echo_agent/agent/tools/__init__.py

@@ -189,30 +189,42 @@ def _infer_tts_model(api_base: str) -> str:
 
 def _try_register_image_gen(tools: list[Tool], config: Config, provider: LLMProvider | None = None) -> None:
     ig = getattr(config.tools, "image_gen", None)
-    explicit_key = getattr(ig, "api_key", "") if ig else ""
+    backend = getattr(ig, "backend", "openai") if ig else "openai"
+
+    if backend == "fal":
+        fal_key = getattr(ig, "fal_key", "") if ig else ""
+        fal_model = getattr(ig, "fal_model", "") if ig else ""
+        if not fal_key:
+            logger.info(
+                "image_generate tool not registered: no fal_key configured. "
+                "Set tools.image_gen.fal_key and tools.image_gen.fal_model in config to enable."
+            )
+            return
+        from echo_agent.agent.tools.image_gen_fal import FalImageGenTool, FAL_MODELS
+        if fal_model and fal_model not in FAL_MODELS:
+            logger.warning(
+                "image_generate: configured fal_model '{}' is not in the built-in catalog. "
+                "Supported: {}. The tool will error at execution time.",
+                fal_model, ", ".join(sorted(FAL_MODELS.keys())),
+            )
+        tools.append(FalImageGenTool(fal_key=fal_key, model=fal_model))
+        return
+
+    api_key = getattr(ig, "api_key", "") if ig else ""
     api_base = getattr(ig, "api_base", "") if ig else ""
     model = getattr(ig, "model", "") if ig else ""
 
-    if explicit_key:
-        # User explicitly configured image_gen — use their settings as-is
-        api_key = explicit_key
-    elif _is_openai_compatible_provider(provider):
-        # Fallback only for OpenAI-compatible providers — use unwrapped to get real key/base
-        real = _unwrap_provider(provider)
-        api_key = getattr(real, "api_key", "")
-        if not api_base:
-            api_base = getattr(real, "api_base", "")
-        # Reset default model so we infer from api_base
-        model = ""
-    else:
-        return
-
     if not api_key:
+        if _is_openai_compatible_provider(provider):
+            logger.info(
+                "image_generate tool not registered: no explicit image_gen.api_key configured. "
+                "Set tools.image_gen.api_key, tools.image_gen.api_base, and tools.image_gen.model in config to enable."
+            )
         return
 
-    # Infer model from api_base if not explicitly set by user
-    if not model or (not explicit_key and model == "dall-e-3"):
+    if not model:
         model = _infer_image_model(api_base)
+        logger.debug("image_generate: model not configured, inferred '{}' from api_base", model)
 
     from echo_agent.agent.tools.image_gen import ImageGenTool
     tools.append(ImageGenTool(api_key=api_key, api_base=api_base, model=model))
@@ -222,18 +234,23 @@ def _try_register_tts(tools: list[Tool], config: Config, ws: str, provider: LLMP
     from echo_agent.agent.tools.tts import TTSTool
     tts_cfg = getattr(config.tools, "tts", None)
     openai_key = getattr(tts_cfg, "openai_api_key", "") if tts_cfg else ""
-    openai_base = ""
+    openai_base = getattr(tts_cfg, "openai_api_base", "") if tts_cfg else ""
+    tts_model = getattr(tts_cfg, "model", "") if tts_cfg else ""
     default_backend = getattr(tts_cfg, "default_backend", "edge") if tts_cfg else "edge"
     default_voice = getattr(tts_cfg, "default_voice", "") if tts_cfg else ""
 
-    # Fallback only for OpenAI-compatible providers
     if not openai_key and _is_openai_compatible_provider(provider):
-        real = _unwrap_provider(provider)
-        openai_key = getattr(real, "api_key", "")
-        openai_base = getattr(real, "api_base", "")
-
-    # Infer TTS model from api_base
-    tts_model = _infer_tts_model(openai_base)
+        logger.info(
+            "TTS openai backend not available: no explicit tts.openai_api_key configured. "
+            "Set tools.tts.openai_api_key, tools.tts.openai_api_base, and tools.tts.model in config to enable. "
+            "edge backend remains available without configuration."
+        )
+
+    if not tts_model and openai_key:
+        tts_model = _infer_tts_model(openai_base)
+        logger.debug("TTS: model not configured, inferred '{}' from openai_api_base", tts_model)
+    if not tts_model:
+        tts_model = "tts-1"
 
     tools.append(TTSTool(
         workspace=ws,

echo_agent-0.2.3/echo_agent/agent/tools/image_gen_fal.py

@@ -0,0 +1,231 @@
+"""Image generation tool — FAL.ai backend."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import threading
+from typing import Any
+
+from echo_agent.agent.tools.base import Tool, ToolExecutionContext, ToolResult
+
+DEFAULT_MODEL = "fal-ai/flux/schnell"
+
+FAL_MODELS: dict[str, dict[str, Any]] = {
+    "fal-ai/flux/schnell": {
+        "display": "FLUX Schnell",
+        "size_style": "image_size_preset",
+        "sizes": {
+            "landscape": "landscape_16_9",
+            "square": "square_hd",
+            "portrait": "portrait_16_9",
+        },
+        "defaults": {
+            "num_images": 1,
+            "output_format": "png",
+            "enable_safety_checker": False,
+            "sync_mode": True,
+        },
+        "supports": {
+            "prompt", "image_size", "num_images", "output_format",
+            "enable_safety_checker", "sync_mode", "seed",
+        },
+    },
+    "fal-ai/flux-2-pro": {
+        "display": "FLUX 2 Pro",
+        "size_style": "image_size_preset",
+        "sizes": {
+            "landscape": "landscape_16_9",
+            "square": "square_hd",
+            "portrait": "portrait_16_9",
+        },
+        "defaults": {
+            "num_inference_steps": 50,
+            "guidance_scale": 4.5,
+            "num_images": 1,
+            "output_format": "png",
+            "enable_safety_checker": False,
+            "sync_mode": True,
+        },
+        "supports": {
+            "prompt", "image_size", "num_inference_steps", "guidance_scale",
+            "num_images", "output_format", "enable_safety_checker",
+            "sync_mode", "seed",
+        },
+    },
+    "fal-ai/ideogram/v3": {
+        "display": "Ideogram V3",
+        "size_style": "image_size_preset",
+        "sizes": {
+            "landscape": "landscape_16_9",
+            "square": "square_hd",
+            "portrait": "portrait_16_9",
+        },
+        "defaults": {
+            "rendering_speed": "BALANCED",
+            "expand_prompt": True,
+            "style": "AUTO",
+        },
+        "supports": {
+            "prompt", "image_size", "rendering_speed", "expand_prompt",
+            "style", "seed",
+        },
+    },
+    "fal-ai/recraft/v4/pro/text-to-image": {
+        "display": "Recraft V4 Pro",
+        "size_style": "image_size_preset",
+        "sizes": {
+            "landscape": "landscape_16_9",
+            "square": "square_hd",
+            "portrait": "portrait_16_9",
+        },
+        "defaults": {
+            "enable_safety_checker": False,
+        },
+        "supports": {
+            "prompt", "image_size", "enable_safety_checker",
+        },
+    },
+    "fal-ai/qwen-image": {
+        "display": "Qwen Image",
+        "size_style": "image_size_preset",
+        "sizes": {
+            "landscape": "landscape_16_9",
+            "square": "square_hd",
+            "portrait": "portrait_16_9",
+        },
+        "defaults": {
+            "num_inference_steps": 30,
+            "guidance_scale": 2.5,
+            "num_images": 1,
+            "output_format": "png",
+        },
+        "supports": {
+            "prompt", "image_size", "num_inference_steps", "guidance_scale",
+            "num_images", "output_format", "seed", "sync_mode",
+        },
+    },
+}
+
+VALID_ASPECT_RATIOS = ("landscape", "square", "portrait")
+
+
+def _load_fal_client():
+    try:
+        from echo_agent.dependencies import ensure
+        ensure("tool.image-gen-fal")
+    except Exception:
+        pass
+    import fal_client  # type: ignore
+    return fal_client
+
+
+_fal_env_lock = threading.Lock()
+
+
+def _build_payload(model_id: str, prompt: str, aspect_ratio: str) -> dict[str, Any]:
+    meta = FAL_MODELS[model_id]
+    size_style = meta["size_style"]
+    sizes = meta["sizes"]
+
+    aspect = aspect_ratio if aspect_ratio in sizes else "landscape"
+    payload: dict[str, Any] = dict(meta.get("defaults", {}))
+    payload["prompt"] = prompt.strip()
+
+    if size_style == "image_size_preset":
+        payload["image_size"] = sizes[aspect]
+    elif size_style == "aspect_ratio":
+        payload["aspect_ratio"] = sizes[aspect]
+
+    supports = meta["supports"]
+    return {k: v for k, v in payload.items() if k in supports}
+
+
+class FalImageGenTool(Tool):
+    name = "image_generate"
+    description = "Generate an image from a text prompt using FAL.ai (supports FLUX, Ideogram, Recraft, Qwen and more)."
+    parameters = {
+        "type": "object",
+        "properties": {
+            "prompt": {"type": "string", "description": "Text description of the image to generate."},
+            "aspect_ratio": {
+                "type": "string",
+                "enum": ["landscape", "square", "portrait"],
+                "description": "Image aspect ratio.",
+            },
+        },
+        "required": ["prompt"],
+    }
+    timeout_seconds = 120
+
+    def __init__(self, fal_key: str = "", model: str = ""):
+        self._fal_key = fal_key
+        self._model = model or DEFAULT_MODEL
+
+    def is_ready(self) -> bool:
+        return bool(self._fal_key)
+
+    def readiness_detail(self) -> tuple[bool, str]:
+        if self._fal_key:
+            return True, "ok"
+        return False, "FAL.ai API key not configured"
+
+    async def execute(self, params: dict[str, Any], ctx: ToolExecutionContext | None = None) -> ToolResult:
+        if not self._fal_key:
+            return ToolResult(success=False, error="FAL.ai API key not configured")
+
+        prompt = params.get("prompt", "").strip()
+        if not prompt:
+            return ToolResult(success=False, error="prompt is required")
+
+        aspect_ratio = params.get("aspect_ratio", "landscape").lower().strip()
+        if aspect_ratio not in VALID_ASPECT_RATIOS:
+            aspect_ratio = "landscape"
+
+        model_id = self._model
+        if model_id not in FAL_MODELS:
+            supported = ", ".join(sorted(FAL_MODELS.keys()))
+            return ToolResult(
+                success=False,
+                error=f"Unknown FAL model '{model_id}'. Supported models: {supported}",
+            )
+
+        arguments = _build_payload(model_id, prompt, aspect_ratio)
+
+        try:
+            fal = _load_fal_client()
+        except ImportError:
+            return ToolResult(
+                success=False,
+                error="fal-client package not installed. Run: pip install fal-client",
+            )
+
+        def _submit_with_key():
+            with _fal_env_lock:
+                prev_key = os.environ.get("FAL_KEY")
+                os.environ["FAL_KEY"] = self._fal_key
+                try:
+                    handler = fal.submit(model_id, arguments=arguments)
+                    return handler.get()
+                finally:
+                    if prev_key is not None:
+                        os.environ["FAL_KEY"] = prev_key
+                    else:
+                        os.environ.pop("FAL_KEY", None)
+
+        try:
+            result = await asyncio.to_thread(_submit_with_key)
+        except Exception as e:
+            return ToolResult(success=False, error=f"FAL.ai generation failed: {e}")
+
+        images = result.get("images") if isinstance(result, dict) else None
+        if not images:
+            return ToolResult(success=False, error="No images returned from FAL.ai")
+
+        image_url = images[0].get("url", "")
+        width = images[0].get("width", "")
+        height = images[0].get("height", "")
+        output = f"Image URL: {image_url}"
+        if width and height:
+            output += f"\nSize: {width}x{height}"
+        return ToolResult(output=output, metadata={"url": image_url})

{echo_agent-0.2.1 → 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.1 → echo_agent-0.2.3}/echo_agent/channels/base.py

@@ -21,6 +21,7 @@ class SendResult:
     success: bool
     message_id: str = ""
     error: str = ""
+    skipped: bool = False
 
 
 class BaseChannel(ABC):
@@ -52,6 +53,20 @@ class BaseChannel(ABC):
     async def send(self, event: OutboundEvent) -> SendResult | None:
         """Send a message through this channel."""
 
+    def should_deliver(self, event: OutboundEvent) -> bool:
+        """Return False to silently skip non-final messages on channels that cannot edit.
+
+        Channels that support message editing (Telegram, Discord) can show progress
+        then overwrite it with the final response. Channels without edit support would
+        deliver every intermediate chunk as a separate, irrevocable message — confusing
+        the user with duplicates. This guard prevents that at the base layer.
+        """
+        if self.supports_edit:
+            return True
+        if event.is_final:
+            return True
+        return False
+
     async def edit_message(
         self,
         chat_id: str,

{echo_agent-0.2.1 → echo_agent-0.2.3}/echo_agent/channels/dingtalk.py

@@ -56,6 +56,8 @@ class DingTalkChannel(BaseChannel):
             await self._session.close()
 
     async def send(self, event: OutboundEvent) -> SendResult | None:
+        if not self.should_deliver(event):
+            return SendResult(success=True, skipped=True)
         text = event.text or ""
         if not text or not self._session:
             return SendResult(success=False, error="no text or no session")

{echo_agent-0.2.1 → echo_agent-0.2.3}/echo_agent/channels/email.py

@@ -44,6 +44,8 @@ class EmailChannel(BaseChannel):
                 pass
 
     async def send(self, event: OutboundEvent) -> SendResult | None:
+        if not self.should_deliver(event):
+            return SendResult(success=True, skipped=True)
         text = event.text or ""
         if not text:
             return SendResult(success=False, error="no text")

{echo_agent-0.2.1 → echo_agent-0.2.3}/echo_agent/channels/feishu.py

@@ -56,6 +56,8 @@ class FeishuChannel(BaseChannel):
             await self._session.close()
 
     async def send(self, event: OutboundEvent) -> SendResult | None:
+        if not self.should_deliver(event):
+            return SendResult(success=True, skipped=True)
         text = event.text or ""
         if not text or not self._session:
             return SendResult(success=False, error="no text or no session")

{echo_agent-0.2.1 → echo_agent-0.2.3}/echo_agent/channels/matrix.py

@@ -54,6 +54,8 @@ class MatrixChannel(BaseChannel):
             await self._session.close()
 
     async def send(self, event: OutboundEvent) -> SendResult | None:
+        if not self.should_deliver(event):
+            return SendResult(success=True, skipped=True)
         text = event.text or ""
         if not text or not self._session:
             return SendResult(success=False, error="no text or no session")

{echo_agent-0.2.1 → echo_agent-0.2.3}/echo_agent/channels/qqbot.py

@@ -191,6 +191,8 @@ class QQBotChannel(BaseChannel):
     # ── Send ─────────────────────────────────────────────────────────────────
 
     async def send(self, event: OutboundEvent) -> SendResult | None:
+        if not self.should_deliver(event):
+            return SendResult(success=True, skipped=True)
         if not self._session:
             return SendResult(success=False, error="session not initialized")
         await self._ensure_token()

{echo_agent-0.2.1 → echo_agent-0.2.3}/echo_agent/channels/webhook.py

@@ -43,6 +43,8 @@ class WebhookChannel(BaseChannel):
             await self._runner.cleanup()
 
     async def send(self, event: OutboundEvent) -> SendResult | None:
+        if not self.should_deliver(event):
+            return SendResult(success=True, skipped=True)
         future = self._pending_responses.pop(event.reply_to_id or "", None)
         if future and not future.done():
             future.set_result(event.text)

{echo_agent-0.2.1 → echo_agent-0.2.3}/echo_agent/channels/wecom.py

@@ -55,6 +55,8 @@ class WeComChannel(BaseChannel):
             await self._session.close()
 
     async def send(self, event: OutboundEvent) -> SendResult | None:
+        if not self.should_deliver(event):
+            return SendResult(success=True, skipped=True)
         text = event.text or ""
         if not text or not self._session:
             return SendResult(success=False, error="no text or no session")

{echo_agent-0.2.1 → echo_agent-0.2.3}/echo_agent/channels/weixin.py

@@ -367,6 +367,8 @@ class WeixinChannel(BaseChannel):
     # ── Send ─────────────────────────────────────────────────────────────────
 
     async def send(self, event: OutboundEvent) -> SendResult | None:
+        if not self.should_deliver(event):
+            return SendResult(success=True, skipped=True)
         text = event.text or ""
         if not text or not self._send_session or not self._token:
             return SendResult(success=False, error="no text, no session, or no token")