flowent 0.0.6 → 0.0.10

package/backend/src/flowent/model_metadata.py

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

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

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

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

@@ -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)