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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: echo-agent
-Version: 0.2.1
+Version: 0.2.2
 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.2}/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.2/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.2}/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.2}/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.2}/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.2}/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.2}/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.2}/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.2}/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.2}/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.2}/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")

{echo_agent-0.2.1 → echo_agent-0.2.2}/echo_agent/channels/whatsapp.py

@@ -51,6 +51,8 @@ class WhatsAppChannel(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.2}/echo_agent/cli/i18n/en.py

@@ -156,9 +156,17 @@ MESSAGES = {
         "web_provider": "Search provider:",
         "web_api_key": "Search API key",
         "image_api_key": "Image-gen API key",
+        "image_api_base": "Image-gen API base URL",
         "image_model": "Image-gen model",
+        "image_backend": "Image-gen backend:",
+        "image_backend_openai": "OpenAI-compatible (SiliconFlow / DashScope / OpenAI)",
+        "image_backend_fal": "FAL.ai (FLUX / Ideogram / Recraft / Qwen)",
+        "image_fal_key": "FAL.ai API key",
+        "image_fal_model": "FAL model (e.g. fal-ai/flux/schnell)",
         "tts_backend": "TTS backend:",
         "tts_openai_key": "OpenAI TTS API key",
+        "tts_openai_base": "TTS API base URL",
+        "tts_model": "TTS model",
         "mcp_skip_hint": "Configure MCP servers later in echo-agent.yaml under tools.mcp_servers",
         "saved": "Tool profile: {profile}, optional: {extras}",
     },

{echo_agent-0.2.1 → echo_agent-0.2.2}/echo_agent/cli/i18n/zh.py

@@ -156,9 +156,17 @@ MESSAGES = {
         "web_provider": "搜索 Provider：",
         "web_api_key": "搜索 API key",
         "image_api_key": "图像生成 API key",
+        "image_api_base": "图像生成 API 地址",
         "image_model": "图像生成模型",
+        "image_backend": "图像生成后端：",
+        "image_backend_openai": "OpenAI 兼容（硅基流动/通义/智谱/OpenAI）",
+        "image_backend_fal": "FAL.ai（FLUX/Ideogram/Recraft/Qwen）",
+        "image_fal_key": "FAL.ai API key",
+        "image_fal_model": "FAL 模型（如 fal-ai/flux/schnell）",
         "tts_backend": "TTS 后端：",
         "tts_openai_key": "OpenAI TTS API key",
+        "tts_openai_base": "TTS API 地址",
+        "tts_model": "TTS 模型",
         "mcp_skip_hint": "稍后在 echo-agent.yaml 的 tools.mcp_servers 中配置 MCP。",
         "saved": "工具档位：{profile}，可选：{extras}",
     },

{echo_agent-0.2.1 → echo_agent-0.2.2}/echo_agent/cli/setup.py

@@ -389,7 +389,7 @@ def setup_tools(config: dict) -> None:
     if (tools.get("web", {}) or {}).get("enabled"):
         pre_selected.append(TOOL_OPTIONS.index("web"))
     image_block = tools.get("image_gen") or tools.get("imageGen") or {}
-    if image_block.get("api_key") or image_block.get("apiKey"):
+    if image_block.get("api_key") or image_block.get("apiKey") or image_block.get("fal_key") or image_block.get("falKey"):
         pre_selected.append(TOOL_OPTIONS.index("image_gen"))
     tts_block = tools.get("tts", {}) or {}
     if tts_block.get("openai_api_key") or tts_block.get("openaiApiKey") or tts_block.get("default_backend"):
@@ -436,16 +436,36 @@ def setup_tools(config: dict) -> None:
 
     if "image_gen" in chosen:
         ig = _ensure_dict(tools, "image_gen")
-        existing = ig.get("api_key") or ig.get("apiKey") or ""
-        if existing:
-            new_key = prompt(f"  {t('tools.image_api_key')} [****{t('common.saved')}]", password=True)
-            if new_key:
-                ig["api_key"] = new_key
+        backend_options = [t("tools.image_backend_openai"), t("tools.image_backend_fal")]
+        backend_values = ["openai", "fal"]
+        cur_backend = ig.get("backend", "openai")
+        b_idx = prompt_choice(t("tools.image_backend"), backend_options,
+                              default=backend_values.index(cur_backend) if cur_backend in backend_values else 0)
+        ig["backend"] = backend_values[b_idx]
+
+        if backend_values[b_idx] == "fal":
+            existing = ig.get("fal_key") or ig.get("falKey") or ""
+            if existing:
+                new_key = prompt(f"  {t('tools.image_fal_key')} [****{t('common.saved')}]", password=True)
+                if new_key:
+                    ig["fal_key"] = new_key
+            else:
+                new_key = prompt(f"  {t('tools.image_fal_key')}", password=True)
+                if new_key:
+                    ig["fal_key"] = new_key
+            ig["fal_model"] = prompt(f"  {t('tools.image_fal_model')}", default=ig.get("fal_model") or ig.get("falModel") or "fal-ai/flux/schnell")
         else:
-            new_key = prompt(f"  {t('tools.image_api_key')}", password=True)
-            if new_key:
-                ig["api_key"] = new_key
-        ig["model"] = prompt(f"  {t('tools.image_model')}", default=ig.get("model", "dall-e-3"))
+            existing = ig.get("api_key") or ig.get("apiKey") or ""
+            if existing:
+                new_key = prompt(f"  {t('tools.image_api_key')} [****{t('common.saved')}]", password=True)
+                if new_key:
+                    ig["api_key"] = new_key
+            else:
+                new_key = prompt(f"  {t('tools.image_api_key')}", password=True)
+                if new_key:
+                    ig["api_key"] = new_key
+            ig["api_base"] = prompt(f"  {t('tools.image_api_base')}", default=ig.get("api_base") or ig.get("apiBase") or "https://api.openai.com/v1")
+            ig["model"] = prompt(f"  {t('tools.image_model')}", default=ig.get("model", "dall-e-3"))
 
     if "tts" in chosen:
         tts = _ensure_dict(tools, "tts")
@@ -462,6 +482,8 @@ def setup_tools(config: dict) -> None:
                     tts["openai_api_key"] = new_key
             else:
                 tts["openai_api_key"] = prompt(f"  {t('tools.tts_openai_key')}", password=True)
+            tts["openai_api_base"] = prompt(f"  {t('tools.tts_openai_base')}", default=tts.get("openai_api_base", "https://api.openai.com/v1"))
+            tts["model"] = prompt(f"  {t('tools.tts_model')}", default=tts.get("model", "tts-1"))
 
     code_exec = _ensure_dict(tools, "code_exec")
     code_exec["enabled"] = "code_exec" in chosen

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

@@ -243,13 +243,20 @@ class WebToolConfig(_Base):
 
 
 class ImageGenConfig(_Base):
+    backend: str = "openai"
+    # OpenAI-compatible backend
     api_key: str = ""
     api_base: str = ""
-    model: str = "dall-e-3"
+    model: str = ""
+    # FAL.ai backend
+    fal_key: str = ""
+    fal_model: str = ""
 
 
 class TTSConfig(_Base):
     openai_api_key: str = ""
+    openai_api_base: str = ""
+    model: str = ""
     default_backend: str = "edge"
     default_voice: str = ""
 

{echo_agent-0.2.1 → echo_agent-0.2.2}/echo_agent/dependencies/lazy_deps.py

@@ -75,6 +75,7 @@ SKILL_DEPS: dict[str, tuple[str, ...]] = {
 
     # ─── Creative skills ──────────────────────────────────────────────────
     "skill.image-gen": (),  # uses API via urllib, no extra deps
+    "tool.image-gen-fal": ("fal-client>=0.5",),
     "skill.meme-gen": ("Pillow>=10.0",),
     "skill.ppt-author": ("python-pptx>=1.0",),
     "skill.excel-author": ("openpyxl>=3.1",),

echo_agent-0.2.2/echo_agent/gateway/api/__init__.py

@@ -0,0 +1,50 @@
+"""Management API routes for the desktop client.
+
+All routes are registered under the gateway's api_prefix (default /api).
+Authentication reuses the existing GatewayAuth token check.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from aiohttp import web
+
+if TYPE_CHECKING:
+    from echo_agent.gateway.server import GatewayServer
+
+
+def register_management_routes(app: web.Application, prefix: str, server: GatewayServer) -> None:
+    from echo_agent.gateway.api.memory import MemoryAPI
+    from echo_agent.gateway.api.skills import SkillsAPI
+    from echo_agent.gateway.api.channels import ChannelsAPI
+    from echo_agent.gateway.api.knowledge import KnowledgeAPI
+    from echo_agent.gateway.api.config import ConfigAPI
+
+    memory_api = MemoryAPI(server)
+    skills_api = SkillsAPI(server)
+    channels_api = ChannelsAPI(server)
+    knowledge_api = KnowledgeAPI(server)
+    config_api = ConfigAPI(server)
+
+    app.router.add_get(f"{prefix}/memory", memory_api.list_entries)
+    app.router.add_get(f"{prefix}/memory/stats", memory_api.stats)
+    app.router.add_post(f"{prefix}/memory/search", memory_api.search)
+    app.router.add_get(f"{prefix}/memory/{{id}}", memory_api.get_entry)
+    app.router.add_put(f"{prefix}/memory/{{id}}", memory_api.update_entry)
+    app.router.add_delete(f"{prefix}/memory/{{id}}", memory_api.delete_entry)
+
+    app.router.add_get(f"{prefix}/skills", skills_api.list_skills)
+    app.router.add_get(f"{prefix}/skills/{{name}}", skills_api.get_skill)
+    app.router.add_post(f"{prefix}/skills/{{name}}/toggle", skills_api.toggle_skill)
+
+    app.router.add_get(f"{prefix}/channels", channels_api.list_channels)
+
+    app.router.add_get(f"{prefix}/knowledge/status", knowledge_api.get_status)
+    app.router.add_post(f"{prefix}/knowledge/rebuild", knowledge_api.rebuild)
+    app.router.add_post(f"{prefix}/knowledge/upload", knowledge_api.upload)
+    app.router.add_get(f"{prefix}/knowledge/documents", knowledge_api.list_documents)
+    app.router.add_delete(f"{prefix}/knowledge/documents/{{path}}", knowledge_api.delete_document)
+
+    app.router.add_get(f"{prefix}/config", config_api.get_config)
+    app.router.add_get(f"{prefix}/config/models", config_api.get_models)