flowent 0.2.4 → 0.3.1

package/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:

package/backend/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:

package/backend/pyproject.toml

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

package/backend/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):

package/backend/src/flowent/api_models.py

@@ -0,0 +1,108 @@
+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 ProviderModelsFailureResponse(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    code: Literal[
+        "connection_failed",
+        "access_denied",
+        "rate_limited",
+        "provider_unavailable",
+        "request_failed",
+    ]
+
+
+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")
+
+    is_responding: bool = False
+    messages: list[StoredMessage]
+
+
+class WorkspaceRespondRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    content: str
+    message_id: str | None = None
+
+
+class WorkspaceClearResponse(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    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]

package/backend/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)

package/backend/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,
     )

package/backend/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)

package/backend/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
 
 
@@ -84,6 +85,20 @@ class LLMStreamError(RuntimeError):
     pass
 
 
+class ProviderModelFetchFailure(StrEnum):
+    CONNECTION_FAILED = "connection_failed"
+    ACCESS_DENIED = "access_denied"
+    RATE_LIMITED = "rate_limited"
+    PROVIDER_UNAVAILABLE = "provider_unavailable"
+    REQUEST_FAILED = "request_failed"
+
+
+class ProviderModelFetchError(RuntimeError):
+    def __init__(self, failure: ProviderModelFetchFailure) -> None:
+        super().__init__(failure.value)
+        self.failure = failure
+
+
 async def wait_before_llm_retry(attempt_number: int) -> None:
     await asyncio.sleep(LLM_RETRY_BASE_DELAY_SECONDS * attempt_number)
 
@@ -247,6 +262,31 @@ def unique_model_names(provider: ProviderFormat, models: Sequence[str]) -> list[
     return normalized_models
 
 
+def classify_provider_model_fetch_failure(
+    exception: Exception,
+) -> ProviderModelFetchFailure:
+    try:
+        import litellm
+    except Exception:
+        return ProviderModelFetchFailure.REQUEST_FAILED
+
+    if isinstance(exception, (litellm.APIConnectionError, litellm.Timeout)):
+        return ProviderModelFetchFailure.CONNECTION_FAILED
+    if isinstance(
+        exception, (litellm.AuthenticationError, litellm.PermissionDeniedError)
+    ):
+        return ProviderModelFetchFailure.ACCESS_DENIED
+    if isinstance(exception, litellm.RateLimitError):
+        return ProviderModelFetchFailure.RATE_LIMITED
+    if isinstance(
+        exception, (litellm.ServiceUnavailableError, litellm.InternalServerError)
+    ):
+        return ProviderModelFetchFailure.PROVIDER_UNAVAILABLE
+    if isinstance(exception, (ConnectionError, TimeoutError)):
+        return ProviderModelFetchFailure.CONNECTION_FAILED
+    return ProviderModelFetchFailure.REQUEST_FAILED
+
+
 def list_provider_models(
     *,
     provider: ProviderFormat,
@@ -260,12 +300,17 @@ def list_provider_models(
         configure_litellm_logging()
         model_lister = get_valid_models
 
-    models = model_lister(
-        api_base=normalize_provider_base_url(provider, base_url),
-        api_key=secret_reference,
-        check_provider_endpoint=True,
-        custom_llm_provider=provider_litellm_name(provider),
-    )
+    try:
+        models = model_lister(
+            api_base=normalize_provider_base_url(provider, base_url),
+            api_key=secret_reference,
+            check_provider_endpoint=True,
+            custom_llm_provider=provider_litellm_name(provider),
+        )
+    except Exception as exc:
+        raise ProviderModelFetchError(
+            classify_provider_model_fetch_failure(exc)
+        ) from exc
     return unique_model_names(provider, models)
 
 
@@ -300,6 +345,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),
     }