flowent 0.2.4__tar.gz → 0.3.0__tar.gz

{flowent-0.2.4 → flowent-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowent
-Version: 0.2.4
+Version: 0.3.0
 Summary: A workflow orchestration platform for multi-agent collaboration
 Keywords: agent,agents,ai,ai-agents,assistant,automation,code-generation,llm,mcp,orchestration,sandbox,web-application,workflow
 Author: ImFeH2
@@ -44,11 +44,11 @@ A workflow orchestration platform for multi-agent collaboration.
 
 ## Install
 
-Flowent requires Bubblewrap for local tool isolation. Install the system package
-first:
+Flowent requires Bubblewrap for local tool isolation and ripgrep for file
+search. Install the system packages first:
 
 ```bash
-sudo apt-get install bubblewrap
+sudo apt-get install bubblewrap ripgrep
 ```
 
 Install the CLI globally:

{flowent-0.2.4 → flowent-0.3.0}/README.md

@@ -17,11 +17,11 @@ A workflow orchestration platform for multi-agent collaboration.
 
 ## Install
 
-Flowent requires Bubblewrap for local tool isolation. Install the system package
-first:
+Flowent requires Bubblewrap for local tool isolation and ripgrep for file
+search. Install the system packages first:
 
 ```bash
-sudo apt-get install bubblewrap
+sudo apt-get install bubblewrap ripgrep
 ```
 
 Install the CLI globally:

{flowent-0.2.4 → flowent-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flowent"
-version = "0.2.4"
+version = "0.3.0"
 description = "A workflow orchestration platform for multi-agent collaboration"
 readme = "README.md"
 authors = [

{flowent-0.2.4 → flowent-0.3.0}/src/flowent/agent.py

@@ -45,7 +45,7 @@ Use tools deliberately:
 - Search the web only when current external information is needed.
 - Update the plan when a task has multiple meaningful steps.
 
-After each tool result, decide whether the task is complete, whether another tool is needed, or whether you need to explain a blocker. When no more tool work is needed, provide the final response."""
+After each tool result, decide whether the task is complete, whether another tool is needed, or whether you need to explain a blocker. A tool call is not a final response. After every tool result, continue the same turn until you either call another tool, explain a blocker, or provide a final response. If a tool fails, use the error as context and continue deciding whether to retry, use another tool, or explain the blocker. When no more tool work is needed, provide the final response."""
 
 
 class AgentStreamEvent(BaseModel):

flowent-0.3.0/src/flowent/api_models.py

@@ -0,0 +1,103 @@
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict
+
+from flowent.llm import ProviderFormat
+from flowent.storage import StoredMessage, StoredWritablePath
+from flowent.usage import TokenUsageInfo
+
+
+class ProviderModelsRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    provider: ProviderFormat
+    secret_reference: str
+    base_url: str | None = None
+
+
+class ProviderModelsResponse(BaseModel):
+    models: list[str]
+
+
+class WorkspaceMessagesRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    messages: list[StoredMessage]
+
+
+class WorkspaceMessageEditRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    action: Literal["resend", "save"]
+    content: str
+
+
+class WorkspaceMessageEditResponse(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    messages: list[StoredMessage]
+    run_id: str | None = None
+
+
+class WorkspaceRespondRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    content: str
+    message_id: str | None = None
+
+
+class WorkspaceRunResponse(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    run_id: str
+
+
+class WorkspaceClearResponse(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    active_run_id: str | None = None
+    messages: list[StoredMessage]
+    usage_info: TokenUsageInfo | None = None
+
+
+class AboutResponse(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    version: str
+
+
+class TelegramSessionApproveRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    chat_id: str
+
+
+class SkillSettingsRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    enabled: bool
+
+
+class McpImportRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    server_id: str
+    source: Literal["claude_code", "codex"]
+
+
+class McpImportPreviewRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    source: Literal["claude_code", "codex"]
+
+
+class WritablePathRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    path: str
+
+
+class WritablePathListResponse(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    writable_paths: list[StoredWritablePath]

flowent-0.3.0/src/flowent/app.py

@@ -0,0 +1,151 @@
+import logging
+import os
+from collections.abc import AsyncIterator, Awaitable
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+
+from flowent.channels import TelegramBotManager, TelegramTransport
+from flowent.compact import LocalSummaryCompactProvider
+from flowent.llm import CompletionCallable
+from flowent.logging import ensure_logging_configured
+from flowent.mcp import McpManager, McpTransport
+from flowent.paths import resolve_workdir
+from flowent.routes.integrations import register_integration_routes
+from flowent.routes.permissions import register_permission_routes
+from flowent.routes.providers import register_provider_routes
+from flowent.routes.system import register_system_routes
+from flowent.routes.workflow_routes import register_workflow_routes
+from flowent.routes.workspace import register_workspace_routes
+from flowent.sandbox import ensure_sandbox_available
+from flowent.storage import StateStore
+from flowent.system_tools import ensure_ripgrep_available
+from flowent.workspace.runtime import WorkspaceRuntime
+
+logger = logging.getLogger("flowent.app")
+
+
+DEFAULT_STATIC_DIR = Path(__file__).parent / "static"
+
+
+def frontend_static_directory() -> Path:
+    configured_directory = os.environ.get("FLOWENT_STATIC_DIR")
+    if configured_directory:
+        return Path(configured_directory)
+    repository_frontend_dist = Path(__file__).resolve().parents[3] / "frontend" / "dist"
+    if repository_frontend_dist.is_dir():
+        return repository_frontend_dist
+    return DEFAULT_STATIC_DIR
+
+
+def create_app(
+    *,
+    serve_frontend: bool = True,
+    chat_completion: CompletionCallable | None = None,
+    mcp_transport: McpTransport | None = None,
+    telegram_transport: TelegramTransport | None = None,
+    workdir: Path | str | None = None,
+) -> FastAPI:
+    ensure_logging_configured()
+    ensure_sandbox_available()
+    ensure_ripgrep_available()
+
+    cwd = resolve_workdir(workdir)
+    store = StateStore()
+    compact_provider = LocalSummaryCompactProvider()
+    mcp_manager = McpManager(store=store, transport=mcp_transport)
+
+    static_dir = frontend_static_directory().resolve(strict=False)
+    logger.debug("Flowent app created serve_frontend=%s", serve_frontend)
+    logger.info("Workdir: %s", cwd)
+    logger.info("Static directory: %s", static_dir)
+
+    runtime = WorkspaceRuntime(
+        chat_completion=chat_completion,
+        compact_provider=compact_provider,
+        cwd=cwd,
+        mcp_manager=mcp_manager,
+        store=store,
+    )
+
+    telegram_bot_manager = TelegramBotManager(
+        message_handler=runtime.reply_text,
+        store=store,
+        telegram_transport=telegram_transport,
+    )
+
+    async def run_shutdown_step(label: str, cleanup: Awaitable[object]) -> None:
+        try:
+            await cleanup
+        except Exception:
+            logger.exception("%s cleanup failed during shutdown", label)
+
+    async def graceful_shutdown() -> None:
+        await run_shutdown_step("Workspace", runtime.stop_for_shutdown())
+        await run_shutdown_step("Telegram", telegram_bot_manager.stop_all())
+        await run_shutdown_step("MCP", mcp_manager.stop_all())
+
+    @asynccontextmanager
+    async def lifespan(app: FastAPI) -> AsyncIterator[None]:
+        app.state.mcp_manager = mcp_manager
+        app.state.telegram_bot_manager = telegram_bot_manager
+        await mcp_manager.start_enabled()
+        await telegram_bot_manager.start_enabled()
+        try:
+            yield
+        finally:
+            await graceful_shutdown()
+
+    app = FastAPI(title="Flowent", lifespan=lifespan)
+    app.state.mcp_manager = mcp_manager
+    app.state.telegram_bot_manager = telegram_bot_manager
+
+    register_system_routes(
+        app,
+        cwd=cwd,
+        mcp_manager=mcp_manager,
+        runtime=runtime,
+        store=store,
+        telegram_bot_manager=telegram_bot_manager,
+    )
+    register_provider_routes(app, store=store)
+    register_integration_routes(
+        app,
+        cwd=cwd,
+        mcp_manager=mcp_manager,
+        store=store,
+        telegram_bot_manager=telegram_bot_manager,
+    )
+    register_workflow_routes(
+        app,
+        chat_completion=chat_completion,
+        store=store,
+    )
+    register_permission_routes(app, cwd=cwd, store=store)
+    register_workspace_routes(app, runtime=runtime, store=store)
+
+    if serve_frontend and static_dir.is_dir():
+        assets_dir = static_dir / "assets"
+        if assets_dir.is_dir():
+            app.mount("/assets", StaticFiles(directory=assets_dir), name="assets")
+
+        @app.get("/{path:path}")
+        async def spa_fallback(path: str) -> FileResponse:
+            file = (static_dir / path).resolve(strict=False)
+            if file.is_file() and file.is_relative_to(static_dir):
+                return FileResponse(file)
+            return FileResponse(static_dir / "index.html")
+
+    return app
+
+
+app = create_app()
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app)

{flowent-0.2.4 → flowent-0.3.0}/src/flowent/cli.py

@@ -59,13 +59,22 @@ def main(argv: list[str] | None = None) -> None:
 
     if args.command == "doctor":
         from flowent.sandbox import SANDBOX_INSTALL_HINT, sandbox_binary
+        from flowent.system_tools import RIPGREP_INSTALL_HINT, ripgrep_binary
 
         bwrap = sandbox_binary()
+        rg = ripgrep_binary()
+
         if bwrap:
             print(f"Sandbox: {bwrap}")
-            raise SystemExit(0)
-        print(f"Sandbox: missing. {SANDBOX_INSTALL_HINT}", file=sys.stderr)
-        raise SystemExit(1)
+        else:
+            print(f"Sandbox: missing. {SANDBOX_INSTALL_HINT}", file=sys.stderr)
+
+        if rg:
+            print(f"Search: {rg}")
+        else:
+            print(f"Search: missing. {RIPGREP_INSTALL_HINT}", file=sys.stderr)
+
+        raise SystemExit(0 if bwrap and rg else 1)
 
     if args.version:
         try:
@@ -95,7 +104,7 @@ def main(argv: list[str] | None = None) -> None:
     import uvicorn
 
     uvicorn.run(
-        "flowent.main:app",
+        "flowent.app:app",
         host=args.host,
         port=args.port,
     )

{flowent-0.2.4 → flowent-0.3.0}/src/flowent/compact.py

@@ -10,7 +10,7 @@ from flowent.llm import (
     ProviderConnection,
     complete_chat_with_usage,
 )
-from flowent.usage import TokenUsage
+from flowent.usage import APPROX_BYTES_PER_TOKEN, TokenUsage, approximate_token_count
 
 if TYPE_CHECKING:
     from flowent.storage import StoredMessage
@@ -172,14 +172,41 @@ def retained_recent_user_messages(
 def truncate_text_to_token_budget(content: str, token_budget: int) -> str:
     if token_budget <= 0 or not content:
         return ""
-    character_budget = max(token_budget * 4, 1)
-    if len(content) <= character_budget:
+    byte_budget = max(token_budget * APPROX_BYTES_PER_TOKEN, 1)
+    if len(content.encode("utf-8")) <= byte_budget:
         return content
-    left_budget = character_budget // 2
-    right_budget = character_budget - left_budget
-    removed_tokens = approximate_token_count(content[left_budget:-right_budget])
+    left_budget = byte_budget // 2
+    right_budget = byte_budget - left_budget
+    prefix = text_prefix_for_byte_budget(content, left_budget)
+    suffix = text_suffix_for_byte_budget(content, right_budget)
+    middle_end = -len(suffix) if suffix else len(content)
+    removed_tokens = approximate_token_count(content[len(prefix) : middle_end])
     marker = f"…{removed_tokens} tokens truncated…"
-    return f"{content[:left_budget]}{marker}{content[-right_budget:]}"
+    return f"{prefix}{marker}{suffix}"
+
+
+def text_prefix_for_byte_budget(content: str, byte_budget: int) -> str:
+    used_bytes = 0
+    prefix: list[str] = []
+    for character in content:
+        character_bytes = len(character.encode("utf-8"))
+        if used_bytes + character_bytes > byte_budget:
+            break
+        prefix.append(character)
+        used_bytes += character_bytes
+    return "".join(prefix)
+
+
+def text_suffix_for_byte_budget(content: str, byte_budget: int) -> str:
+    used_bytes = 0
+    suffix: list[str] = []
+    for character in reversed(content):
+        character_bytes = len(character.encode("utf-8"))
+        if used_bytes + character_bytes > byte_budget:
+            break
+        suffix.append(character)
+        used_bytes += character_bytes
+    return "".join(reversed(suffix))
 
 
 def transcript_messages_after(
@@ -196,9 +223,3 @@ def transcript_messages_after(
 
 def approximate_tokens_for_messages(messages: Sequence[ChatMessage]) -> int:
     return sum(approximate_token_count(message.content) for message in messages)
-
-
-def approximate_token_count(content: str) -> int:
-    if not content:
-        return 0
-    return max(1, (len(content) + 3) // 4)

{flowent-0.2.4 → flowent-0.3.0}/src/flowent/llm.py

@@ -13,6 +13,7 @@ from flowent.logging import (
     configure_litellm_logging,
     write_llm_request_diagnostic,
 )
+from flowent.network import flowent_user_agent
 from flowent.usage import TokenUsage, token_usage_from_response
 
 
@@ -300,6 +301,7 @@ def build_litellm_request(
     )
     request: dict[str, Any] = {
         "api_key": connection.secret_reference,
+        "extra_headers": {"User-Agent": flowent_user_agent()},
         "messages": request_messages,
         "model": provider_model_name(connection),
     }

flowent-0.3.0/src/flowent/main.py

@@ -0,0 +1,19 @@
+from flowent.app import (
+    app,
+    create_app,
+    frontend_static_directory,
+)
+from flowent.provider_connections import selected_connection
+from flowent.routes.permissions import normalized_request_path
+from flowent.workspace.context import should_auto_compact
+from flowent.workspace.runtime import WORKSPACE_PROGRESS_FLUSH_INTERVAL_SECONDS
+
+__all__ = [
+    "WORKSPACE_PROGRESS_FLUSH_INTERVAL_SECONDS",
+    "app",
+    "create_app",
+    "frontend_static_directory",
+    "normalized_request_path",
+    "selected_connection",
+    "should_auto_compact",
+]

{flowent-0.2.4 → flowent-0.3.0}/src/flowent/mcp.py

@@ -5,17 +5,23 @@ import json
 import logging
 import os
 import re
+import sys
 from collections.abc import Callable
-from contextlib import AsyncExitStack
+from contextlib import AsyncExitStack, suppress
 from dataclasses import dataclass
 from importlib import import_module
-from typing import Any, Protocol
+from typing import Any, Protocol, TextIO, cast
 
 from flowent.storage import StateStore, StoredMcpServer, StoredMcpTool
 from flowent.tools import ToolResult
 
 logger = logging.getLogger("flowent.mcp")
 MCP_CONNECT_TIMEOUT_SECONDS = 10
+PYTHON_TRACEBACK_START = "Traceback (most recent call last):"
+PYTHON_TRACEBACK_TERMINAL_PATTERN = re.compile(
+    r"^(?:[A-Za-z_][A-Za-z0-9_.]*(?:Error|Exception|Interrupt|Warning)|"
+    r"BaseExceptionGroup|ExceptionGroup)(?::|$)"
+)
 
 
 class McpTransport(Protocol):
@@ -128,6 +134,96 @@ class _McpConnection:
     session: Any = None
 
 
+class _McpStdioErrorFilter:
+    def __init__(self, target: TextIO) -> None:
+        self.target = target
+        self.line_buffer = ""
+        self.traceback_lines: list[str] | None = None
+
+    def feed(self, text: str) -> None:
+        self.line_buffer += text
+        while "\n" in self.line_buffer:
+            line, self.line_buffer = self.line_buffer.split("\n", 1)
+            self.feed_line(f"{line}\n")
+
+    def finish(self) -> None:
+        if self.line_buffer:
+            self.feed_line(self.line_buffer)
+            self.line_buffer = ""
+        if self.traceback_lines is not None:
+            self.write("".join(self.traceback_lines))
+            self.traceback_lines = None
+
+    def feed_line(self, line: str) -> None:
+        stripped_line = line.rstrip("\r\n")
+        if self.traceback_lines is not None:
+            self.traceback_lines.append(line)
+            if stripped_line == "KeyboardInterrupt":
+                self.traceback_lines = None
+                return
+            if PYTHON_TRACEBACK_TERMINAL_PATTERN.match(stripped_line):
+                self.write("".join(self.traceback_lines))
+                self.traceback_lines = None
+            return
+        if stripped_line == PYTHON_TRACEBACK_START:
+            self.traceback_lines = [line]
+            return
+        self.write(line)
+
+    def write(self, text: str) -> None:
+        self.target.write(text)
+        self.target.flush()
+
+
+class _McpStdioErrorLog:
+    def __init__(self, target: TextIO | None = None) -> None:
+        self.target = target or sys.stderr
+        self.filter = _McpStdioErrorFilter(self.target)
+        self.read_fd, write_fd = os.pipe()
+        self.write_file = os.fdopen(write_fd, "wb", buffering=0)
+        self.drain_task: asyncio.Task[None] | None = None
+
+    async def __aenter__(self) -> _McpStdioErrorLog:
+        self.drain_task = asyncio.create_task(self.drain())
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        traceback: object,
+    ) -> None:
+        self.close_write_file()
+        if self.drain_task is not None:
+            await asyncio.gather(self.drain_task, return_exceptions=True)
+        else:
+            self.close_read_fd()
+
+    def fileno(self) -> int:
+        return self.write_file.fileno()
+
+    async def drain(self) -> None:
+        try:
+            while True:
+                chunk = await asyncio.to_thread(os.read, self.read_fd, 4096)
+                if not chunk:
+                    break
+                self.filter.feed(chunk.decode("utf-8", errors="replace"))
+        except OSError:
+            pass
+        finally:
+            self.filter.finish()
+            self.close_read_fd()
+
+    def close_write_file(self) -> None:
+        with suppress(OSError, ValueError):
+            self.write_file.close()
+
+    def close_read_fd(self) -> None:
+        with suppress(OSError):
+            os.close(self.read_fd)
+
+
 class DefaultMcpTransport:
     def __init__(self) -> None:
         self._connections: dict[str, _McpConnection] = {}
@@ -197,9 +293,11 @@ class DefaultMcpTransport:
                             )
                         )
                 else:
+                    stdio_errlog = await stack.enter_async_context(_McpStdioErrorLog())
                     read_stream, write_stream = await stack.enter_async_context(
                         stdio_client(
                             self._stdio_parameters(server, config),
+                            errlog=cast(TextIO, stdio_errlog),
                         )
                     )
                 session = await stack.enter_async_context(

flowent-0.3.0/src/flowent/network.py

@@ -0,0 +1,5 @@
+from flowent._version import __version__
+
+
+def flowent_user_agent() -> str:
+    return f"Flowent/{__version__}"

flowent-0.3.0/src/flowent/provider_connections.py

@@ -0,0 +1,42 @@
+import logging
+
+from fastapi import HTTPException
+
+from flowent.llm import ProviderConnection
+from flowent.storage import StoredState
+
+logger = logging.getLogger("flowent.provider_connections")
+
+
+def selected_connection(state: StoredState) -> ProviderConnection:
+    provider = next(
+        (
+            stored_provider
+            for stored_provider in state.providers
+            if stored_provider.id == state.settings.selected_provider_id
+        ),
+        None,
+    )
+    if provider is None or not state.settings.selected_model:
+        logger.warning("Workspace request blocked because provider or model is missing")
+        raise HTTPException(
+            status_code=400,
+            detail="Choose a provider and model before sending.",
+        )
+    if not provider.api_key:
+        logger.warning("Workspace request blocked because selected provider has no key")
+        raise HTTPException(status_code=400, detail="Add a key before sending.")
+
+    logger.debug(
+        "Workspace request using provider=%s model=%s",
+        provider.name,
+        state.settings.selected_model,
+    )
+    return ProviderConnection(
+        base_url=provider.base_url or None,
+        model=state.settings.selected_model,
+        name=provider.name,
+        provider=provider.type,
+        reasoning_effort=state.settings.reasoning_effort,
+        secret_reference=provider.api_key,
+    )