flowent 0.0.7 → 0.0.10

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

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

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

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

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

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

@@ -1,146 +0,0 @@
-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",
-]