flowent 0.2.4 → 0.3.0

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})")}