flowent 0.0.1 → 0.0.5

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

@@ -0,0 +1,272 @@
+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
+    from_output_port_key: str | None = None
+    to_input_port_key: str | None = None
+    value_summary: 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
+    from_output_port_key: str | None = None
+    to_input_port_key: str | None = None
+    value_summary: 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 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)
+
+
+@dataclass
+class PortInboundEntry(Serializable):
+    from_id: str
+    from_output_port_key: str
+    to_input_port_key: str
+    port_type: str
+    value: Any
+    source_label: str | None = None
+    value_summary: str | None = None
+    timestamp: float = field(default_factory=time.time)
+
+
+HistoryEntry = (
+    SystemEntry
+    | ReceivedMessage
+    | AssistantText
+    | SentMessage
+    | AssistantThinking
+    | ToolCall
+    | ErrorEntry
+    | CommandResultEntry
+    | PortInboundEntry
+)
+
+
+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
+            ),
+            from_output_port_key=(
+                str(data["from_output_port_key"])
+                if isinstance(data.get("from_output_port_key"), str)
+                else None
+            ),
+            to_input_port_key=(
+                str(data["to_input_port_key"])
+                if isinstance(data.get("to_input_port_key"), str)
+                else None
+            ),
+            value_summary=(
+                str(data["value_summary"])
+                if isinstance(data.get("value_summary"), 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
+            ),
+            from_output_port_key=(
+                str(data["from_output_port_key"])
+                if isinstance(data.get("from_output_port_key"), str)
+                else None
+            ),
+            to_input_port_key=(
+                str(data["to_input_port_key"])
+                if isinstance(data.get("to_input_port_key"), str)
+                else None
+            ),
+            value_summary=(
+                str(data["value_summary"])
+                if isinstance(data.get("value_summary"), str)
+                else None
+            ),
+            timestamp=timestamp_value,
+        )
+    if entry_type == "AssistantThinking":
+        return AssistantThinking(
+            content=str(data.get("content", "")),
+            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,
+        )
+    if entry_type == "PortInboundEntry":
+        return PortInboundEntry(
+            from_id=str(data.get("from_id", "")),
+            from_output_port_key=str(data.get("from_output_port_key", "")),
+            to_input_port_key=str(data.get("to_input_port_key", "")),
+            port_type=str(data.get("port_type", "")),
+            value=data.get("value"),
+            source_label=(
+                str(data["source_label"])
+                if isinstance(data.get("source_label"), str)
+                else None
+            ),
+            value_summary=(
+                str(data["value_summary"])
+                if isinstance(data.get("value_summary"), str)
+                else None
+            ),
+            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
+        if item.get("type") != "StateEntry"
+    ]

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

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class ModelCapabilities:
+    input_image: bool = False
+    output_image: bool = False
+    structured_output: bool = False
+
+
+@dataclass
+class ModelInfo:
+    id: str
+    capabilities: ModelCapabilities = field(default_factory=ModelCapabilities)
+    context_window_tokens: int | None = None
+
+
+@dataclass
+class LLMUsage:
+    total_tokens: int
+    input_tokens: int | None = None
+    output_tokens: int | None = None
+    cached_input_tokens: int | None = None
+    cache_read_tokens: int | None = None
+    cache_write_tokens: int | None = None
+    details: dict[str, int] = field(default_factory=dict)
+
+
+@dataclass
+class ToolCallResult:
+    id: str
+    name: str
+    arguments: dict[str, Any]
+
+
+@dataclass
+class LLMOutputTextPart:
+    text: str
+
+
+@dataclass
+class LLMOutputImagePart:
+    data: bytes
+    mime_type: str
+    width: int | None = None
+    height: int | None = None
+
+
+LLMOutputPart = LLMOutputTextPart | LLMOutputImagePart
+
+
+@dataclass
+class LLMResponse:
+    content: str | None = None
+    parts: list[LLMOutputPart] | None = None
+    tool_calls: list[ToolCallResult] | None = None
+    thinking: str | None = None
+    usage: LLMUsage | None = None
+    raw_usage: dict[str, Any] | None = None

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

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+
+from flowent.models.content import (
+    ContentPart,
+    content_parts_to_text,
+    deserialize_content_parts,
+)
+
+
+@dataclass
+class Message:
+    from_id: str
+    to_id: str
+    parts: list[ContentPart] = field(default_factory=list)
+    content: str = ""
+    message_id: str | None = None
+    history_recorded: bool = False
+    from_output_port_key: str | None = None
+    to_input_port_key: str | None = None
+    port_type: str | None = None
+    value: object | None = None
+    value_summary: str | None = None
+    port_inbound_recorded: bool = False
+    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)

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

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+
+from flowent.models.graph import WorkflowActivationState, WorkflowDefinition
+
+
+@dataclass
+class Tab:
+    id: str
+    title: str
+    leader_id: str | None = None
+    definition: WorkflowDefinition = field(default_factory=WorkflowDefinition)
+    activation_state: WorkflowActivationState = WorkflowActivationState.INACTIVE
+    allow_network: bool = False
+    write_dirs: list[str] = field(default_factory=list)
+    permissions_initialized: bool = False
+    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,
+            "title": self.title,
+            "leader_id": self.leader_id,
+            "definition": self.definition.serialize(),
+            "activation_state": self.activation_state.value,
+            "allow_network": self.allow_network,
+            "write_dirs": list(self.write_dirs),
+            "permissions_initialized": self.permissions_initialized,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+        }
+
+    @classmethod
+    def from_mapping(cls, data: dict[str, object]) -> Tab:
+        from flowent.settings import build_assistant_write_dirs
+
+        created_at = data.get("created_at")
+        updated_at = data.get("updated_at")
+        raw_definition = data.get("definition")
+        raw_activation_state = data.get("activation_state")
+        raw_permissions_initialized = data.get("permissions_initialized")
+        raw_write_dirs_value = data.get("write_dirs")
+        raw_write_dirs = (
+            [item for item in raw_write_dirs_value if isinstance(item, str)]
+            if isinstance(raw_write_dirs_value, list)
+            else []
+        )
+        try:
+            write_dirs = build_assistant_write_dirs(
+                raw_write_dirs,
+                field_name="write_dirs",
+            )
+        except ValueError:
+            write_dirs = []
+        try:
+            activation_state = WorkflowActivationState(str(raw_activation_state))
+        except ValueError:
+            activation_state = WorkflowActivationState.INACTIVE
+        return cls(
+            id=str(data.get("id", "")),
+            title=str(data.get("title", "")),
+            leader_id=str(data["leader_id"])
+            if isinstance(data.get("leader_id"), str)
+            else None,
+            definition=WorkflowDefinition.from_mapping(
+                raw_definition if isinstance(raw_definition, dict) else None
+            ),
+            activation_state=activation_state,
+            allow_network=bool(data.get("allow_network", False)),
+            write_dirs=write_dirs,
+            permissions_initialized=(
+                bool(raw_permissions_initialized)
+                or "allow_network" in data
+                or "write_dirs" in data
+            ),
+            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/todo.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from flowent.models.base import Serializable
+
+
+@dataclass
+class TodoItem(Serializable):
+    text: str

package/backend/src/flowent/network.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Any, Literal
+
+from curl_cffi.requests import AsyncSession, Session
+from curl_cffi.requests.exceptions import RequestException
+
+DEFAULT_BROWSER_IMPERSONATE: Literal["chrome"] = "chrome"
+
+
+def create_http_session(
+    *,
+    timeout: float,
+    impersonate_browser: bool = False,
+) -> Session:
+    kwargs: dict[str, Any] = {"timeout": timeout}
+    if impersonate_browser:
+        kwargs["impersonate"] = DEFAULT_BROWSER_IMPERSONATE
+    return Session(**kwargs)
+
+
+def create_async_http_session(
+    *,
+    timeout: float,
+    impersonate_browser: bool = False,
+) -> AsyncSession:
+    kwargs: dict[str, Any] = {"timeout": timeout}
+    if impersonate_browser:
+        kwargs["impersonate"] = DEFAULT_BROWSER_IMPERSONATE
+    return AsyncSession(**kwargs)
+
+
+def is_success_status(status_code: int) -> bool:
+    return 200 <= status_code < 300
+
+
+def iter_response_lines(response: Any) -> Iterator[str]:
+    for line in response.iter_lines():
+        normalized = _decode_to_text(line)
+        if normalized:
+            yield normalized
+
+
+def iter_response_text(response: Any) -> Iterator[str]:
+    iter_text = getattr(response, "iter_text", None)
+    if callable(iter_text):
+        for chunk in iter_text():
+            normalized = _decode_to_text(chunk)
+            if normalized:
+                yield normalized
+        return
+
+    for chunk in response.iter_content():
+        normalized = _decode_to_text(chunk)
+        if normalized:
+            yield normalized
+
+
+def read_response_text(response: Any) -> str:
+    text = getattr(response, "text", None)
+    if isinstance(text, str) and text:
+        return text
+
+    content = getattr(response, "content", None)
+    if isinstance(content, str) and content:
+        return content
+    if isinstance(content, (bytes, bytearray)) and content:
+        return bytes(content).decode("utf-8", errors="replace")
+
+    iter_text = getattr(response, "iter_text", None)
+    if callable(iter_text):
+        chunks = [_decode_to_text(chunk) for chunk in iter_text()]
+        if chunks:
+            return "".join(chunks)
+
+    iter_content = getattr(response, "iter_content", None)
+    if callable(iter_content):
+        chunks = [_decode_to_text(chunk) for chunk in iter_content()]
+        if chunks:
+            return "".join(chunks)
+
+    read = getattr(response, "read", None)
+    if callable(read):
+        payload = read()
+        if isinstance(payload, str):
+            return payload
+        if isinstance(payload, (bytes, bytearray)):
+            return bytes(payload).decode("utf-8", errors="replace")
+
+    return ""
+
+
+def get_response_header(response: Any, header_name: str) -> str | None:
+    headers = getattr(response, "headers", None)
+    if headers is None:
+        return None
+    getter = getattr(headers, "get", None)
+    if callable(getter):
+        value = getter(header_name)
+        if isinstance(value, str):
+            return value
+    if isinstance(headers, dict):
+        value = headers.get(header_name) or headers.get(header_name.lower())
+        if isinstance(value, str):
+            return value
+    return None
+
+
+def response_looks_like_html(response: Any) -> bool:
+    content_type = get_response_header(response, "content-type")
+    if not isinstance(content_type, str):
+        return False
+    normalized = content_type.lower()
+    return "text/html" in normalized or "application/xhtml+xml" in normalized
+
+
+def truncate_text(text: str, limit: int = 500) -> str:
+    if len(text) <= limit:
+        return text
+    return text[:limit]
+
+
+def _decode_to_text(value: Any) -> str:
+    if isinstance(value, str):
+        return value
+    if isinstance(value, (bytes, bytearray)):
+        return bytes(value).decode("utf-8", errors="replace")
+    return str(value)
+
+
+__all__ = [
+    "DEFAULT_BROWSER_IMPERSONATE",
+    "AsyncSession",
+    "RequestException",
+    "Session",
+    "create_async_http_session",
+    "create_http_session",
+    "get_response_header",
+    "is_success_status",
+    "iter_response_lines",
+    "iter_response_text",
+    "read_response_text",
+    "response_looks_like_html",
+    "truncate_text",
+]