flowent 0.0.12 → 0.1.0

package/backend/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flowent"
-version = "0.0.12"
+version = "0.1.0"
 description = "A workflow orchestration platform for multi-agent collaboration."
 readme = "README.md"
 authors = [
@@ -11,6 +11,7 @@ license = "Apache-2.0"
 dependencies = [
     "fastapi[standard]>=0.136.1",
     "litellm>=1.84.0",
+    "mcp>=1.24.0",
     "uvicorn>=0.46.0",
 ]
 

package/backend/src/flowent/agent.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from collections.abc import AsyncIterator, Callable, Mapping, Sequence
+from collections.abc import AsyncIterator, Awaitable, Callable, Mapping, Sequence
 from dataclasses import dataclass
 from pathlib import Path
 from uuid import uuid4
@@ -20,6 +20,7 @@ from flowent.llm import (
 from flowent.logging import TRACE_LEVEL
 from flowent.tools import (
     ToolContext,
+    ToolResult,
     new_tool_item,
     parse_tool_arguments,
     run_tool,
@@ -104,6 +105,10 @@ async def run_agent_stream(
     connection: ProviderConnection,
     cwd: Path,
     messages: Sequence[Mapping[str, object]],
+    extra_tool_runner: Callable[[str, dict[str, object]], Awaitable[ToolResult | None]]
+    | None = None,
+    extra_tool_specs: Sequence[Mapping[str, object]] | None = None,
+    extra_tool_title: Callable[[str], str | None] | None = None,
     web_searcher: Callable[[str], Sequence[dict[str, str]]] | None = None,
 ) -> AsyncIterator[AgentStreamEvent]:
     conversation: list[Mapping[str, object]] = [
@@ -132,7 +137,10 @@ async def run_agent_stream(
         pending: dict[int, PendingToolCall] = {}
 
         async for chunk in stream_chat_chunks(
-            connection, conversation, completion=completion, tools=tool_specs()
+            connection,
+            conversation,
+            completion=completion,
+            tools=[*tool_specs(), *list(extra_tool_specs or [])],
         ):
             reasoning = chunk_delta_reasoning(chunk)
             if reasoning:
@@ -221,16 +229,29 @@ async def run_agent_stream(
                     },
                 )
             else:
-                tool_item = new_tool_item(tool_call.name, arguments)
+                tool_item = new_tool_item(
+                    tool_call.name,
+                    arguments,
+                    extra_tool_title(tool_call.name) if extra_tool_title else None,
+                )
                 logger.debug(
                     "Tool call started name=%s id=%s", tool_call.name, tool_item["id"]
                 )
                 logger.log(TRACE_LEVEL, "Tool start item=%r", tool_item)
                 yield AgentStreamEvent(event="tool_start", data={"tool": tool_item})
-                result = run_tool(
-                    tool_call.name,
-                    arguments,
-                    ToolContext(cwd=cwd, web_searcher=web_searcher),
+                extra_result = (
+                    await extra_tool_runner(tool_call.name, arguments)
+                    if extra_tool_runner is not None
+                    else None
+                )
+                result = (
+                    extra_result
+                    if isinstance(extra_result, ToolResult)
+                    else run_tool(
+                        tool_call.name,
+                        arguments,
+                        ToolContext(cwd=cwd, web_searcher=web_searcher),
+                    )
                 )
                 result_content = result.content
                 logger.debug(

package/backend/src/flowent/channels.py

@@ -0,0 +1,296 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import urllib.error
+import urllib.request
+from collections.abc import Awaitable, Callable
+from contextlib import suppress
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import Any, Protocol
+
+from flowent.storage import StateStore, StoredTelegramBot, StoredTelegramSession
+
+logger = logging.getLogger("flowent.channels")
+
+TELEGRAM_MESSAGE_LIMIT = 4096
+
+
+class ChannelStatus(StrEnum):
+    DISABLED = "disabled"
+    ERROR = "error"
+    RUNNING = "running"
+    STARTING = "starting"
+
+
+class TelegramTransport(Protocol):
+    async def get_updates(
+        self,
+        *,
+        offset: int | None,
+        timeout: int,
+        token: str,
+    ) -> list[dict[str, Any]]: ...
+
+    async def send_message(
+        self,
+        *,
+        chat_id: str,
+        text: str,
+        token: str,
+    ) -> None: ...
+
+
+class TelegramBotTransport:
+    async def get_updates(
+        self,
+        *,
+        offset: int | None,
+        timeout: int,
+        token: str,
+    ) -> list[dict[str, Any]]:
+        payload: dict[str, object] = {
+            "allowed_updates": ["message"],
+            "timeout": timeout,
+        }
+        if offset is not None:
+            payload["offset"] = offset
+        response = await asyncio.to_thread(
+            self._post,
+            token,
+            "getUpdates",
+            payload,
+        )
+        result = response.get("result")
+        if not isinstance(result, list):
+            raise RuntimeError("Updates could not be fetched.")
+        return [update for update in result if isinstance(update, dict)]
+
+    async def send_message(
+        self,
+        *,
+        chat_id: str,
+        text: str,
+        token: str,
+    ) -> None:
+        await asyncio.to_thread(
+            self._post,
+            token,
+            "sendMessage",
+            {"chat_id": chat_id, "text": text},
+        )
+
+    def _post(
+        self,
+        token: str,
+        method: str,
+        payload: dict[str, object],
+    ) -> dict[str, Any]:
+        request = urllib.request.Request(
+            f"https://api.telegram.org/bot{token}/{method}",
+            data=json.dumps(payload).encode("utf-8"),
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(request, timeout=40) as response:
+                raw_body = response.read().decode("utf-8")
+        except urllib.error.HTTPError as error:
+            raw_body = error.read().decode("utf-8")
+            try:
+                body = json.loads(raw_body)
+            except json.JSONDecodeError as decode_error:
+                raise RuntimeError("Telegram request failed.") from decode_error
+            description = body.get("description")
+            raise RuntimeError(
+                str(description) if description else "Telegram request failed."
+            ) from error
+        except urllib.error.URLError as error:
+            raise RuntimeError(str(error.reason)) from error
+
+        body = json.loads(raw_body)
+        if not body.get("ok"):
+            description = body.get("description")
+            raise RuntimeError(
+                str(description) if description else "Telegram request failed."
+            )
+        return body
+
+
+@dataclass
+class ChannelRuntime:
+    error: str = ""
+    offset: int | None = None
+    status: ChannelStatus = ChannelStatus.DISABLED
+    task: asyncio.Task[None] | None = None
+
+
+class TelegramBotManager:
+    def __init__(
+        self,
+        *,
+        message_handler: Callable[[str], Awaitable[str]],
+        store: StateStore,
+        telegram_transport: TelegramTransport | None = None,
+    ) -> None:
+        self.message_handler = message_handler
+        self.store = store
+        self.telegram_transport = telegram_transport or TelegramBotTransport()
+        self.runtime = ChannelRuntime()
+
+    def bot_with_status(self, bot: StoredTelegramBot) -> StoredTelegramBot:
+        if not bot.enabled:
+            return bot.model_copy(
+                update={"status": ChannelStatus.DISABLED, "error": ""}
+            )
+        if self.runtime.status == ChannelStatus.DISABLED:
+            return bot.model_copy(
+                update={"status": ChannelStatus.STARTING, "error": ""}
+            )
+        return bot.model_copy(
+            update={"status": self.runtime.status, "error": self.runtime.error}
+        )
+
+    async def start_enabled(self) -> None:
+        await self.sync_bot(self.store.read_telegram_bot())
+
+    async def stop_all(self) -> None:
+        if self.runtime.task is not None:
+            self.runtime.task.cancel()
+            with suppress(asyncio.CancelledError):
+                await self.runtime.task
+        self.runtime = ChannelRuntime()
+
+    async def sync_bot(self, bot: StoredTelegramBot) -> None:
+        if not bot.enabled:
+            if self.runtime.task is not None:
+                self.runtime.task.cancel()
+            self.runtime.status = ChannelStatus.DISABLED
+            self.runtime.error = ""
+            return
+        if self.runtime.task is not None and not self.runtime.task.done():
+            return
+        self.runtime.status = ChannelStatus.STARTING
+        self.runtime.error = ""
+        self.runtime.task = asyncio.create_task(self._run_bot(bot))
+
+    async def poll_once(self, bot: StoredTelegramBot) -> None:
+        if not bot.enabled:
+            self.runtime.status = ChannelStatus.DISABLED
+            self.runtime.error = ""
+            return
+
+        self.runtime.status = ChannelStatus.STARTING
+        self.runtime.error = ""
+        try:
+            updates = await self.telegram_transport.get_updates(
+                offset=self.runtime.offset,
+                timeout=30,
+                token=bot.bot_token,
+            )
+            self.runtime.status = ChannelStatus.RUNNING
+            for update in updates:
+                update_id = update.get("update_id")
+                if isinstance(update_id, int):
+                    self.runtime.offset = max(self.runtime.offset or 0, update_id + 1)
+                await self._handle_telegram_update(bot, update)
+        except Exception as error:
+            self.runtime.status = ChannelStatus.ERROR
+            self.runtime.error = str(error) or "Connection failed."
+            logger.exception("Telegram polling failed")
+
+    async def _run_bot(self, bot: StoredTelegramBot) -> None:
+        while True:
+            await self.poll_once(bot)
+            if self.runtime.status == ChannelStatus.ERROR:
+                await asyncio.sleep(5)
+
+    async def _handle_telegram_update(
+        self,
+        bot: StoredTelegramBot,
+        update: dict[str, Any],
+    ) -> None:
+        message = update.get("message")
+        if not isinstance(message, dict):
+            return
+        text = message.get("text")
+        if not isinstance(text, str) or text == "":
+            return
+        chat = message.get("chat")
+        sender = message.get("from")
+        chat_id = str(chat.get("id")) if isinstance(chat, dict) else ""
+        if not chat_id:
+            return
+
+        session = self._telegram_session(
+            chat=chat if isinstance(chat, dict) else {},
+            message=text,
+            sender=sender if isinstance(sender, dict) else {},
+        )
+        if not self._is_approved(session.chat_id):
+            self.store.save_telegram_session(session)
+            await self._send_telegram_reply(
+                bot,
+                chat_id,
+                "Request received. Approve this conversation in Flowent.",
+            )
+            return
+
+        self.store.save_telegram_session(
+            session.model_copy(update={"status": "approved"})
+        )
+
+        reply = await self.message_handler(text)
+        await self._send_telegram_reply(bot, chat_id, reply)
+
+    def _is_approved(self, chat_id: str) -> bool:
+        return any(
+            session.chat_id == chat_id and session.status == "approved"
+            for session in self.store.read_telegram_bot().sessions
+        )
+
+    def _telegram_session(
+        self,
+        *,
+        chat: dict[str, Any],
+        message: str,
+        sender: dict[str, Any],
+    ) -> StoredTelegramSession:
+        first_name = str(sender.get("first_name") or "")
+        last_name = str(sender.get("last_name") or "")
+        title = str(chat.get("title") or "")
+        display_name = title or " ".join(
+            part for part in [first_name, last_name] if part
+        )
+        return StoredTelegramSession(
+            chat_id=str(chat.get("id") or ""),
+            display_name=display_name,
+            recent_message=message,
+            status="pending",
+            user_id=str(sender.get("id") or ""),
+            username=str(sender.get("username") or ""),
+        )
+
+    async def _send_telegram_reply(
+        self,
+        bot: StoredTelegramBot,
+        chat_id: str,
+        content: str,
+    ) -> None:
+        for part in split_telegram_message(content):
+            await self.telegram_transport.send_message(
+                chat_id=chat_id,
+                text=part,
+                token=bot.bot_token,
+            )
+
+
+def split_telegram_message(content: str) -> list[str]:
+    if content == "":
+        return [""]
+    return [
+        content[index : index + TELEGRAM_MESSAGE_LIMIT]
+        for index in range(0, len(content), TELEGRAM_MESSAGE_LIMIT)
+    ]