flowent 0.3.0 → 0.3.2

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

@@ -1,7 +1,6 @@
 import json
 import os
 from collections.abc import Mapping, Sequence
-from typing import Literal
 
 from fastapi import HTTPException
 
@@ -13,10 +12,11 @@ from flowent.storage import (
     StoredSettings,
     StoredState,
 )
+from flowent.tools import tool_result_model_content
 from flowent.usage import (
     TokenUsageInfo,
     current_model_context_window,
-    estimated_token_usage_for_messages,
+    estimated_token_usage_for_request,
     recompute_context_usage,
 )
 from flowent.workspace.output import error_context_summary, message_error_items
@@ -49,16 +49,18 @@ def auto_compact_token_limit(context_window: int) -> int:
 
 
 def should_auto_compact(
-    messages: list[ChatMessage],
+    messages: Sequence[ChatMessage | Mapping[str, object]],
     *,
     context_window: int,
+    tools: Sequence[Mapping[str, object]] = (),
 ) -> bool:
     token_limit = auto_compact_token_limit(context_window)
     if token_limit <= 0:
         return False
     return (
-        estimated_token_usage_for_messages(
-            [message.model_dump() for message in messages]
+        estimated_token_usage_for_request(
+            model_request_messages_data(messages),
+            tools=tools,
         ).total_tokens
         >= token_limit
     )
@@ -84,17 +86,19 @@ def update_context_usage_for_response(
     messages: Sequence[Mapping[str, object]],
     output_content: str,
     output_tools: Sequence[Mapping[str, object]] = (),
+    request_tools: Sequence[Mapping[str, object]] = (),
     model_context_window: int,
 ) -> TokenUsageInfo:
     return recompute_context_usage(
         usage_info,
-        estimated_token_usage_for_messages(
+        estimated_token_usage_for_request(
             [
                 *model_visible_messages_for_usage(messages),
                 *model_visible_response_messages_for_usage(
                     output_content, output_tools
                 ),
             ],
+            tools=request_tools,
         ).total_tokens,
         model_context_window=model_context_window,
     )
@@ -108,6 +112,8 @@ def model_visible_response_messages_for_usage(
     for index, tool in enumerate(output_tools):
         tool_id = str(tool.get("id") or f"call_{index}")
         arguments = tool.get("arguments")
+        result_payload = tool.get("result")
+        tool_result = result_payload if isinstance(result_payload, dict) else {}
         visible_messages.append(
             {
                 "role": "assistant",
@@ -131,7 +137,7 @@ def model_visible_response_messages_for_usage(
             {
                 "role": "tool",
                 "tool_call_id": tool_id,
-                "content": str(tool.get("content") or ""),
+                "content": tool_result_model_content(tool_result),
             }
         )
     if output_content:
@@ -139,12 +145,129 @@ def model_visible_response_messages_for_usage(
     return visible_messages
 
 
+def model_visible_assistant_output_messages(
+    message: StoredMessage,
+) -> list[dict[str, object]]:
+    visible_messages: list[dict[str, object]] = []
+    for group in message.groups:
+        group_content = "".join(
+            item.content for item in group.items if item.type == "text"
+        )
+        group_tools = [item.tool for item in group.items if item.type == "tool"]
+        if not group_tools:
+            if group_content:
+                visible_messages.append({"role": "assistant", "content": group_content})
+            continue
+        visible_messages.append(
+            {
+                "role": "assistant",
+                "content": group_content or None,
+                "tool_calls": [
+                    {
+                        "id": tool.id,
+                        "type": "function",
+                        "function": {
+                            "name": tool.name,
+                            "arguments": json.dumps(
+                                tool.arguments or {},
+                                ensure_ascii=False,
+                            ),
+                        },
+                    }
+                    for tool in group_tools
+                ],
+            }
+        )
+        visible_messages.extend(
+            {
+                "role": "tool",
+                "tool_call_id": tool.id,
+                "content": tool_result_model_content(tool.result or {}),
+            }
+            for tool in group_tools
+            if tool.status != "running"
+        )
+    if not visible_messages and message.content:
+        visible_messages.append({"role": "assistant", "content": message.content})
+    return visible_messages
+
+
+def model_visible_workspace_message(message: StoredMessage) -> list[dict[str, object]]:
+    if message.author == "user":
+        return [{"role": "user", "content": message.content}]
+    if message.author != "assistant":
+        raise HTTPException(status_code=400, detail="Message history is invalid.")
+    errors = message_error_items(message)
+    if errors:
+        return [
+            {"role": "assistant", "content": error_context_summary(error)}
+            for error in errors
+        ]
+    return model_visible_assistant_output_messages(message)
+
+
+def model_visible_workspace_messages(
+    messages: Sequence[StoredMessage],
+) -> list[dict[str, object]]:
+    visible_messages: list[dict[str, object]] = []
+    for message in messages:
+        visible_messages.extend(model_visible_workspace_message(message))
+    return visible_messages
+
+
+def compact_prompt_chat_message(message: Mapping[str, object]) -> ChatMessage:
+    role_value = message.get("role")
+    content = str(message.get("content") or "")
+    if role_value == "system":
+        return ChatMessage(role="system", content=content)
+    if role_value == "assistant":
+        tool_calls = message.get("tool_calls")
+        if tool_calls:
+            return ChatMessage(
+                role="assistant",
+                content=(
+                    f"Tool call: {json.dumps(tool_calls, ensure_ascii=False)}"
+                    if not content
+                    else f"{content}\nTool call: {json.dumps(tool_calls, ensure_ascii=False)}"
+                ),
+            )
+        return ChatMessage(role="assistant", content=content)
+    if role_value == "tool":
+        return ChatMessage(role="user", content=f"Tool result: {content}")
+    return ChatMessage(role="user", content=content)
+
+
+def model_request_message_data(
+    message: ChatMessage | Mapping[str, object],
+) -> dict[str, object]:
+    if isinstance(message, ChatMessage):
+        return message.model_dump()
+    return dict(message)
+
+
+def model_request_messages_data(
+    messages: Sequence[ChatMessage | Mapping[str, object]],
+) -> list[dict[str, object]]:
+    return [model_request_message_data(message) for message in messages]
+
+
+def compact_prompt_chat_messages(
+    messages: Sequence[ChatMessage | Mapping[str, object]],
+) -> list[ChatMessage]:
+    return [
+        message
+        if isinstance(message, ChatMessage)
+        else compact_prompt_chat_message(message)
+        for message in messages
+    ]
+
+
 def usage_info_for_model(
     usage_info: TokenUsageInfo | None,
     model_context_window: int,
 ) -> TokenUsageInfo | None:
     if usage_info is None:
-        return None
+        return TokenUsageInfo(model_context_window=model_context_window)
     return usage_info.model_copy(update={"model_context_window": model_context_window})
 
 
@@ -183,11 +306,13 @@ def workspace_chat_messages(
     messages: list[StoredMessage],
     compacted_context: str = "",
     checkpoint: StoredCompactionCheckpoint | None = None,
-) -> list[ChatMessage]:
-    chat_messages: list[ChatMessage] = []
+) -> list[dict[str, object]]:
+    chat_messages: list[dict[str, object]] = []
 
     if checkpoint is not None:
-        chat_messages.extend(checkpoint.replacement_history)
+        chat_messages.extend(
+            model_request_messages_data(checkpoint.replacement_history)
+        )
         visible_messages = transcript_messages_after(
             messages,
             checkpoint.source_message_id,
@@ -195,26 +320,7 @@ def workspace_chat_messages(
         for message in visible_messages:
             if message.author == "system" and is_context_marker(message):
                 continue
-            if message.author not in ("user", "assistant"):
-                raise HTTPException(
-                    status_code=400, detail="Message history is invalid."
-                )
-            if message.author == "assistant":
-                errors = message_error_items(message)
-                if errors:
-                    chat_messages.extend(
-                        ChatMessage(
-                            role="assistant", content=error_context_summary(error)
-                        )
-                        for error in errors
-                    )
-                    continue
-            checkpoint_role: Literal["user", "assistant"] = (
-                "user" if message.author == "user" else "assistant"
-            )
-            chat_messages.append(
-                ChatMessage(role=checkpoint_role, content=message.content)
-            )
+            chat_messages.extend(model_visible_workspace_message(message))
         return chat_messages
 
     marker_index = latest_compacted_context_index(messages)
@@ -223,8 +329,8 @@ def workspace_chat_messages(
     if compacted_context and marker_index is not None:
         chat_messages.extend(
             [
-                ChatMessage(role="user", content=COMPACTED_CONTEXT_MARKER),
-                ChatMessage(role="assistant", content=compacted_context),
+                {"role": "user", "content": COMPACTED_CONTEXT_MARKER},
+                {"role": "assistant", "content": compacted_context},
             ]
         )
         visible_messages = messages[marker_index + 1 :]
@@ -232,18 +338,5 @@ def workspace_chat_messages(
     for message in visible_messages:
         if message.author == "system" and is_context_marker(message):
             continue
-        if message.author not in ("user", "assistant"):
-            raise HTTPException(status_code=400, detail="Message history is invalid.")
-        if message.author == "assistant":
-            errors = message_error_items(message)
-            if errors:
-                chat_messages.extend(
-                    ChatMessage(role="assistant", content=error_context_summary(error))
-                    for error in errors
-                )
-                continue
-        role: Literal["user", "assistant"] = (
-            "user" if message.author == "user" else "assistant"
-        )
-        chat_messages.append(ChatMessage(role=role, content=message.content))
+        chat_messages.extend(model_visible_workspace_message(message))
     return chat_messages

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

@@ -3,19 +3,17 @@ 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:
+class WorkspaceResponse:
     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
@@ -50,12 +48,12 @@ def append_or_replace_message(
     ]
 
 
-def run_snapshot_data_at(
-    run: WorkspaceRun, event_index: int
+def response_snapshot_data_at(
+    response: WorkspaceResponse, 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:
+    for current_event_index, event, data in response.events:
         if current_event_index > event_index:
             break
         if event != "snapshot":
@@ -78,7 +76,7 @@ def run_snapshot_data_at(
             snapshot = copy.deepcopy(message)
     if snapshot is None:
         return None
-    for current_event_index, event, data in run.events:
+    for current_event_index, event, data in response.events:
         if current_event_index <= snapshot_event_index:
             continue
         if current_event_index > event_index:

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

@@ -7,11 +7,13 @@ from flowent.storage import (
     StoredAssistantOutputGroup,
     StoredErrorOutputItem,
     StoredMessage,
+    StoredOutputItem,
     StoredTextOutputItem,
     StoredThinkingOutputItem,
     StoredToolItem,
     StoredToolOutputItem,
 )
+from flowent.tools import tool_result_model_content
 
 APPROVAL_TRANSCRIPT_MESSAGE_LIMIT = 12
 APPROVAL_TRANSCRIPT_TEXT_LIMIT = 2_000
@@ -83,7 +85,9 @@ def approval_transcript(
             if content:
                 entries.append(ApprovalTranscriptEntry(role=role, content=content))
             for tool in message.tools:
-                tool_content = approval_transcript_text(tool.content)
+                tool_content = approval_transcript_text(
+                    tool_result_model_content(tool.result or {})
+                )
                 if tool_content:
                     entries.append(
                         ApprovalTranscriptEntry(
@@ -108,6 +112,42 @@ class AssistantOutputBuilder:
         self.error_item_index = 0
         self.tools: dict[str, StoredToolItem] = {}
 
+    @classmethod
+    def from_message(cls, message: StoredMessage) -> "AssistantOutputBuilder":
+        builder = cls(message.id)
+        builder.content = message.content
+        builder.groups = message.groups
+        builder.thinking = message.thinking
+        builder.tools = {tool.id: tool for tool in message.tools}
+        builder.text_item_index = sum(
+            1 for group in message.groups for item in group.items if item.type == "text"
+        )
+        builder.thinking_item_index = sum(
+            1
+            for group in message.groups
+            for item in group.items
+            if item.type == "thinking"
+        )
+        builder.error_item_index = sum(
+            1
+            for group in message.groups
+            for item in group.items
+            if item.type == "error"
+        )
+        latest_item = next(
+            (
+                item
+                for group in reversed(message.groups)
+                for item in reversed(group.items)
+            ),
+            None,
+        )
+        if latest_item is not None and latest_item.type == "text":
+            builder.text_item_id = latest_item.id
+        if latest_item is not None and latest_item.type == "thinking":
+            builder.thinking_item_id = latest_item.id
+        return builder
+
     def set_assistant_id(self, assistant_id: str) -> None:
         self.assistant_id = assistant_id
 
@@ -218,9 +258,29 @@ class AssistantOutputBuilder:
     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)
+    def apply_done_message(
+        self,
+        message: dict[str, object],
+        *,
+        content_prefix: str = "",
+        thinking_prefix: str = "",
+    ) -> None:
+        message_content = str(message.get("content") or "")
+        message_thinking = str(message.get("thinking") or "")
+        final_content = message_content or self.content
+        final_thinking = message_thinking or self.thinking
+        if (
+            content_prefix
+            and message_content
+            and not message_content.startswith(content_prefix)
+        ):
+            final_content = f"{content_prefix}{message_content}"
+        if (
+            thinking_prefix
+            and message_thinking
+            and not message_thinking.startswith(thinking_prefix)
+        ):
+            final_thinking = f"{thinking_prefix}{message_thinking}"
         self._append_missing_done_text(final_content)
         self._append_missing_done_thinking(final_thinking)
         self.content = final_content
@@ -272,3 +332,68 @@ class AssistantOutputBuilder:
         self.groups[-1] = self.groups[-1].model_copy(
             update={"items": [*self.groups[-1].items, item]}
         )
+
+
+def trim_assistant_message_at_error(
+    message: StoredMessage,
+    error_id: str,
+    *,
+    status: str,
+) -> StoredMessage | None:
+    next_groups: list[StoredAssistantOutputGroup] = []
+    found_error = False
+    for group in message.groups:
+        next_items: list[StoredOutputItem] = []
+        for item in group.items:
+            if item.type == "error" and item.id == error_id:
+                found_error = True
+                break
+            next_items.append(item)
+        if found_error:
+            if next_items:
+                next_groups.append(group.model_copy(update={"items": next_items}))
+            break
+        next_groups.append(group)
+
+    if not found_error:
+        return None
+
+    text_content = "".join(
+        item.content
+        for group in next_groups
+        for item in group.items
+        if item.type == "text"
+    )
+    thinking_content = "".join(
+        item.content
+        for group in next_groups
+        for item in group.items
+        if item.type == "thinking"
+    )
+    tools = [
+        item.tool
+        for group in next_groups
+        for item in group.items
+        if item.type == "tool"
+    ]
+    return message.model_copy(
+        update={
+            "content": text_content,
+            "groups": next_groups,
+            "status": status,
+            "thinking": thinking_content,
+            "tools": tools,
+        }
+    )
+
+
+def assistant_retry_output_start_index(message: StoredMessage) -> int:
+    prefix = f"{message.id}-group-"
+    indexes: list[int] = []
+    for group in message.groups:
+        if not group.id.startswith(prefix):
+            continue
+        raw_index = group.id.removeprefix(prefix)
+        if raw_index.isdigit():
+            indexes.append(int(raw_index))
+    return max(indexes, default=1)