flowent 0.0.1 → 0.0.4

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

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from enum import StrEnum
+from typing import Any
+
+
+class EventType(StrEnum):
+    TAB_CREATED = "tab_created"
+    TAB_UPDATED = "tab_updated"
+    TAB_DELETED = "tab_deleted"
+    NODE_CREATED = "node_created"
+    NODE_STATE_CHANGED = "node_state_changed"
+    NODE_TODOS_CHANGED = "node_todos_changed"
+    NODE_MESSAGE = "node_message"
+    NODE_TERMINATED = "node_terminated"
+    NODE_DELETED = "node_deleted"
+    NODE_CONNECTED = "node_connected"
+    NODE_DISCONNECTED = "node_disconnected"
+    ASSISTANT_CONTENT = "assistant_content"
+    TOOL_CALLED = "tool_called"
+    HISTORY_CLEARED = "history_cleared"
+    HISTORY_REPLACED = "history_replaced"
+    HISTORY_ENTRY_ADDED = "history_entry_added"
+    HISTORY_ENTRY_DELTA = "history_entry_delta"
+
+
+DISPLAY_EVENTS: set[EventType] = {
+    EventType.TAB_CREATED,
+    EventType.TAB_UPDATED,
+    EventType.TAB_DELETED,
+    EventType.NODE_CREATED,
+    EventType.NODE_STATE_CHANGED,
+    EventType.NODE_TODOS_CHANGED,
+    EventType.NODE_MESSAGE,
+    EventType.NODE_TERMINATED,
+    EventType.NODE_DELETED,
+    EventType.NODE_CONNECTED,
+    EventType.NODE_DISCONNECTED,
+    EventType.ASSISTANT_CONTENT,
+    EventType.TOOL_CALLED,
+}
+
+
+@dataclass
+class Event:
+    type: EventType
+    agent_id: str
+    data: dict[str, Any] = field(default_factory=dict)
+    timestamp: float = field(default_factory=time.time)

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

@@ -0,0 +1,437 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from enum import StrEnum
+
+from flowent.models.agent import AgentState, NodeConfig, NodeType
+from flowent.models.history import HistoryEntry, deserialize_history_entries
+from flowent.models.todo import TodoItem
+
+
+class WorkflowNodeKind(StrEnum):
+    TRIGGER = "trigger"
+    AGENT = "agent"
+    CODE = "code"
+    IF = "if"
+    MERGE = "merge"
+
+
+class PortDirection(StrEnum):
+    INPUT = "input"
+    OUTPUT = "output"
+
+
+class EdgeKind(StrEnum):
+    CONTROL = "control"
+    DATA = "data"
+    EVENT = "event"
+
+
+@dataclass
+class NodePosition:
+    x: float
+    y: float
+
+    def serialize(self) -> dict[str, float]:
+        return {"x": self.x, "y": self.y}
+
+    @classmethod
+    def from_mapping(cls, data: dict[str, object] | None) -> NodePosition | None:
+        if not isinstance(data, dict):
+            return None
+        x = data.get("x")
+        y = data.get("y")
+        if not isinstance(x, (int, float)) or not isinstance(y, (int, float)):
+            return None
+        return cls(x=float(x), y=float(y))
+
+
+@dataclass
+class WorkflowPort:
+    key: str
+    direction: PortDirection
+    kind: EdgeKind
+    required: bool = False
+    multiple: bool = False
+
+    def serialize(self) -> dict[str, object]:
+        return {
+            "key": self.key,
+            "direction": self.direction.value,
+            "kind": self.kind.value,
+            "required": self.required,
+            "multiple": self.multiple,
+        }
+
+    @classmethod
+    def from_mapping(cls, data: dict[str, object]) -> WorkflowPort | None:
+        key = data.get("key")
+        direction = data.get("direction")
+        kind = data.get("kind")
+        if not isinstance(key, str) or not key.strip():
+            return None
+        try:
+            parsed_direction = PortDirection(str(direction))
+            parsed_kind = EdgeKind(str(kind))
+        except ValueError:
+            return None
+        return cls(
+            key=key.strip(),
+            direction=parsed_direction,
+            kind=parsed_kind,
+            required=bool(data.get("required", False)),
+            multiple=bool(data.get("multiple", False)),
+        )
+
+
+@dataclass
+class GraphEdge:
+    id: str
+    from_node_id: str
+    from_port_key: str
+    to_node_id: str
+    to_port_key: str
+    kind: EdgeKind = EdgeKind.CONTROL
+    tab_id: str | None = None
+    created_at: float = field(default_factory=time.time)
+
+    def serialize(self) -> dict[str, object]:
+        payload: dict[str, object] = {
+            "id": self.id,
+            "from_node_id": self.from_node_id,
+            "from_port_key": self.from_port_key,
+            "to_node_id": self.to_node_id,
+            "to_port_key": self.to_port_key,
+            "kind": self.kind.value,
+            "created_at": self.created_at,
+        }
+        if self.tab_id is not None:
+            payload["tab_id"] = self.tab_id
+        return payload
+
+    @classmethod
+    def from_mapping(cls, data: dict[str, object]) -> GraphEdge:
+        created_at = data.get("created_at")
+        kind = data.get("kind")
+        try:
+            parsed_kind = EdgeKind(str(kind))
+        except ValueError:
+            parsed_kind = EdgeKind.CONTROL
+        from_port_key = data.get("from_port_key")
+        to_port_key = data.get("to_port_key")
+        return cls(
+            id=str(data.get("id", "")),
+            tab_id=str(data["tab_id"]) if isinstance(data.get("tab_id"), str) else None,
+            from_node_id=str(data.get("from_node_id", "")),
+            from_port_key=(
+                str(from_port_key)
+                if isinstance(from_port_key, str) and from_port_key.strip()
+                else "out"
+            ),
+            to_node_id=str(data.get("to_node_id", "")),
+            to_port_key=(
+                str(to_port_key)
+                if isinstance(to_port_key, str) and to_port_key.strip()
+                else "in"
+            ),
+            kind=parsed_kind,
+            created_at=created_at
+            if isinstance(created_at, (int, float))
+            else time.time(),
+        )
+
+
+@dataclass
+class WorkflowNodeDefinition:
+    id: str
+    type: WorkflowNodeKind
+    config: dict[str, object] = field(default_factory=dict)
+    inputs: list[WorkflowPort] = field(default_factory=list)
+    outputs: list[WorkflowPort] = field(default_factory=list)
+
+    def serialize(self) -> dict[str, object]:
+        return {
+            "id": self.id,
+            "type": self.type.value,
+            "config": dict(self.config),
+            "inputs": [port.serialize() for port in self.inputs],
+            "outputs": [port.serialize() for port in self.outputs],
+        }
+
+    @classmethod
+    def from_mapping(
+        cls,
+        data: dict[str, object],
+    ) -> WorkflowNodeDefinition | None:
+        node_id = data.get("id")
+        node_type = data.get("type")
+        if not isinstance(node_id, str) or not node_id.strip():
+            return None
+        try:
+            parsed_type = WorkflowNodeKind(str(node_type))
+        except ValueError:
+            return None
+        raw_config = data.get("config")
+        raw_inputs = data.get("inputs")
+        raw_outputs = data.get("outputs")
+        return cls(
+            id=node_id.strip(),
+            type=parsed_type,
+            config=dict(raw_config) if isinstance(raw_config, dict) else {},
+            inputs=[
+                port
+                for port in (
+                    WorkflowPort.from_mapping(item)
+                    for item in (raw_inputs if isinstance(raw_inputs, list) else [])
+                    if isinstance(item, dict)
+                )
+                if port is not None
+            ],
+            outputs=[
+                port
+                for port in (
+                    WorkflowPort.from_mapping(item)
+                    for item in (raw_outputs if isinstance(raw_outputs, list) else [])
+                    if isinstance(item, dict)
+                )
+                if port is not None
+            ],
+        )
+
+
+@dataclass
+class WorkflowViewDefinition:
+    positions: dict[str, NodePosition] = field(default_factory=dict)
+
+    def serialize(self) -> dict[str, object]:
+        if not self.positions:
+            return {}
+        return {
+            "positions": {
+                node_id: position.serialize()
+                for node_id, position in self.positions.items()
+            }
+        }
+
+    @classmethod
+    def from_mapping(cls, data: dict[str, object] | None) -> WorkflowViewDefinition:
+        if not isinstance(data, dict):
+            return cls()
+        raw_positions = data.get("positions")
+        if not isinstance(raw_positions, dict):
+            return cls()
+        positions = {
+            str(node_id): position
+            for node_id, position in (
+                (
+                    node_id,
+                    NodePosition.from_mapping(payload),
+                )
+                for node_id, payload in raw_positions.items()
+                if isinstance(node_id, str) and isinstance(payload, dict)
+            )
+            if position is not None
+        }
+        return cls(positions=positions)
+
+
+@dataclass
+class WorkflowDefinition:
+    version: int = 1
+    nodes: list[WorkflowNodeDefinition] = field(default_factory=list)
+    edges: list[GraphEdge] = field(default_factory=list)
+    view: WorkflowViewDefinition = field(default_factory=WorkflowViewDefinition)
+
+    def serialize(self) -> dict[str, object]:
+        payload: dict[str, object] = {
+            "version": self.version,
+            "nodes": [node.serialize() for node in self.nodes],
+            "edges": [edge.serialize() for edge in self.edges],
+        }
+        serialized_view = self.view.serialize()
+        if serialized_view:
+            payload["view"] = serialized_view
+        return payload
+
+    @classmethod
+    def from_mapping(cls, data: dict[str, object] | None) -> WorkflowDefinition:
+        if not isinstance(data, dict):
+            return cls()
+        raw_version = data.get("version")
+        raw_nodes = data.get("nodes")
+        raw_edges = data.get("edges")
+        raw_view = data.get("view")
+        return cls(
+            version=raw_version
+            if isinstance(raw_version, int) and raw_version > 0
+            else 1,
+            nodes=[
+                node
+                for node in (
+                    WorkflowNodeDefinition.from_mapping(item)
+                    for item in (raw_nodes if isinstance(raw_nodes, list) else [])
+                    if isinstance(item, dict)
+                )
+                if node is not None
+            ],
+            edges=[
+                GraphEdge.from_mapping(item)
+                for item in (raw_edges if isinstance(raw_edges, list) else [])
+                if isinstance(item, dict)
+            ],
+            view=WorkflowViewDefinition.from_mapping(
+                raw_view if isinstance(raw_view, dict) else None
+            ),
+        )
+
+    def get_node(self, node_id: str) -> WorkflowNodeDefinition | None:
+        return next((node for node in self.nodes if node.id == node_id), None)
+
+
+@dataclass
+class GraphNodeRecord:
+    id: str
+    config: NodeConfig
+    state: AgentState
+    todos: list[TodoItem] = field(default_factory=list)
+    history: list[HistoryEntry] = field(default_factory=list)
+    execution_context_summary: str = ""
+    execution_context_history_cutoff: int = 0
+    position: NodePosition | None = None
+    created_at: float = field(default_factory=time.time)
+    updated_at: float = field(default_factory=time.time)
+
+    def serialize(self) -> dict[str, object]:
+        return {
+            "id": self.id,
+            "config": {
+                "node_type": self.config.node_type.value,
+                "role_name": self.config.role_name,
+                "tab_id": self.config.tab_id,
+                "name": self.config.name,
+                "tools": list(self.config.tools),
+                "write_dirs": list(self.config.write_dirs),
+                "allow_network": self.config.allow_network,
+            },
+            "state": self.state.value,
+            "todos": [item.serialize() for item in self.todos],
+            "history": [entry.serialize() for entry in self.history],
+            "execution_context_summary": self.execution_context_summary,
+            "execution_context_history_cutoff": self.execution_context_history_cutoff,
+            "position": self.position.serialize()
+            if self.position is not None
+            else None,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+        }
+
+    @classmethod
+    def from_mapping(cls, data: dict[str, object]) -> GraphNodeRecord:
+        from flowent.settings import (
+            build_assistant_write_dirs,
+            normalize_tool_names,
+        )
+
+        raw_config = data.get("config")
+        config = raw_config if isinstance(raw_config, dict) else {}
+        raw_todos = data.get("todos")
+        raw_history = data.get("history")
+        raw_execution_context_summary = data.get("execution_context_summary")
+        raw_execution_context_history_cutoff = data.get(
+            "execution_context_history_cutoff"
+        )
+        created_at = data.get("created_at")
+        updated_at = data.get("updated_at")
+        raw_state = data.get("state")
+
+        node_type = config.get("node_type")
+        try:
+            parsed_node_type = NodeType(str(node_type))
+        except ValueError:
+            parsed_node_type = NodeType.AGENT
+
+        try:
+            state = AgentState(str(raw_state))
+        except ValueError:
+            state = AgentState.INITIALIZING
+
+        todos = []
+        if isinstance(raw_todos, list):
+            todos = [
+                TodoItem(text=str(item.get("text", "")))
+                for item in raw_todos
+                if isinstance(item, dict)
+            ]
+
+        history_items: list[HistoryEntry] = []
+        if isinstance(raw_history, list):
+            history_items = deserialize_history_entries(
+                [item for item in raw_history if isinstance(item, dict)]
+            )
+        raw_position = data.get("position")
+
+        raw_write_dirs = (
+            [
+                str(item)
+                for item in config.get("write_dirs", [])
+                if isinstance(item, str)
+            ]
+            if isinstance(config.get("write_dirs"), list)
+            else []
+        )
+
+        return cls(
+            id=str(data.get("id", "")),
+            config=NodeConfig(
+                node_type=parsed_node_type,
+                role_name=(
+                    str(config["role_name"])
+                    if isinstance(config.get("role_name"), str)
+                    else None
+                ),
+                tab_id=str(config["tab_id"])
+                if isinstance(config.get("tab_id"), str)
+                else None,
+                name=str(config["name"])
+                if isinstance(config.get("name"), str)
+                else None,
+                tools=normalize_tool_names(
+                    [
+                        str(item)
+                        for item in config.get("tools", [])
+                        if isinstance(item, str)
+                    ]
+                    if isinstance(config.get("tools"), list)
+                    else []
+                ),
+                write_dirs=build_assistant_write_dirs(
+                    raw_write_dirs,
+                    field_name="write_dirs",
+                ),
+                allow_network=bool(config.get("allow_network", False)),
+            ),
+            state=state,
+            todos=todos,
+            history=history_items,
+            execution_context_summary=(
+                str(raw_execution_context_summary)
+                if isinstance(raw_execution_context_summary, str)
+                else ""
+            ),
+            execution_context_history_cutoff=(
+                raw_execution_context_history_cutoff
+                if isinstance(raw_execution_context_history_cutoff, int)
+                and raw_execution_context_history_cutoff >= 0
+                else 0
+            ),
+            position=NodePosition.from_mapping(
+                raw_position if isinstance(raw_position, dict) else None
+            ),
+            created_at=created_at
+            if isinstance(created_at, (int, float))
+            else time.time(),
+            updated_at=updated_at
+            if isinstance(updated_at, (int, float))
+            else time.time(),
+        )

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

@@ -0,0 +1,214 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from typing import Any
+
+from flowent.models.base import Serializable
+from flowent.models.content import (
+    ContentPart,
+    content_parts_to_text,
+    deserialize_content_parts,
+)
+
+
+@dataclass
+class SystemEntry(Serializable):
+    content: str
+    timestamp: float = field(default_factory=time.time)
+
+
+@dataclass
+class ReceivedMessage(Serializable):
+    from_id: str
+    parts: list[ContentPart] = field(default_factory=list)
+    content: str = ""
+    message_id: str | None = None
+    timestamp: float = field(default_factory=time.time)
+
+    def __post_init__(self) -> None:
+        if self.parts and not self.content:
+            self.content = content_parts_to_text(self.parts)
+        elif self.content and not self.parts:
+            self.parts = deserialize_content_parts(None, fallback_text=self.content)
+
+
+@dataclass
+class AssistantText(Serializable):
+    parts: list[ContentPart] = field(default_factory=list)
+    content: str = ""
+    timestamp: float = field(default_factory=time.time)
+
+    def __post_init__(self) -> None:
+        if self.parts and not self.content:
+            self.content = content_parts_to_text(self.parts)
+        elif self.content and not self.parts:
+            self.parts = deserialize_content_parts(None, fallback_text=self.content)
+
+
+@dataclass
+class SentMessage(Serializable):
+    to_id: str
+    parts: list[ContentPart] = field(default_factory=list)
+    content: str = ""
+    message_id: str | None = None
+    timestamp: float = field(default_factory=time.time)
+
+    def __post_init__(self) -> None:
+        if self.parts and not self.content:
+            self.content = content_parts_to_text(self.parts)
+        elif self.content and not self.parts:
+            self.parts = deserialize_content_parts(None, fallback_text=self.content)
+
+
+@dataclass
+class AssistantThinking(Serializable):
+    content: str
+    timestamp: float = field(default_factory=time.time)
+
+
+@dataclass
+class StateEntry(Serializable):
+    state: str
+    reason: str = ""
+    timestamp: float = field(default_factory=time.time)
+
+
+@dataclass
+class ToolCall(Serializable):
+    tool_name: str
+    tool_call_id: str
+    arguments: dict[str, Any]
+    result: str | None = None
+    streaming: bool = False
+    timestamp: float = field(default_factory=time.time)
+
+
+@dataclass
+class ErrorEntry(Serializable):
+    content: str
+    timestamp: float = field(default_factory=time.time)
+
+
+@dataclass
+class CommandResultEntry(Serializable):
+    command_name: str
+    content: str
+    include_in_context: bool = False
+    timestamp: float = field(default_factory=time.time)
+
+
+HistoryEntry = (
+    SystemEntry
+    | ReceivedMessage
+    | AssistantText
+    | SentMessage
+    | AssistantThinking
+    | StateEntry
+    | ToolCall
+    | ErrorEntry
+    | CommandResultEntry
+)
+
+
+def deserialize_history_entry(data: dict[str, Any]) -> HistoryEntry:
+    entry_type = data.get("type")
+    timestamp = data.get("timestamp")
+    timestamp_value = timestamp if isinstance(timestamp, (int, float)) else time.time()
+
+    if entry_type == "SystemEntry":
+        return SystemEntry(
+            content=str(data.get("content", "")),
+            timestamp=timestamp_value,
+        )
+    if entry_type == "ReceivedMessage":
+        parts = deserialize_content_parts(
+            data.get("parts"),
+            fallback_text=str(data.get("content", "")),
+        )
+        return ReceivedMessage(
+            from_id=str(data.get("from_id", "")),
+            parts=parts,
+            content=content_parts_to_text(parts),
+            message_id=(
+                str(data["message_id"])
+                if isinstance(data.get("message_id"), str)
+                else None
+            ),
+            timestamp=timestamp_value,
+        )
+    if entry_type == "AssistantText":
+        parts = deserialize_content_parts(
+            data.get("parts"),
+            fallback_text=str(data.get("content", "")),
+        )
+        return AssistantText(
+            parts=parts,
+            content=content_parts_to_text(parts),
+            timestamp=timestamp_value,
+        )
+    if entry_type == "SentMessage":
+        parts = deserialize_content_parts(
+            data.get("parts"),
+            fallback_text=str(data.get("content", "")),
+        )
+        to_id = (
+            str(data["to_id"])
+            if isinstance(data.get("to_id"), str)
+            else (
+                str(data["to_ids"][0])
+                if isinstance(data.get("to_ids"), list)
+                and data["to_ids"]
+                and isinstance(data["to_ids"][0], str)
+                else ""
+            )
+        )
+        return SentMessage(
+            to_id=to_id,
+            parts=parts,
+            content=content_parts_to_text(parts),
+            message_id=(
+                str(data["message_id"])
+                if isinstance(data.get("message_id"), str)
+                else None
+            ),
+            timestamp=timestamp_value,
+        )
+    if entry_type == "AssistantThinking":
+        return AssistantThinking(
+            content=str(data.get("content", "")),
+            timestamp=timestamp_value,
+        )
+    if entry_type == "StateEntry":
+        return StateEntry(
+            state=str(data.get("state", "")),
+            reason=str(data.get("reason", "")),
+            timestamp=timestamp_value,
+        )
+    if entry_type == "ToolCall":
+        arguments = data.get("arguments")
+        return ToolCall(
+            tool_name=str(data.get("tool_name", "")),
+            tool_call_id=str(data.get("tool_call_id", "")),
+            arguments=arguments if isinstance(arguments, dict) else {},
+            result=str(data["result"]) if isinstance(data.get("result"), str) else None,
+            streaming=bool(data.get("streaming", False)),
+            timestamp=timestamp_value,
+        )
+    if entry_type == "ErrorEntry":
+        return ErrorEntry(
+            content=str(data.get("content", "")),
+            timestamp=timestamp_value,
+        )
+    if entry_type == "CommandResultEntry":
+        return CommandResultEntry(
+            command_name=str(data.get("command_name", "")),
+            content=str(data.get("content", "")),
+            include_in_context=bool(data.get("include_in_context", False)),
+            timestamp=timestamp_value,
+        )
+    raise ValueError(f"Unknown history entry type: {entry_type}")
+
+
+def deserialize_history_entries(items: list[dict[str, Any]]) -> list[HistoryEntry]:
+    return [deserialize_history_entry(item) for item in items]