flowent 0.2.3 → 0.3.0

package/backend/src/flowent/routes/workspace.py

@@ -0,0 +1,105 @@
+import logging
+
+from fastapi import FastAPI, Query
+from fastapi.responses import StreamingResponse
+
+from flowent.api_models import (
+    WorkspaceClearResponse,
+    WorkspaceMessageEditRequest,
+    WorkspaceMessageEditResponse,
+    WorkspaceMessagesRequest,
+    WorkspaceRespondRequest,
+    WorkspaceRunResponse,
+)
+from flowent.logging import TRACE_LEVEL
+from flowent.storage import StateStore
+from flowent.workspace.runtime import WorkspaceRuntime
+
+logger = logging.getLogger("flowent.routes.workspace")
+
+
+def register_workspace_routes(
+    app: FastAPI,
+    *,
+    runtime: WorkspaceRuntime,
+    store: StateStore,
+) -> None:
+    @app.put("/api/workspace/messages")
+    async def save_workspace_messages(
+        request: WorkspaceMessagesRequest,
+    ) -> WorkspaceMessagesRequest:
+        return WorkspaceMessagesRequest(messages=store.save_messages(request.messages))
+
+    @app.post("/api/workspace/messages/{message_id}/edit")
+    async def edit_workspace_message(
+        message_id: str,
+        request: WorkspaceMessageEditRequest,
+    ) -> WorkspaceMessageEditResponse:
+        logger.info(
+            "Workspace message edit requested action=%s message_id=%s content_length=%s",
+            request.action,
+            message_id,
+            len(request.content),
+        )
+        logger.log(TRACE_LEVEL, "Workspace edited user content=%r", request.content)
+        messages, run = runtime.edit_message(
+            message_id,
+            action=request.action,
+            content=request.content,
+        )
+        return WorkspaceMessageEditResponse(
+            messages=messages,
+            run_id=run.id if run else None,
+        )
+
+    @app.post("/api/workspace/clear")
+    async def clear_workspace() -> WorkspaceClearResponse:
+        messages = runtime.clear()
+        await runtime.notify_cleared_runs()
+        return WorkspaceClearResponse(messages=messages)
+
+    @app.post("/api/workspace/runs")
+    async def start_workspace_run(
+        request: WorkspaceRespondRequest,
+    ) -> WorkspaceRunResponse:
+        logger.info("Workspace run requested content_length=%s", len(request.content))
+        logger.log(TRACE_LEVEL, "Workspace user content=%r", request.content)
+        run = runtime.create_run(request.content, message_id=request.message_id)
+        return WorkspaceRunResponse(run_id=run.id)
+
+    @app.get("/api/workspace/runs/{run_id}/stream")
+    async def stream_workspace_run(
+        run_id: str,
+        after: int = Query(default=0, ge=0),
+    ) -> StreamingResponse:
+        run = runtime.run_by_id(run_id)
+        return StreamingResponse(
+            runtime.run_stream(run, after),
+            media_type="text/event-stream",
+        )
+
+    @app.post("/api/workspace/runs/{run_id}/stop")
+    async def stop_workspace_run(run_id: str) -> dict[str, bool]:
+        runtime.stop_run(run_id)
+        return {"ok": True}
+
+    @app.post("/api/workspace/compact", response_class=StreamingResponse)
+    async def compact_workspace() -> StreamingResponse:
+        return StreamingResponse(
+            runtime.compact_stream(),
+            media_type="text/event-stream",
+        )
+
+    @app.post("/api/workspace/respond")
+    async def respond_to_workspace(
+        request: WorkspaceRespondRequest,
+    ) -> StreamingResponse:
+        logger.info(
+            "Workspace response requested content_length=%s", len(request.content)
+        )
+        logger.log(TRACE_LEVEL, "Workspace user content=%r", request.content)
+        run = runtime.create_run(request.content, message_id=request.message_id)
+        return StreamingResponse(
+            runtime.run_stream(run, include_snapshots=False),
+            media_type="text/event-stream",
+        )

package/backend/src/flowent/sandbox.py

@@ -262,7 +262,7 @@ class SandboxRunner:
             if root == self.cwd:
                 continue
             if not root.exists():
-                root.mkdir(mode=0o700, parents=True, exist_ok=True)
+                continue
             args.extend(["--bind", str(root), str(root)])
         args.extend(
             [

package/backend/src/flowent/state/__init__.py

@@ -0,0 +1,53 @@
+from flowent.state.models import (
+    StoredAssistantOutputGroup,
+    StoredCompactionCheckpoint,
+    StoredErrorOutputItem,
+    StoredMcpServer,
+    StoredMcpTool,
+    StoredMessage,
+    StoredOutputItem,
+    StoredProvider,
+    StoredSettings,
+    StoredSkill,
+    StoredState,
+    StoredTelegramBot,
+    StoredTelegramSession,
+    StoredTextOutputItem,
+    StoredThinkingOutputItem,
+    StoredToolItem,
+    StoredToolOutputItem,
+    StoredWorkflow,
+    StoredWorkflowDefinition,
+    StoredWorkflowEdge,
+    StoredWorkflowNode,
+    StoredWorkflowNodePosition,
+    StoredWritablePath,
+)
+from flowent.state.store import StateStore
+
+__all__ = [
+    "StateStore",
+    "StoredAssistantOutputGroup",
+    "StoredCompactionCheckpoint",
+    "StoredErrorOutputItem",
+    "StoredMcpServer",
+    "StoredMcpTool",
+    "StoredMessage",
+    "StoredOutputItem",
+    "StoredProvider",
+    "StoredSettings",
+    "StoredSkill",
+    "StoredState",
+    "StoredTelegramBot",
+    "StoredTelegramSession",
+    "StoredTextOutputItem",
+    "StoredThinkingOutputItem",
+    "StoredToolItem",
+    "StoredToolOutputItem",
+    "StoredWorkflow",
+    "StoredWorkflowDefinition",
+    "StoredWorkflowEdge",
+    "StoredWorkflowNode",
+    "StoredWorkflowNodePosition",
+    "StoredWritablePath",
+]

package/backend/src/flowent/state/models.py

@@ -0,0 +1,257 @@
+from typing import Annotated, Literal
+
+from pydantic import BaseModel, ConfigDict, Field, PositiveInt
+
+from flowent.llm import ChatMessage, ProviderFormat, ReasoningEffort
+from flowent.usage import TokenUsageInfo
+
+
+class StoredTelegramSession(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    chat_id: str
+    display_name: str = ""
+    recent_message: str = ""
+    status: str
+    updated_at: int = 0
+    user_id: str = ""
+    username: str = ""
+
+
+class StoredTelegramBot(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    bot_token: str
+    enabled: bool
+    error: str = ""
+    sessions: list[StoredTelegramSession] = Field(default_factory=list)
+    status: str = "disabled"
+
+
+class StoredMcpTool(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    description: str = ""
+    input_schema: dict[str, object] = Field(default_factory=dict)
+    name: str
+    output_schema: dict[str, object] | None = None
+
+
+class StoredMcpServer(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    args: list[str] = Field(default_factory=list)
+    command: str = ""
+    config: dict[str, object] = Field(default_factory=dict)
+    enabled: bool = True
+    error: str = ""
+    id: str
+    name: str
+    status: str = "disabled"
+    tools: list[StoredMcpTool] = Field(default_factory=list)
+    type: str
+    url: str = ""
+
+
+class StoredSkill(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    description: str
+    enabled: bool = True
+    error: str = ""
+    id: str
+    name: str
+    path: str
+    scope: str
+    slug: str
+
+
+class StoredWritablePath(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    created_at: int = 0
+    path: str
+
+
+class StoredWorkflowNodePosition(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    x: float = 0
+    y: float = 0
+
+
+class StoredWorkflowNode(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    data: dict[str, object] = Field(default_factory=dict)
+    description: str = ""
+    id: str
+    name: str
+    position: StoredWorkflowNodePosition = Field(
+        default_factory=StoredWorkflowNodePosition
+    )
+    type: Literal["input", "agent", "merge", "output"]
+
+
+class StoredWorkflowEdge(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    id: str
+    label: str = ""
+    source: str
+    source_handle: str = ""
+    target: str
+    target_handle: str = ""
+
+
+class StoredWorkflowDefinition(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    edges: list[StoredWorkflowEdge] = Field(default_factory=list)
+    nodes: list[StoredWorkflowNode] = Field(default_factory=list)
+    version: int = 1
+
+
+class StoredWorkflow(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    created_at: int = 0
+    definition: StoredWorkflowDefinition
+    id: str
+    name: str
+    updated_at: int = 0
+
+
+class StoredProvider(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    api_key: str
+    base_url: str
+    id: str
+    models: list[str]
+    name: str
+    type: ProviderFormat
+
+
+class StoredSettings(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    agent_prompt: str = Field(default="", exclude_if=lambda value: value == "")
+    context_window_limit: PositiveInt | None = None
+    reasoning_effort: ReasoningEffort = ReasoningEffort.DEFAULT
+    selected_model: str
+    selected_provider_id: str
+
+
+class StoredToolItem(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    id: str
+    name: str
+    status: str
+    title: str
+    arguments: dict[str, object] | None = None
+    content: str | None = None
+    data: dict[str, object] | None = None
+
+
+class StoredThinkingOutputItem(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    content: str
+    id: str
+    type: Literal["thinking"]
+
+
+class StoredTextOutputItem(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    content: str
+    id: str
+    type: Literal["text"]
+
+
+class StoredErrorOutputItem(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    detail: str = Field(default="", exclude_if=lambda value: value == "")
+    id: str
+    message: str
+    title: str
+    type: Literal["error"]
+
+
+class StoredToolOutputItem(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    id: str
+    tool: StoredToolItem
+    type: Literal["tool"]
+
+
+StoredOutputItem = Annotated[
+    StoredThinkingOutputItem
+    | StoredTextOutputItem
+    | StoredErrorOutputItem
+    | StoredToolOutputItem,
+    Field(discriminator="type"),
+]
+
+
+class StoredAssistantOutputGroup(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    id: str
+    items: list[StoredOutputItem]
+
+
+class StoredMessage(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    author: str
+    content: str
+    groups: list[StoredAssistantOutputGroup] = Field(
+        default_factory=list, exclude_if=lambda value: value == []
+    )
+    id: str
+    status: str = Field(
+        default="completed", exclude_if=lambda value: value == "completed"
+    )
+    thinking: str = Field(default="", exclude_if=lambda value: value == "")
+    tools: list[StoredToolItem] = Field(default_factory=list)
+    usage_info: TokenUsageInfo | None = Field(
+        default=None, exclude_if=lambda value: value is None
+    )
+
+
+class StoredCompactionCheckpoint(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    created_at: int = 0
+    id: str
+    method: str
+    replacement_history: list[ChatMessage]
+    source_message_id: str | None = None
+    summary: str
+    token_after: int = 0
+    token_before: int = 0
+    trigger: str
+
+
+class StoredState(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    active_run_event_index: int = 0
+    active_run_id: str | None = None
+    is_compacting: bool = False
+    mcp_servers: list[StoredMcpServer]
+    messages: list[StoredMessage]
+    providers: list[StoredProvider]
+    settings: StoredSettings
+    skills: list[StoredSkill]
+    telegram_bot: StoredTelegramBot
+    usage_info: TokenUsageInfo | None = Field(
+        default=None, exclude_if=lambda value: value is None
+    )
+    writable_paths: list[StoredWritablePath] = Field(default_factory=list)
+    workflows: list[StoredWorkflow] = Field(default_factory=list)

package/backend/src/flowent/state/schema.py

@@ -0,0 +1,186 @@
+import sqlite3
+
+
+def migrate(connection: sqlite3.Connection) -> None:
+    connection.executescript(
+        """
+        CREATE TABLE IF NOT EXISTS workflows (
+            id TEXT PRIMARY KEY,
+            name TEXT NOT NULL,
+            definition TEXT NOT NULL,
+            created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+            updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+        );
+
+        CREATE TABLE IF NOT EXISTS mcp_servers (
+            id TEXT PRIMARY KEY,
+            name TEXT NOT NULL,
+            type TEXT NOT NULL,
+            command TEXT NOT NULL DEFAULT '',
+            args TEXT NOT NULL DEFAULT '[]',
+            config TEXT NOT NULL DEFAULT '{}',
+            url TEXT NOT NULL DEFAULT '',
+            enabled INTEGER NOT NULL DEFAULT 1,
+            created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+            updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+        );
+
+        CREATE TABLE IF NOT EXISTS mcp_tools (
+            server_id TEXT NOT NULL REFERENCES mcp_servers(id) ON DELETE CASCADE,
+            name TEXT NOT NULL,
+            description TEXT NOT NULL DEFAULT '',
+            input_schema TEXT NOT NULL DEFAULT '{}',
+            output_schema TEXT,
+            position INTEGER NOT NULL,
+            PRIMARY KEY (server_id, name)
+        );
+
+        CREATE TABLE IF NOT EXISTS telegram_bot (
+            id INTEGER PRIMARY KEY CHECK (id = 1),
+            enabled INTEGER NOT NULL DEFAULT 0,
+            bot_token TEXT NOT NULL,
+            updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+        );
+
+        CREATE TABLE IF NOT EXISTS telegram_sessions (
+            chat_id TEXT PRIMARY KEY,
+            user_id TEXT NOT NULL DEFAULT '',
+            username TEXT NOT NULL DEFAULT '',
+            display_name TEXT NOT NULL DEFAULT '',
+            recent_message TEXT NOT NULL DEFAULT '',
+            status TEXT NOT NULL,
+            updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+        );
+
+        CREATE TABLE IF NOT EXISTS providers (
+            id TEXT PRIMARY KEY,
+            name TEXT NOT NULL,
+            type TEXT NOT NULL,
+            base_url TEXT NOT NULL,
+            api_key TEXT NOT NULL,
+            created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+            updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+        );
+
+        CREATE TABLE IF NOT EXISTS provider_models (
+            provider_id TEXT NOT NULL REFERENCES providers(id) ON DELETE CASCADE,
+            model TEXT NOT NULL,
+            position INTEGER NOT NULL,
+            PRIMARY KEY (provider_id, model)
+        );
+
+        CREATE TABLE IF NOT EXISTS settings (
+            id INTEGER PRIMARY KEY CHECK (id = 1),
+            selected_provider_id TEXT NOT NULL DEFAULT '',
+            selected_model TEXT NOT NULL DEFAULT '',
+            reasoning_effort TEXT NOT NULL DEFAULT 'default',
+            agent_prompt TEXT NOT NULL DEFAULT '',
+            context_window_limit INTEGER,
+            updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+        );
+
+        CREATE TABLE IF NOT EXISTS messages (
+            id TEXT PRIMARY KEY,
+            author TEXT NOT NULL,
+            content TEXT NOT NULL,
+            status TEXT NOT NULL DEFAULT 'completed',
+            usage_info TEXT,
+            position INTEGER NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS workspace_context (
+            id INTEGER PRIMARY KEY CHECK (id = 1),
+            compacted_summary TEXT NOT NULL DEFAULT '',
+            active_compaction_id TEXT,
+            is_compacting INTEGER NOT NULL DEFAULT 0,
+            usage_info TEXT,
+            updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+        );
+
+        CREATE TABLE IF NOT EXISTS compaction_checkpoints (
+            id TEXT PRIMARY KEY,
+            trigger TEXT NOT NULL,
+            method TEXT NOT NULL,
+            summary TEXT NOT NULL,
+            replacement_history TEXT NOT NULL DEFAULT '[]',
+            source_message_id TEXT,
+            token_before INTEGER NOT NULL DEFAULT 0,
+            token_after INTEGER NOT NULL DEFAULT 0,
+            created_at INTEGER NOT NULL DEFAULT (unixepoch())
+        );
+
+        CREATE TABLE IF NOT EXISTS skill_settings (
+            id TEXT PRIMARY KEY,
+            enabled INTEGER NOT NULL DEFAULT 1,
+            updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+        );
+
+        CREATE TABLE IF NOT EXISTS writable_paths (
+            path TEXT PRIMARY KEY,
+            created_at INTEGER NOT NULL DEFAULT (unixepoch())
+        );
+
+        CREATE TABLE IF NOT EXISTS schema_migrations (
+            version INTEGER PRIMARY KEY
+        );
+
+        INSERT OR IGNORE INTO schema_migrations (version) VALUES (1);
+        """
+    )
+    mcp_server_columns = table_columns(connection, "mcp_servers")
+    if "config" not in mcp_server_columns:
+        connection.execute(
+            """
+            ALTER TABLE mcp_servers
+            ADD COLUMN config TEXT NOT NULL DEFAULT '{}'
+            """
+        )
+    message_columns = table_columns(connection, "messages")
+    if "tools" not in message_columns:
+        connection.execute(
+            "ALTER TABLE messages ADD COLUMN tools TEXT NOT NULL DEFAULT '[]'"
+        )
+    if "thinking" not in message_columns:
+        connection.execute(
+            "ALTER TABLE messages ADD COLUMN thinking TEXT NOT NULL DEFAULT ''"
+        )
+    if "status" not in message_columns:
+        connection.execute(
+            "ALTER TABLE messages ADD COLUMN status TEXT NOT NULL DEFAULT 'completed'"
+        )
+    if "groups" not in message_columns:
+        connection.execute(
+            "ALTER TABLE messages ADD COLUMN groups TEXT NOT NULL DEFAULT '[]'"
+        )
+    if "usage_info" not in message_columns:
+        connection.execute("ALTER TABLE messages ADD COLUMN usage_info TEXT")
+    settings_columns = table_columns(connection, "settings")
+    if "reasoning_effort" not in settings_columns:
+        connection.execute(
+            "ALTER TABLE settings "
+            "ADD COLUMN reasoning_effort TEXT NOT NULL DEFAULT 'default'"
+        )
+    if "agent_prompt" not in settings_columns:
+        connection.execute(
+            "ALTER TABLE settings ADD COLUMN agent_prompt TEXT NOT NULL DEFAULT ''"
+        )
+    if "context_window_limit" not in settings_columns:
+        connection.execute(
+            "ALTER TABLE settings ADD COLUMN context_window_limit INTEGER"
+        )
+    workspace_context_columns = table_columns(connection, "workspace_context")
+    if "active_compaction_id" not in workspace_context_columns:
+        connection.execute(
+            "ALTER TABLE workspace_context ADD COLUMN active_compaction_id TEXT"
+        )
+    if "usage_info" not in workspace_context_columns:
+        connection.execute("ALTER TABLE workspace_context ADD COLUMN usage_info TEXT")
+    if "is_compacting" not in workspace_context_columns:
+        connection.execute(
+            "ALTER TABLE workspace_context "
+            "ADD COLUMN is_compacting INTEGER NOT NULL DEFAULT 0"
+        )
+
+
+def table_columns(connection: sqlite3.Connection, table: str) -> set[str]:
+    return {row["name"] for row in connection.execute(f"PRAGMA table_info({table})")}