flowent 0.2.3 → 0.3.0

package/backend/src/flowent/workspace/events.py

@@ -0,0 +1,180 @@
+import asyncio
+import copy
+import json
+from dataclasses import dataclass, field
+from typing import Literal
+from uuid import uuid4
+
+from flowent.storage import StoredMessage
+
+
+@dataclass
+class WorkspaceRun:
+    condition: asyncio.Condition
+    active_output: Literal["text", "thinking"] | None = None
+    discard_on_cancel: bool = False
+    events: list[tuple[int, str, dict[str, object]]] = field(default_factory=list)
+    generation: int = 0
+    id: str = field(default_factory=lambda: str(uuid4()))
+    is_done: bool = False
+    latest_snapshot: StoredMessage | None = None
+    task: asyncio.Task[None] | None = None
+
+    @property
+    def latest_event_index(self) -> int:
+        return self.events[-1][0] if self.events else 0
+
+
+def stream_event(
+    event: str, data: dict[str, object], event_id: int | None = None
+) -> str:
+    id_line = f"id: {event_id}\n" if event_id is not None else ""
+    return f"{id_line}event: {event}\ndata: {json.dumps(data)}\n\n"
+
+
+def stream_message_data(
+    message: StoredMessage, active_output: Literal["text", "thinking"] | None = None
+) -> dict[str, object]:
+    data = {**message.model_dump(), "status": message.status}
+    if active_output is not None:
+        data["active_output"] = active_output
+    return data
+
+
+def append_or_replace_message(
+    messages: list[StoredMessage], message: StoredMessage
+) -> list[StoredMessage]:
+    return [
+        *(current for current in messages if current.id != message.id),
+        message,
+    ]
+
+
+def run_snapshot_data_at(
+    run: WorkspaceRun, event_index: int
+) -> dict[str, object] | None:
+    snapshot_event_index = 0
+    snapshot: dict[str, object] | None = None
+    for current_event_index, event, data in run.events:
+        if current_event_index > event_index:
+            break
+        if event != "snapshot":
+            if event == "start" and snapshot is None:
+                assistant_id = data.get("id")
+                if isinstance(assistant_id, str):
+                    snapshot_event_index = current_event_index
+                    snapshot = {
+                        "author": "assistant",
+                        "content": "",
+                        "groups": [],
+                        "id": assistant_id,
+                        "status": "running",
+                        "tools": [],
+                    }
+            continue
+        message = data.get("message")
+        if isinstance(message, dict):
+            snapshot_event_index = current_event_index
+            snapshot = copy.deepcopy(message)
+    if snapshot is None:
+        return None
+    for current_event_index, event, data in run.events:
+        if current_event_index <= snapshot_event_index:
+            continue
+        if current_event_index > event_index:
+            break
+        apply_stream_event_to_snapshot(snapshot, event, data)
+    return snapshot
+
+
+def apply_stream_event_to_snapshot(
+    snapshot: dict[str, object], event: str, data: dict[str, object]
+) -> None:
+    if event == "output_start":
+        snapshot.pop("active_output", None)
+        index = data.get("index")
+        if isinstance(index, int):
+            append_snapshot_group(snapshot, index)
+    if event == "delta":
+        append_snapshot_text(snapshot, str(data.get("content") or ""))
+    if event == "thinking_delta":
+        append_snapshot_thinking(snapshot, str(data.get("content") or ""))
+    if event == "output_done":
+        snapshot.pop("active_output", None)
+
+
+def snapshot_groups(snapshot: dict[str, object]) -> list[dict[str, object]]:
+    groups = snapshot.get("groups")
+    if not isinstance(groups, list):
+        groups = []
+        snapshot["groups"] = groups
+    return groups
+
+
+def append_snapshot_group(
+    snapshot: dict[str, object], index: int | None = None
+) -> None:
+    groups = snapshot_groups(snapshot)
+    assistant_id = str(snapshot.get("id") or "assistant")
+    group_index = index if index is not None else len(groups) + 1
+    group_id = f"{assistant_id}-group-{group_index}"
+    if groups and groups[-1].get("id") == group_id:
+        return
+    groups.append({"id": group_id, "items": []})
+
+
+def append_snapshot_text(snapshot: dict[str, object], content: str) -> None:
+    if not content:
+        return
+    snapshot["active_output"] = "text"
+    snapshot["content"] = f"{snapshot.get('content') or ''}{content}"
+    append_snapshot_item_content(snapshot, content, "text")
+
+
+def append_snapshot_thinking(snapshot: dict[str, object], content: str) -> None:
+    if not content:
+        return
+    snapshot["active_output"] = "thinking"
+    snapshot["thinking"] = f"{snapshot.get('thinking') or ''}{content}"
+    append_snapshot_item_content(snapshot, content, "thinking")
+
+
+def append_snapshot_item_content(
+    snapshot: dict[str, object], content: str, item_type: Literal["text", "thinking"]
+) -> None:
+    groups = snapshot_groups(snapshot)
+    if not groups:
+        append_snapshot_group(snapshot)
+    group = groups[-1]
+    items = group.get("items")
+    if not isinstance(items, list):
+        items = []
+        group["items"] = items
+    item = next(
+        (
+            current
+            for current in reversed(items)
+            if isinstance(current, dict) and current.get("type") == item_type
+        ),
+        None,
+    )
+    if item is None:
+        assistant_id = str(snapshot.get("id") or "assistant")
+        snapshot_item_count = 0
+        for current_group in groups:
+            current_items = current_group.get("items")
+            if not isinstance(current_items, list):
+                continue
+            snapshot_item_count += sum(
+                1
+                for current_item in current_items
+                if isinstance(current_item, dict)
+                and current_item.get("type") == item_type
+            )
+        item = {
+            "content": "",
+            "id": f"{assistant_id}-{item_type}-{snapshot_item_count + 1}",
+            "type": item_type,
+        }
+        items.append(item)
+    item["content"] = f"{item.get('content') or ''}{content}"

package/backend/src/flowent/workspace/output.py

@@ -0,0 +1,274 @@
+from collections.abc import Sequence
+from typing import Literal
+
+from flowent.approval import ApprovalTranscriptEntry
+from flowent.logging import redact_diagnostic_value
+from flowent.storage import (
+    StoredAssistantOutputGroup,
+    StoredErrorOutputItem,
+    StoredMessage,
+    StoredTextOutputItem,
+    StoredThinkingOutputItem,
+    StoredToolItem,
+    StoredToolOutputItem,
+)
+
+APPROVAL_TRANSCRIPT_MESSAGE_LIMIT = 12
+APPROVAL_TRANSCRIPT_TEXT_LIMIT = 2_000
+USER_VISIBLE_RUN_ERROR_TITLE = "Request failed"
+USER_VISIBLE_RUN_ERROR_MESSAGE = "Check the model connection settings and try again."
+USER_VISIBLE_CONTEXT_OPTIMIZATION_ERROR_MESSAGE = "Context could not be optimized."
+EMPTY_MODEL_RESPONSE_DETAIL = "The model did not return a response."
+
+
+def user_visible_run_error_message(detail: str) -> str:
+    if detail.strip() == USER_VISIBLE_CONTEXT_OPTIMIZATION_ERROR_MESSAGE:
+        return USER_VISIBLE_CONTEXT_OPTIMIZATION_ERROR_MESSAGE
+    return USER_VISIBLE_RUN_ERROR_MESSAGE
+
+
+def run_error_output_item(
+    assistant_id: str,
+    detail: str,
+    index: int = 1,
+) -> StoredErrorOutputItem:
+    redacted_detail = redact_diagnostic_value(detail.strip())
+    message = user_visible_run_error_message(redacted_detail)
+    return StoredErrorOutputItem(
+        detail="" if redacted_detail == message else redacted_detail,
+        id=f"{assistant_id}-error-{index}",
+        message=message,
+        title=USER_VISIBLE_RUN_ERROR_TITLE,
+        type="error",
+    )
+
+
+def run_error_event_data(error: StoredErrorOutputItem) -> dict[str, object]:
+    return {
+        "error": error.model_dump(exclude_none=True),
+        "message": error.message,
+    }
+
+
+def message_error_items(message: StoredMessage) -> list[StoredErrorOutputItem]:
+    return [
+        item for group in message.groups for item in group.items if item.type == "error"
+    ]
+
+
+def error_context_summary(error: StoredErrorOutputItem) -> str:
+    parts = [f"Previous response failed: {error.title}.", error.message]
+    if error.detail and error.detail != error.message:
+        parts.append(f"Detail: {error.detail}")
+    return " ".join(part.strip() for part in parts if part.strip())
+
+
+def approval_transcript_text(content: str | None) -> str:
+    text = (content or "").strip()
+    if len(text) <= APPROVAL_TRANSCRIPT_TEXT_LIMIT:
+        return text
+    return f"{text[:APPROVAL_TRANSCRIPT_TEXT_LIMIT]}\n[truncated]"
+
+
+def approval_transcript(
+    messages: Sequence[StoredMessage],
+) -> list[ApprovalTranscriptEntry]:
+    entries: list[ApprovalTranscriptEntry] = []
+    for message in messages[-APPROVAL_TRANSCRIPT_MESSAGE_LIMIT:]:
+        if message.author in ("user", "assistant"):
+            role: Literal["user", "assistant"] = (
+                "user" if message.author == "user" else "assistant"
+            )
+            content = approval_transcript_text(message.content)
+            if content:
+                entries.append(ApprovalTranscriptEntry(role=role, content=content))
+            for tool in message.tools:
+                tool_content = approval_transcript_text(tool.content)
+                if tool_content:
+                    entries.append(
+                        ApprovalTranscriptEntry(
+                            role="tool",
+                            content=tool_content,
+                            name=tool.name,
+                        )
+                    )
+    return entries
+
+
+class AssistantOutputBuilder:
+    def __init__(self, assistant_id: str = "") -> None:
+        self.assistant_id = assistant_id
+        self.content = ""
+        self.groups: list[StoredAssistantOutputGroup] = []
+        self.text_item_index = 0
+        self.text_item_id = ""
+        self.thinking = ""
+        self.thinking_item_index = 0
+        self.thinking_item_id = ""
+        self.error_item_index = 0
+        self.tools: dict[str, StoredToolItem] = {}
+
+    def set_assistant_id(self, assistant_id: str) -> None:
+        self.assistant_id = assistant_id
+
+    def start_group(self, index: int) -> None:
+        group_id = f"{self.assistant_id or 'assistant'}-group-{index}"
+        if self.groups and self.groups[-1].id == group_id:
+            return
+        self.text_item_id = ""
+        self.thinking_item_id = ""
+        self.groups.append(StoredAssistantOutputGroup(id=group_id, items=[]))
+
+    def append_text(self, content: str) -> None:
+        if not content:
+            return
+        self._ensure_group()
+        if not self.text_item_id:
+            self.text_item_index += 1
+            self.text_item_id = f"{self.assistant_id}-text-{self.text_item_index}"
+            self._append_current_item(
+                StoredTextOutputItem(content="", id=self.text_item_id, type="text")
+            )
+        self.content += content
+        self.groups[-1] = self.groups[-1].model_copy(
+            update={
+                "items": [
+                    item.model_copy(update={"content": item.content + content})
+                    if item.type == "text" and item.id == self.text_item_id
+                    else item
+                    for item in self.groups[-1].items
+                ]
+            }
+        )
+
+    def append_thinking(self, content: str) -> None:
+        if not content:
+            return
+        self._ensure_group()
+        if not self.thinking_item_id:
+            self.thinking_item_index += 1
+            self.thinking_item_id = (
+                f"{self.assistant_id}-thinking-{self.thinking_item_index}"
+            )
+            self._append_current_item(
+                StoredThinkingOutputItem(
+                    content="", id=self.thinking_item_id, type="thinking"
+                )
+            )
+        self.thinking += content
+        self.groups[-1] = self.groups[-1].model_copy(
+            update={
+                "items": [
+                    item.model_copy(update={"content": item.content + content})
+                    if item.type == "thinking" and item.id == self.thinking_item_id
+                    else item
+                    for item in self.groups[-1].items
+                ]
+            }
+        )
+
+    def start_tool(self, tool: StoredToolItem) -> None:
+        self._ensure_group()
+        self.text_item_id = ""
+        self.thinking_item_id = ""
+        self.tools[tool.id] = tool
+        self._append_current_item(
+            StoredToolOutputItem(id=f"tool-{tool.id}", tool=tool, type="tool")
+        )
+
+    def update_tool(self, tool_id: str, data: dict[str, object]) -> None:
+        current_tool = self.tools.get(tool_id)
+        if current_tool is None:
+            return
+        updated_tool = StoredToolItem.model_validate(
+            {**current_tool.model_dump(exclude_none=True), **data}
+        )
+        self.tools[tool_id] = updated_tool
+        self.groups = [
+            group.model_copy(
+                update={
+                    "items": [
+                        item.model_copy(update={"tool": updated_tool})
+                        if item.type == "tool" and item.tool.id == tool_id
+                        else item
+                        for item in group.items
+                    ]
+                }
+            )
+            for group in self.groups
+        ]
+
+    def append_error(self, error: StoredErrorOutputItem) -> StoredErrorOutputItem:
+        self.error_item_index += 1
+        if not error.id:
+            error = error.model_copy(
+                update={"id": f"{self.assistant_id}-error-{self.error_item_index}"}
+            )
+        error_group_id = f"{self.assistant_id}-errors"
+        if self.groups and self.groups[-1].id == error_group_id:
+            self.groups[-1] = self.groups[-1].model_copy(
+                update={"items": [*self.groups[-1].items, error]}
+            )
+        else:
+            self.groups.append(
+                StoredAssistantOutputGroup(id=error_group_id, items=[error])
+            )
+        return error
+
+    def has_output(self) -> bool:
+        return any(group.items for group in self.groups)
+
+    def apply_done_message(self, message: dict[str, object]) -> None:
+        final_content = str(message.get("content") or self.content)
+        final_thinking = str(message.get("thinking") or self.thinking)
+        self._append_missing_done_text(final_content)
+        self._append_missing_done_thinking(final_thinking)
+        self.content = final_content
+        self.thinking = final_thinking
+
+    def _append_missing_done_text(self, final_content: str) -> None:
+        streamed_text = "".join(
+            item.content
+            for group in self.groups
+            for item in group.items
+            if item.type == "text"
+        )
+        if not final_content or streamed_text == final_content:
+            return
+        missing_text = (
+            final_content[len(streamed_text) :]
+            if final_content.startswith(streamed_text)
+            else final_content
+        )
+        self.append_text(missing_text)
+
+    def _append_missing_done_thinking(self, final_thinking: str) -> None:
+        streamed_thinking = "".join(
+            item.content
+            for group in self.groups
+            for item in group.items
+            if item.type == "thinking"
+        )
+        if not final_thinking or streamed_thinking == final_thinking:
+            return
+        missing_thinking = (
+            final_thinking[len(streamed_thinking) :]
+            if final_thinking.startswith(streamed_thinking)
+            else final_thinking
+        )
+        self.append_thinking(missing_thinking)
+
+    def _ensure_group(self) -> None:
+        if not self.groups:
+            self.start_group(1)
+
+    def _append_current_item(
+        self,
+        item: StoredTextOutputItem
+        | StoredThinkingOutputItem
+        | StoredErrorOutputItem
+        | StoredToolOutputItem,
+    ) -> None:
+        self.groups[-1] = self.groups[-1].model_copy(
+            update={"items": [*self.groups[-1].items, item]}
+        )