flowent 0.0.1 → 0.0.5

package/backend/src/flowent/model_metadata.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from flowent.models import ModelCapabilities, ModelInfo
+
+_STATIC_CONTEXT_WINDOWS: tuple[tuple[tuple[str, ...], int], ...] = (
+    (("gpt-5", "gpt-4.1", "gpt-4o", "o1", "o3"), 128_000),
+    (("claude-3", "claude-sonnet-4", "claude-opus-4"), 200_000),
+    (("gemini-2.5", "gemini-2.0"), 1_000_000),
+)
+_STATIC_INPUT_IMAGE_PREFIXES: tuple[str, ...] = (
+    "gpt-5",
+    "gpt-4.1",
+    "gpt-4o",
+    "claude-3",
+    "claude-sonnet-4",
+    "claude-opus-4",
+    "gemini-2.5",
+    "gemini-2.0",
+)
+_STATIC_OPENAI_RESPONSES_OUTPUT_IMAGE_PREFIXES: tuple[str, ...] = (
+    "gpt-5",
+    "gpt-4.1",
+    "gpt-4o",
+)
+
+
+def _normalize_model_id(model_id: str) -> str:
+    return model_id.strip().lower()
+
+
+def infer_model_capabilities(
+    *,
+    provider_type: str,
+    model_id: str,
+    input_image: bool | None = None,
+    output_image: bool | None = None,
+    structured_output: bool | None = None,
+) -> ModelCapabilities:
+    normalized_model_id = _normalize_model_id(model_id)
+    inferred_input_image = any(
+        normalized_model_id.startswith(prefix)
+        for prefix in _STATIC_INPUT_IMAGE_PREFIXES
+    )
+    if provider_type == "gemini":
+        inferred_input_image = True
+    inferred_output_image = False
+    if provider_type == "openai_responses":
+        inferred_output_image = any(
+            normalized_model_id.startswith(prefix)
+            for prefix in _STATIC_OPENAI_RESPONSES_OUTPUT_IMAGE_PREFIXES
+        )
+    elif provider_type == "gemini":
+        inferred_output_image = "image" in normalized_model_id
+    return ModelCapabilities(
+        input_image=inferred_input_image if input_image is None else input_image,
+        output_image=(inferred_output_image if output_image is None else output_image),
+        structured_output=False if structured_output is None else structured_output,
+    )
+
+
+def infer_context_window_tokens(
+    *,
+    provider_type: str,
+    model_id: str,
+    context_window_tokens: int | None = None,
+) -> int | None:
+    if isinstance(context_window_tokens, int) and context_window_tokens > 0:
+        return context_window_tokens
+
+    normalized_model_id = _normalize_model_id(model_id)
+    for prefixes, inferred_limit in _STATIC_CONTEXT_WINDOWS:
+        if any(normalized_model_id.startswith(prefix) for prefix in prefixes):
+            return inferred_limit
+    if provider_type == "gemini" and normalized_model_id:
+        return 1_000_000
+    return None
+
+
+def build_model_info(
+    *,
+    provider_type: str,
+    model_id: str,
+    input_image: bool | None = None,
+    output_image: bool | None = None,
+    structured_output: bool | None = None,
+    context_window_tokens: int | None = None,
+) -> ModelInfo:
+    return ModelInfo(
+        id=model_id,
+        capabilities=infer_model_capabilities(
+            provider_type=provider_type,
+            model_id=model_id,
+            input_image=input_image,
+            output_image=output_image,
+            structured_output=structured_output,
+        ),
+        context_window_tokens=infer_context_window_tokens(
+            provider_type=provider_type,
+            model_id=model_id,
+            context_window_tokens=context_window_tokens,
+        ),
+    )

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

@@ -0,0 +1,125 @@
+from flowent.models.agent import AgentState, NodeConfig, NodeType
+from flowent.models.base import Serializable
+from flowent.models.blueprint import (
+    AgentBlueprint,
+    BlueprintEdge,
+    BlueprintSlot,
+    BlueprintVersionSummary,
+)
+from flowent.models.content import (
+    ContentPart,
+    ImagePart,
+    TextPart,
+    content_parts_to_text,
+    deserialize_content_parts,
+    has_image_parts,
+    parse_content_parts_payload,
+)
+from flowent.models.delta import (
+    ContentDelta,
+    ReceivedMessageDelta,
+    SentMessageDelta,
+    StreamingDelta,
+    ThinkingDelta,
+    ToolResultDelta,
+)
+from flowent.models.event import DISPLAY_EVENTS, Event, EventType
+from flowent.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNodeRecord,
+    NodePosition,
+    PortDirection,
+    PortType,
+    WorkflowActivationState,
+    WorkflowDefinition,
+    WorkflowNodeDefinition,
+    WorkflowNodeKind,
+    WorkflowPort,
+    WorkflowViewDefinition,
+)
+from flowent.models.history import (
+    AssistantText,
+    AssistantThinking,
+    CommandResultEntry,
+    ErrorEntry,
+    HistoryEntry,
+    PortInboundEntry,
+    ReceivedMessage,
+    SentMessage,
+    SystemEntry,
+    ToolCall,
+)
+from flowent.models.llm import (
+    LLMOutputImagePart,
+    LLMOutputPart,
+    LLMOutputTextPart,
+    LLMResponse,
+    LLMUsage,
+    ModelCapabilities,
+    ModelInfo,
+    ToolCallResult,
+)
+from flowent.models.message import Message
+from flowent.models.tab import Tab
+from flowent.models.todo import TodoItem
+
+__all__ = [
+    "DISPLAY_EVENTS",
+    "AgentBlueprint",
+    "AgentState",
+    "AssistantText",
+    "AssistantThinking",
+    "BlueprintEdge",
+    "BlueprintSlot",
+    "BlueprintVersionSummary",
+    "CommandResultEntry",
+    "ContentDelta",
+    "ContentPart",
+    "EdgeKind",
+    "ErrorEntry",
+    "Event",
+    "EventType",
+    "GraphEdge",
+    "GraphNodeRecord",
+    "HistoryEntry",
+    "ImagePart",
+    "LLMOutputImagePart",
+    "LLMOutputPart",
+    "LLMOutputTextPart",
+    "LLMResponse",
+    "LLMUsage",
+    "Message",
+    "ModelCapabilities",
+    "ModelInfo",
+    "NodeConfig",
+    "NodePosition",
+    "NodeType",
+    "PortDirection",
+    "PortInboundEntry",
+    "PortType",
+    "ReceivedMessage",
+    "ReceivedMessageDelta",
+    "SentMessage",
+    "SentMessageDelta",
+    "Serializable",
+    "StreamingDelta",
+    "SystemEntry",
+    "Tab",
+    "TextPart",
+    "ThinkingDelta",
+    "TodoItem",
+    "ToolCall",
+    "ToolCallResult",
+    "ToolResultDelta",
+    "WorkflowActivationState",
+    "WorkflowDefinition",
+    "WorkflowNodeDefinition",
+    "WorkflowNodeKind",
+    "WorkflowPort",
+    "WorkflowViewDefinition",
+    "content_parts_to_text",
+    "deserialize_content_parts",
+    "has_image_parts",
+    "parse_content_parts_payload",
+]

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

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import StrEnum
+
+
+class NodeType(StrEnum):
+    ASSISTANT = "assistant"
+    AGENT = "agent"
+    LLM = "llm"
+    TRIGGER = "trigger"
+    CODE = "code"
+    IF = "if"
+    MERGE = "merge"
+
+
+class AgentState(StrEnum):
+    INITIALIZING = "initializing"
+    IDLE = "idle"
+    SLEEPING = "sleeping"
+    RUNNING = "running"
+    ERROR = "error"
+    TERMINATED = "terminated"
+
+
+@dataclass
+class NodeConfig:
+    node_type: NodeType
+    role_name: str | None = None
+    tab_id: str | None = None
+    name: str | None = None
+    tools: list[str] = field(default_factory=list)
+    write_dirs: list[str] = field(default_factory=list)
+    allow_network: bool = False

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

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class Serializable:
+    def serialize(self) -> dict[str, Any]:
+        fields: dict[str, Any] = {}
+        for k, v in self.__dict__.items():
+            if k.startswith("_"):
+                continue
+            if isinstance(v, Serializable):
+                fields[k] = v.serialize()
+            elif isinstance(v, list):
+                fields[k] = [
+                    item.serialize() if isinstance(item, Serializable) else item
+                    for item in v
+                ]
+            else:
+                fields[k] = v
+        fields["type"] = self.__class__.__name__
+        return fields

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

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+
+
+@dataclass
+class BlueprintSlot:
+    id: str
+    role_name: str
+    display_name: str | None = None
+
+    def serialize(self) -> dict[str, object]:
+        return {
+            "id": self.id,
+            "role_name": self.role_name,
+            "display_name": self.display_name,
+        }
+
+    @classmethod
+    def from_mapping(cls, data: dict[str, object]) -> BlueprintSlot | None:
+        slot_id = data.get("id")
+        role_name = data.get("role_name")
+        if not isinstance(slot_id, str) or not slot_id.strip():
+            return None
+        if not isinstance(role_name, str) or not role_name.strip():
+            return None
+        raw_display_name = data.get("display_name")
+        return cls(
+            id=slot_id.strip(),
+            role_name=role_name.strip(),
+            display_name=(
+                raw_display_name.strip()
+                if isinstance(raw_display_name, str) and raw_display_name.strip()
+                else None
+            ),
+        )
+
+
+@dataclass
+class BlueprintEdge:
+    from_slot_id: str
+    to_slot_id: str
+
+    def serialize(self) -> dict[str, object]:
+        return {
+            "from_slot_id": self.from_slot_id,
+            "to_slot_id": self.to_slot_id,
+        }
+
+    @classmethod
+    def from_mapping(cls, data: dict[str, object]) -> BlueprintEdge | None:
+        from_slot_id = data.get("from_slot_id")
+        to_slot_id = data.get("to_slot_id")
+        if not isinstance(from_slot_id, str) or not from_slot_id.strip():
+            return None
+        if not isinstance(to_slot_id, str) or not to_slot_id.strip():
+            return None
+        return cls(
+            from_slot_id=from_slot_id.strip(),
+            to_slot_id=to_slot_id.strip(),
+        )
+
+
+@dataclass
+class BlueprintVersionSummary:
+    version: int
+    updated_at: float
+
+    def serialize(self) -> dict[str, object]:
+        return {
+            "version": self.version,
+            "updated_at": self.updated_at,
+        }
+
+    @classmethod
+    def from_mapping(
+        cls,
+        data: dict[str, object],
+    ) -> BlueprintVersionSummary | None:
+        version = data.get("version")
+        updated_at = data.get("updated_at")
+        if not isinstance(version, int) or version <= 0:
+            return None
+        if not isinstance(updated_at, (int, float)):
+            return None
+        return cls(version=version, updated_at=updated_at)
+
+
+@dataclass
+class AgentBlueprint:
+    id: str
+    name: str
+    description: str = ""
+    version: int = 1
+    slots: list[BlueprintSlot] = field(default_factory=list)
+    edges: list[BlueprintEdge] = field(default_factory=list)
+    created_at: float = field(default_factory=time.time)
+    updated_at: float = field(default_factory=time.time)
+    version_history: list[BlueprintVersionSummary] = field(default_factory=list)
+
+    def serialize(self) -> dict[str, object]:
+        return {
+            "id": self.id,
+            "name": self.name,
+            "description": self.description,
+            "version": self.version,
+            "slots": [slot.serialize() for slot in self.slots],
+            "edges": [edge.serialize() for edge in self.edges],
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "version_history": [item.serialize() for item in self.version_history],
+        }
+
+    @classmethod
+    def from_mapping(cls, data: dict[str, object]) -> AgentBlueprint:
+        created_at = data.get("created_at")
+        updated_at = data.get("updated_at")
+        raw_slots = data.get("slots")
+        raw_edges = data.get("edges")
+        raw_version_history = data.get("version_history")
+        slots = [
+            slot
+            for slot in (
+                BlueprintSlot.from_mapping(item)
+                for item in (raw_slots if isinstance(raw_slots, list) else [])
+                if isinstance(item, dict)
+            )
+            if slot is not None
+        ]
+        edges = [
+            edge
+            for edge in (
+                BlueprintEdge.from_mapping(item)
+                for item in (raw_edges if isinstance(raw_edges, list) else [])
+                if isinstance(item, dict)
+            )
+            if edge is not None
+        ]
+        raw_version = data.get("version")
+        normalized_created_at = (
+            created_at if isinstance(created_at, (int, float)) else time.time()
+        )
+        normalized_updated_at = (
+            updated_at if isinstance(updated_at, (int, float)) else time.time()
+        )
+        version = raw_version if isinstance(raw_version, int) and raw_version > 0 else 1
+        version_history = [
+            item
+            for item in (
+                BlueprintVersionSummary.from_mapping(entry)
+                for entry in (
+                    raw_version_history if isinstance(raw_version_history, list) else []
+                )
+                if isinstance(entry, dict)
+            )
+            if item is not None
+        ]
+        if not version_history:
+            version_history = [
+                BlueprintVersionSummary(
+                    version=version,
+                    updated_at=normalized_updated_at,
+                )
+            ]
+        return cls(
+            id=str(data.get("id", "")),
+            name=str(data.get("name", "")),
+            description=str(data.get("description", "")),
+            version=version,
+            slots=slots,
+            edges=edges,
+            created_at=normalized_created_at,
+            updated_at=normalized_updated_at,
+            version_history=version_history,
+        )

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

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from flowent.models.base import Serializable
+
+
+@dataclass
+class TextPart(Serializable):
+    text: str
+
+    def serialize(self) -> dict[str, Any]:
+        return {"type": "text", "text": self.text}
+
+
+@dataclass
+class ImagePart(Serializable):
+    asset_id: str
+    mime_type: str | None = None
+    width: int | None = None
+    height: int | None = None
+    alt: str | None = None
+
+    def serialize(self) -> dict[str, Any]:
+        return {
+            "type": "image",
+            "asset_id": self.asset_id,
+            "mime_type": self.mime_type,
+            "width": self.width,
+            "height": self.height,
+            "alt": self.alt,
+        }
+
+
+ContentPart = TextPart | ImagePart
+
+
+def fallback_text_parts(content: str | None) -> list[ContentPart]:
+    if not isinstance(content, str) or not content:
+        return []
+    return [TextPart(text=content)]
+
+
+def deserialize_content_parts(
+    raw_parts: Any,
+    *,
+    fallback_text: str | None = None,
+) -> list[ContentPart]:
+    if not isinstance(raw_parts, list):
+        return fallback_text_parts(fallback_text)
+
+    parts: list[ContentPart] = []
+    for raw_part in raw_parts:
+        if not isinstance(raw_part, dict):
+            continue
+        part_type = raw_part.get("type")
+        if part_type == "TextPart":
+            part_type = "text"
+        if part_type == "ImagePart":
+            part_type = "image"
+
+        if part_type == "text":
+            text = raw_part.get("text")
+            if isinstance(text, str):
+                parts.append(TextPart(text=text))
+            continue
+
+        if part_type == "image":
+            asset_id = raw_part.get("asset_id")
+            if not isinstance(asset_id, str) or not asset_id:
+                continue
+            width = raw_part.get("width")
+            height = raw_part.get("height")
+            parts.append(
+                ImagePart(
+                    asset_id=asset_id,
+                    mime_type=(
+                        str(raw_part["mime_type"])
+                        if isinstance(raw_part.get("mime_type"), str)
+                        else None
+                    ),
+                    width=width if isinstance(width, int) else None,
+                    height=height if isinstance(height, int) else None,
+                    alt=(
+                        str(raw_part["alt"])
+                        if isinstance(raw_part.get("alt"), str)
+                        else None
+                    ),
+                )
+            )
+
+    if parts:
+        return parts
+    return fallback_text_parts(fallback_text)
+
+
+def parse_content_parts_payload(raw_parts: Any) -> list[ContentPart]:
+    if not isinstance(raw_parts, list) or not raw_parts:
+        raise ValueError("send.parts must be a non-empty array")
+
+    parts: list[ContentPart] = []
+    for index, raw_part in enumerate(raw_parts):
+        if not isinstance(raw_part, dict):
+            raise ValueError(f"send.parts[{index}] must be an object")
+
+        part_type = raw_part.get("type")
+        if part_type == "text":
+            text = raw_part.get("text")
+            if not isinstance(text, str):
+                raise ValueError(f"send.parts[{index}].text must be a string")
+            parts.append(TextPart(text=text))
+            continue
+
+        if part_type == "image":
+            asset_id = raw_part.get("asset_id")
+            if not isinstance(asset_id, str) or not asset_id:
+                raise ValueError(
+                    f"send.parts[{index}].asset_id must be a non-empty string"
+                )
+            width = raw_part.get("width")
+            height = raw_part.get("height")
+            if width is not None and not isinstance(width, int):
+                raise ValueError(f"send.parts[{index}].width must be an integer")
+            if height is not None and not isinstance(height, int):
+                raise ValueError(f"send.parts[{index}].height must be an integer")
+            mime_type = raw_part.get("mime_type")
+            if mime_type is not None and not isinstance(mime_type, str):
+                raise ValueError(f"send.parts[{index}].mime_type must be a string")
+            alt = raw_part.get("alt")
+            if alt is not None and not isinstance(alt, str):
+                raise ValueError(f"send.parts[{index}].alt must be a string")
+            parts.append(
+                ImagePart(
+                    asset_id=asset_id,
+                    mime_type=mime_type,
+                    width=width,
+                    height=height,
+                    alt=alt,
+                )
+            )
+            continue
+
+        raise ValueError(f"send.parts[{index}].type must be either `text` or `image`")
+
+    return parts
+
+
+def content_parts_to_text(parts: list[ContentPart]) -> str:
+    text_parts: list[str] = []
+    for part in parts:
+        if isinstance(part, TextPart):
+            text_parts.append(part.text)
+            continue
+        if isinstance(part, ImagePart):
+            if part.alt:
+                text_parts.append(f"[image: {part.alt}]")
+            else:
+                text_parts.append("[image]")
+    return "".join(text_parts)
+
+
+def has_image_parts(parts: list[ContentPart]) -> bool:
+    return any(isinstance(part, ImagePart) for part in parts)