flowent 0.0.7 → 0.0.10

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

@@ -1,176 +0,0 @@
-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

@@ -1,164 +0,0 @@
-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)

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

@@ -1,44 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from flowent.models.base import Serializable
-
-
-@dataclass
-class ContentDelta(Serializable):
-    text: str
-
-
-@dataclass
-class ThinkingDelta(Serializable):
-    text: str
-
-
-@dataclass
-class ToolResultDelta(Serializable):
-    tool_call_id: str
-    text: str
-
-
-@dataclass
-class SentMessageDelta(Serializable):
-    message_id: str
-    to_id: str
-    text: str
-
-
-@dataclass
-class ReceivedMessageDelta(Serializable):
-    message_id: str
-    from_id: str
-    text: str
-
-
-StreamingDelta = (
-    ContentDelta
-    | ThinkingDelta
-    | ToolResultDelta
-    | SentMessageDelta
-    | ReceivedMessageDelta
-)

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

@@ -1,51 +0,0 @@
-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)