flowent 0.1.4 → 0.2.0

package/backend/src/flowent/main.py

@@ -2,7 +2,7 @@ import asyncio
 import json
 import logging
 import os
-from collections.abc import AsyncIterator
+from collections.abc import AsyncIterator, Mapping, Sequence
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -15,7 +15,12 @@ from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel, ConfigDict
 
 from flowent._version import __version__
-from flowent.agent import run_agent_stream
+from flowent.agent import AgentContextUpdate, run_agent_stream
+from flowent.approval import (
+    ApprovalReviewRequest,
+    ApprovalTranscriptEntry,
+    review_approval_request,
+)
 from flowent.channels import TelegramBotManager, TelegramTransport
 from flowent.compact import (
     CompactInput,
@@ -30,11 +35,15 @@ from flowent.llm import (
     ProviderFormat,
     list_provider_models,
 )
-from flowent.logging import TRACE_LEVEL, ensure_logging_configured
+from flowent.logging import (
+    TRACE_LEVEL,
+    ensure_logging_configured,
+    redact_diagnostic_value,
+)
 from flowent.mcp import McpManager, McpTransport
 from flowent.mcp_import import McpImportDiscovery, discover_imported_mcp_servers
 from flowent.paths import resolve_workdir
-from flowent.permissions import WritablePathDecision, run_tool_with_path_permissions
+from flowent.permissions import run_tool_with_path_permissions
 from flowent.sandbox import ensure_sandbox_available
 from flowent.skills import (
     discover_skills,
@@ -43,17 +52,21 @@ from flowent.skills import (
 )
 from flowent.storage import (
     StateStore,
+    StoredAssistantOutputGroup,
     StoredCompactionCheckpoint,
+    StoredErrorOutputItem,
     StoredMcpServer,
     StoredMessage,
-    StoredPermissionRequest,
     StoredProvider,
     StoredSettings,
     StoredSkill,
     StoredState,
     StoredTelegramBot,
     StoredTelegramSession,
+    StoredTextOutputItem,
+    StoredThinkingOutputItem,
     StoredToolItem,
+    StoredToolOutputItem,
     StoredWritablePath,
 )
 from flowent.tools import ToolContext
@@ -63,6 +76,11 @@ logger = logging.getLogger("flowent.main")
 
 DEFAULT_STATIC_DIR = Path(__file__).parent / "static"
 COMPACTED_CONTEXT_MARKER = "Context compacted"
+OPTIMIZED_CONTEXT_MARKER = "Context optimized"
+DEFAULT_AUTO_COMPACT_TOKEN_LIMIT = 120_000
+AUTO_COMPACT_RETAINED_MESSAGE_TOKEN_BUDGET = 20_000
+APPROVAL_TRANSCRIPT_MESSAGE_LIMIT = 12
+APPROVAL_TRANSCRIPT_TEXT_LIMIT = 2_000
 
 
 class ProviderModelsRequest(BaseModel):
@@ -144,21 +162,6 @@ class WritablePathListResponse(BaseModel):
     writable_paths: list[StoredWritablePath]
 
 
-class WorkspacePermissionDecisionRequest(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-
-    decision: Literal["allow_once", "always_allow", "deny"]
-    id: str
-
-
-@dataclass
-class PendingWorkspacePermission:
-    future: asyncio.Future[WritablePathDecision]
-    path: Path
-    reason: str
-    tool_call_id: str | None = None
-
-
 @dataclass
 class WorkspaceRun:
     condition: asyncio.Condition
@@ -166,26 +169,12 @@ class WorkspaceRun:
     events: list[tuple[int, str, dict[str, object]]] = field(default_factory=list)
     id: str = field(default_factory=lambda: str(uuid4()))
     is_done: bool = False
-    pending_permissions: dict[str, PendingWorkspacePermission] = field(
-        default_factory=dict
-    )
     task: asyncio.Task[None] | None = None
 
     @property
     def latest_event_index(self) -> int:
         return self.events[-1][0] if self.events else 0
 
-    def permission_requests(self) -> list[StoredPermissionRequest]:
-        return [
-            StoredPermissionRequest(
-                id=permission_id,
-                path=str(permission.path),
-                reason=permission.reason,
-                tool_call_id=permission.tool_call_id,
-            )
-            for permission_id, permission in self.pending_permissions.items()
-        ]
-
 
 def stream_event(event: str, data: dict[str, object]) -> str:
     return f"event: {event}\ndata: {json.dumps(data)}\n\n"
@@ -200,6 +189,265 @@ def append_or_replace_message(
     ]
 
 
+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]}
+        )
+
+
 def frontend_static_directory() -> Path:
     configured_directory = os.environ.get("FLOWENT_STATIC_DIR")
     if configured_directory:
@@ -247,11 +495,33 @@ def selected_connection(state: StoredState) -> ProviderConnection:
 def latest_compacted_context_index(messages: list[StoredMessage]) -> int | None:
     for index in range(len(messages) - 1, -1, -1):
         message = messages[index]
-        if message.author == "system" and message.content == COMPACTED_CONTEXT_MARKER:
+        if message.author == "system" and is_context_marker(message):
             return index
     return None
 
 
+def is_context_marker(message: StoredMessage) -> bool:
+    return message.content in {COMPACTED_CONTEXT_MARKER, OPTIMIZED_CONTEXT_MARKER}
+
+
+def auto_compact_token_limit() -> int:
+    raw_limit = os.environ.get("FLOWENT_AUTO_COMPACT_TOKEN_LIMIT", "")
+    try:
+        return max(0, int(raw_limit))
+    except ValueError:
+        return DEFAULT_AUTO_COMPACT_TOKEN_LIMIT
+
+
+def should_auto_compact(messages: list[ChatMessage]) -> bool:
+    token_limit = auto_compact_token_limit()
+    if token_limit <= 0:
+        return False
+    return (
+        sum(max(1, (len(message.content) + 3) // 4) for message in messages)
+        >= token_limit
+    )
+
+
 def workspace_chat_messages(
     messages: list[StoredMessage],
     compacted_context: str = "",
@@ -266,15 +536,22 @@ def workspace_chat_messages(
             checkpoint.source_message_id,
         )
         for message in visible_messages:
-            if (
-                message.author == "system"
-                and message.content == COMPACTED_CONTEXT_MARKER
-            ):
+            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"
             )
@@ -296,10 +573,18 @@ def workspace_chat_messages(
         visible_messages = messages[marker_index + 1 :]
 
     for message in visible_messages:
-        if message.author == "system" and message.content == COMPACTED_CONTEXT_MARKER:
+        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"
         )
@@ -338,6 +623,99 @@ def create_app(
     logger.info("Workdir: %s", cwd)
     logger.info("Static directory: %s", static_dir)
 
+    def request_messages_for_content(
+        state: StoredState,
+        messages: list[StoredMessage],
+        content: str,
+    ) -> list[dict[str, object]]:
+        compacted_context = store.read_compacted_context()
+        checkpoint = store.read_active_compaction_checkpoint()
+        chat_messages = workspace_chat_messages(
+            messages,
+            compacted_context,
+            checkpoint,
+        )
+        return [
+            message.model_dump()
+            for message in [
+                *runtime_context_messages(cwd, state.settings.agent_prompt),
+                *explicit_skill_messages(cwd, store, content),
+                *chat_messages,
+            ]
+        ]
+
+    async def save_context_checkpoint(
+        *,
+        connection: ProviderConnection,
+        messages: list[StoredMessage],
+        model_history: list[ChatMessage],
+        marker_content: str,
+        source_message_id: str | None = None,
+        trigger: Literal["manual", "auto"],
+    ) -> tuple[StoredMessage, list[dict[str, object]]]:
+        marker = StoredMessage(
+            author="system",
+            content=marker_content,
+            id=str(uuid4()),
+        )
+        compact_result = await compact_provider.compact(
+            connection,
+            CompactInput(
+                messages=messages,
+                model_history=model_history,
+                retained_message_token_budget=AUTO_COMPACT_RETAINED_MESSAGE_TOKEN_BUDGET,
+                trigger=trigger,
+            ),
+            completion=chat_completion,
+        )
+        store.save_compaction_checkpoint(
+            StoredCompactionCheckpoint(
+                id=str(uuid4()),
+                method=compact_result.method,
+                replacement_history=compact_result.replacement_history,
+                source_message_id=source_message_id or marker.id,
+                summary=compact_result.summary,
+                token_after=compact_result.token_after,
+                token_before=compact_result.token_before,
+                trigger=trigger,
+            )
+        )
+        logger.info(
+            "Workspace compact checkpoint saved trigger=%s method=%s summary_length=%s token_before=%s token_after=%s",
+            trigger,
+            compact_result.method,
+            len(compact_result.summary),
+            compact_result.token_before,
+            compact_result.token_after,
+        )
+        logger.log(TRACE_LEVEL, "Workspace compact summary=%r", compact_result.summary)
+        return marker, [
+            message.model_dump() for message in compact_result.replacement_history
+        ]
+
+    async def auto_compact_workspace_messages(
+        *,
+        connection: ProviderConnection,
+        messages: list[StoredMessage],
+        model_history: list[ChatMessage],
+        source_message_id: str | None = None,
+    ) -> tuple[StoredMessage, list[dict[str, object]]] | None:
+        if not should_auto_compact(model_history):
+            return None
+        logger.info("Workspace auto compact requested")
+        try:
+            return await save_context_checkpoint(
+                connection=connection,
+                marker_content=OPTIMIZED_CONTEXT_MARKER,
+                messages=messages,
+                model_history=model_history,
+                source_message_id=source_message_id,
+                trigger="auto",
+            )
+        except Exception as error:
+            logger.exception("Workspace auto compact failed")
+            raise RuntimeError("Context could not be optimized.") from error
+
     async def run_workspace_turn(content: str) -> StoredMessage:
         state = store.read_state()
         connection = selected_connection(state)
@@ -348,24 +726,54 @@ def create_app(
         )
         next_messages = [*state.messages, user_message]
         store.save_messages(next_messages)
-        chat_messages = workspace_chat_messages(
-            next_messages,
-            store.read_compacted_context(),
-            store.read_active_compaction_checkpoint(),
-        )
-        skill_messages = explicit_skill_messages(cwd, store, content)
-        request_messages = [
-            message.model_dump()
-            for message in [
-                *runtime_context_messages(cwd),
-                *skill_messages,
-                *chat_messages,
-            ]
+        model_history = [
+            *runtime_context_messages(cwd, state.settings.agent_prompt),
+            *workspace_chat_messages(
+                state.messages,
+                store.read_compacted_context(),
+                store.read_active_compaction_checkpoint(),
+            ),
         ]
-        assistant_content = ""
-        assistant_thinking = ""
-        assistant_tools: dict[str, StoredToolItem] = {}
+        auto_compaction = await auto_compact_workspace_messages(
+            connection=connection,
+            messages=state.messages,
+            model_history=model_history,
+            source_message_id=None,
+        )
+        if auto_compaction is not None:
+            marker, _ = auto_compaction
+            next_messages = [*state.messages, marker, user_message]
+            store.save_messages(next_messages)
+        request_messages = request_messages_for_content(state, next_messages, content)
         assistant_id = str(uuid4())
+        assistant_output = AssistantOutputBuilder(assistant_id)
+
+        async def review_tool_approval(request: ApprovalReviewRequest):
+            return await review_approval_request(
+                connection,
+                request.model_copy(
+                    update={
+                        "transcript": approval_transcript(next_messages),
+                        "user_request": content,
+                    }
+                ),
+                completion=chat_completion,
+            )
+
+        async def tool_runner(
+            name: str,
+            arguments: dict[str, object],
+            context: ToolContext,
+        ):
+            return await run_tool_with_path_permissions(
+                name,
+                arguments,
+                context,
+                review_approval=review_tool_approval,
+                writable_paths=[
+                    Path(path.path) for path in store.read_writable_paths()
+                ],
+            )
 
         async for event in run_agent_stream(
             completion=chat_completion,
@@ -375,40 +783,44 @@ def create_app(
             extra_tool_specs=mcp_manager.tool_specs(),
             extra_tool_title=mcp_manager.tool_title,
             messages=request_messages,
+            tool_runner=tool_runner,
         ):
+            if event.event == "start":
+                event_id = event.data.get("id")
+                if isinstance(event_id, str):
+                    assistant_id = event_id
+                    assistant_output.set_assistant_id(event_id)
+            if event.event == "output_start":
+                index = event.data.get("index")
+                if isinstance(index, int):
+                    assistant_output.start_group(index)
             if event.event == "delta":
-                assistant_content += str(event.data.get("content") or "")
+                assistant_output.append_text(str(event.data.get("content") or ""))
             if event.event == "thinking_delta":
-                assistant_thinking += str(event.data.get("content") or "")
+                assistant_output.append_thinking(str(event.data.get("content") or ""))
             if event.event == "tool_start":
                 tool = event.data.get("tool")
                 if isinstance(tool, dict) and isinstance(tool.get("id"), str):
-                    assistant_tools[tool["id"]] = StoredToolItem.model_validate(tool)
+                    assistant_output.start_tool(StoredToolItem.model_validate(tool))
             if event.event in {"tool_done", "tool_error"}:
                 tool_id = event.data.get("id")
-                if isinstance(tool_id, str) and tool_id in assistant_tools:
-                    assistant_tools[tool_id] = StoredToolItem.model_validate(
-                        {
-                            **assistant_tools[tool_id].model_dump(exclude_none=True),
-                            **event.data,
-                        }
-                    )
+                if isinstance(tool_id, str):
+                    assistant_output.update_tool(tool_id, event.data)
             if event.event == "done":
                 message = event.data.get("message")
                 if isinstance(message, dict):
                     assistant_id = str(message.get("id") or assistant_id)
-                    assistant_content = str(message.get("content") or assistant_content)
-                    assistant_thinking = str(
-                        message.get("thinking") or assistant_thinking
-                    )
+                    assistant_output.set_assistant_id(assistant_id)
+                    assistant_output.apply_done_message(message)
 
         assistant_message = StoredMessage(
             author="assistant",
-            content=assistant_content,
+            content=assistant_output.content,
+            groups=assistant_output.groups,
             id=assistant_id,
             status="completed",
-            thinking=assistant_thinking,
-            tools=list(assistant_tools.values()),
+            thinking=assistant_output.thinking,
+            tools=list(assistant_output.tools.values()),
         )
         store.save_messages([*next_messages, assistant_message])
         return assistant_message
@@ -460,9 +872,6 @@ def create_app(
             if active_run and not active_run.is_done
             else None,
             "mcp_servers": mcp_manager.servers_with_status(state.mcp_servers),
-            "permission_requests": active_run.permission_requests()
-            if active_run and not active_run.is_done
-            else [],
             "skills": discover_skills(cwd, store),
         }
         if telegram_bot_manager is not None:
@@ -586,25 +995,6 @@ def create_app(
             )
         )
 
-    @app.post("/api/workspace/permissions/approve")
-    async def approve_workspace_permission(
-        request: WorkspacePermissionDecisionRequest,
-    ) -> dict[str, bool]:
-        run = active_workspace_run()
-        if run is None:
-            raise HTTPException(status_code=404, detail="Request not found.")
-        pending = run.pending_permissions.pop(request.id, None)
-        if pending is None:
-            raise HTTPException(status_code=404, detail="Request not found.")
-        path = pending.path
-        if request.decision == "always_allow":
-            saved_path = store.save_writable_path(path)
-            path = Path(saved_path.path)
-        pending.future.set_result(
-            WritablePathDecision(decision=request.decision, path=path)
-        )
-        return {"ok": True}
-
     @app.put("/api/workspace/messages")
     async def save_workspace_messages(
         request: WorkspaceMessagesRequest,
@@ -642,44 +1032,31 @@ def create_app(
         )
         next_messages = [*state.messages, user_message]
         store.save_messages(next_messages)
-        chat_messages = workspace_chat_messages(
-            next_messages,
-            store.read_compacted_context(),
-            store.read_active_compaction_checkpoint(),
-        )
-        request_messages = [
-            message.model_dump()
-            for message in [
-                *runtime_context_messages(cwd),
-                *explicit_skill_messages(cwd, store, content),
-                *chat_messages,
-            ]
-        ]
         run = WorkspaceRun(condition=asyncio.Condition())
         workspace_runs[run.id] = run
         active_workspace_run_id = run.id
 
         async def run_task() -> None:
             nonlocal active_workspace_run_id
-            assistant_tools: dict[str, StoredToolItem] = {}
+            nonlocal next_messages
             assistant_message = StoredMessage(
                 author="assistant",
                 content="",
                 id=str(uuid4()),
                 status="running",
             )
-            assistant_content = ""
-            assistant_thinking = ""
+            assistant_output = AssistantOutputBuilder(assistant_message.id)
 
             def persist_assistant(status: str = "running") -> None:
                 nonlocal next_messages, assistant_message
                 assistant_message = StoredMessage(
                     author="assistant",
-                    content=assistant_content,
+                    content=assistant_output.content,
+                    groups=assistant_output.groups,
                     id=assistant_message.id,
                     status=status,
-                    thinking=assistant_thinking,
-                    tools=list(assistant_tools.values()),
+                    thinking=assistant_output.thinking,
+                    tools=list(assistant_output.tools.values()),
                 )
                 next_messages = append_or_replace_message(
                     next_messages, assistant_message
@@ -688,44 +1065,51 @@ def create_app(
 
             try:
                 current_tool_id: str | None = None
-
-                async def request_writable_path(
-                    path: Path, reason: str
-                ) -> WritablePathDecision:
-                    permission_id = str(uuid4())
-                    future = asyncio.get_running_loop().create_future()
-                    run.pending_permissions[permission_id] = PendingWorkspacePermission(
-                        future=future,
-                        path=path,
-                        reason=reason,
-                        tool_call_id=current_tool_id,
-                    )
-                    if current_tool_id and current_tool_id in assistant_tools:
-                        assistant_tools[current_tool_id] = (
-                            StoredToolItem.model_validate(
-                                {
-                                    **assistant_tools[current_tool_id].model_dump(
-                                        exclude_none=True
-                                    ),
-                                    "status": "waiting",
-                                }
-                            )
-                        )
-                        persist_assistant()
+                current_request_messages = request_messages_for_content(
+                    state,
+                    next_messages,
+                    content,
+                )
+                pre_turn_request_messages = request_messages_for_content(
+                    state,
+                    state.messages,
+                    content,
+                )
+                auto_compaction = await auto_compact_workspace_messages(
+                    connection=connection,
+                    messages=state.messages,
+                    model_history=[
+                        ChatMessage.model_validate(message)
+                        for message in pre_turn_request_messages
+                    ],
+                    source_message_id=None,
+                )
+                if auto_compaction is not None:
+                    marker, _ = auto_compaction
+                    next_messages = [*state.messages, marker, user_message]
+                    store.save_messages(next_messages)
                     await append_run_event(
                         run,
-                        "permission_request",
-                        {
-                            "id": permission_id,
-                            "path": str(path),
-                            "reason": reason,
-                            "tool_call_id": current_tool_id,
-                        },
+                        "context_optimized",
+                        {"message": marker.model_dump()},
+                    )
+                    current_request_messages = request_messages_for_content(
+                        state,
+                        next_messages,
+                        content,
+                    )
+
+                async def review_tool_approval(request: ApprovalReviewRequest):
+                    return await review_approval_request(
+                        connection,
+                        request.model_copy(
+                            update={
+                                "transcript": approval_transcript(next_messages),
+                                "user_request": content,
+                            }
+                        ),
+                        completion=chat_completion,
                     )
-                    try:
-                        return await future
-                    finally:
-                        run.pending_permissions.pop(permission_id, None)
 
                 async def tool_runner(
                     name: str,
@@ -736,20 +1120,79 @@ def create_app(
                         name,
                         arguments,
                         context,
-                        request_writable_path=request_writable_path,
+                        review_approval=review_tool_approval,
                         writable_paths=[
                             Path(path.path) for path in store.read_writable_paths()
                         ],
                     )
 
+                async def context_compactor(
+                    conversation: Sequence[Mapping[str, object]],
+                ) -> AgentContextUpdate | None:
+                    nonlocal next_messages
+                    assistant_snapshot = StoredMessage(
+                        author="assistant",
+                        content=assistant_output.content,
+                        groups=assistant_output.groups,
+                        id=assistant_message.id,
+                        status="running",
+                        thinking=assistant_output.thinking,
+                        tools=list(assistant_output.tools.values()),
+                    )
+                    model_history: list[ChatMessage] = []
+                    for message in conversation:
+                        role_value = message.get("role")
+                        content = str(message.get("content") or "")
+                        if role_value == "system":
+                            model_history.append(
+                                ChatMessage(role="system", content=content)
+                            )
+                        if role_value == "user":
+                            model_history.append(
+                                ChatMessage(role="user", content=content)
+                            )
+                        if role_value == "assistant":
+                            model_history.append(
+                                ChatMessage(role="assistant", content=content)
+                            )
+                        if role_value == "tool":
+                            model_history.append(
+                                ChatMessage(
+                                    role="user",
+                                    content=f"Tool result: {content}",
+                                )
+                            )
+                    auto_result = await auto_compact_workspace_messages(
+                        connection=connection,
+                        messages=next_messages,
+                        model_history=model_history,
+                        source_message_id=assistant_snapshot.id,
+                    )
+                    if auto_result is None:
+                        return None
+                    marker, replacement_history = auto_result
+                    next_messages = append_or_replace_message(
+                        [*next_messages, marker], assistant_snapshot
+                    )
+                    store.save_messages(next_messages)
+                    compacted_conversation = [
+                        dict(conversation[0]),
+                        *replacement_history,
+                    ]
+                    return AgentContextUpdate(
+                        conversation=compacted_conversation,
+                        message=marker.model_dump(),
+                    )
+
                 async for event in run_agent_stream(
                     completion=chat_completion,
                     connection=connection,
+                    context_compactor=context_compactor,
                     cwd=cwd,
                     extra_tool_runner=mcp_manager.run_tool,
                     extra_tool_specs=mcp_manager.tool_specs(),
                     extra_tool_title=mcp_manager.tool_title,
-                    messages=request_messages,
+                    messages=current_request_messages,
                     tool_runner=tool_runner,
                 ):
                     if event.event == "start":
@@ -758,35 +1201,41 @@ def create_app(
                             assistant_message = assistant_message.model_copy(
                                 update={"id": event_id}
                             )
+                            assistant_output.set_assistant_id(event_id)
+                            persist_assistant()
+                    if event.event == "output_start":
+                        index = event.data.get("index")
+                        if isinstance(index, int):
+                            assistant_output.start_group(index)
                             persist_assistant()
                     if event.event == "tool_start":
                         tool = event.data.get("tool")
                         if isinstance(tool, dict) and isinstance(tool.get("id"), str):
                             current_tool_id = tool["id"]
-                            assistant_tools[tool["id"]] = StoredToolItem.model_validate(
-                                tool
+                            assistant_output.start_tool(
+                                StoredToolItem.model_validate(tool)
                             )
                             persist_assistant()
                     if event.event in {"tool_done", "tool_error"}:
                         tool_id = event.data.get("id")
-                        if isinstance(tool_id, str) and tool_id in assistant_tools:
+                        if (
+                            isinstance(tool_id, str)
+                            and tool_id in assistant_output.tools
+                        ):
                             current_tool_id = (
                                 None if current_tool_id == tool_id else current_tool_id
                             )
-                            assistant_tools[tool_id] = StoredToolItem.model_validate(
-                                {
-                                    **assistant_tools[tool_id].model_dump(
-                                        exclude_none=True
-                                    ),
-                                    **event.data,
-                                }
-                            )
+                            assistant_output.update_tool(tool_id, event.data)
                             persist_assistant()
                     if event.event == "delta":
-                        assistant_content += str(event.data.get("content") or "")
+                        assistant_output.append_text(
+                            str(event.data.get("content") or "")
+                        )
                         persist_assistant()
                     if event.event == "thinking_delta":
-                        assistant_thinking += str(event.data.get("content") or "")
+                        assistant_output.append_thinking(
+                            str(event.data.get("content") or "")
+                        )
                         persist_assistant()
                     logger.log(
                         TRACE_LEVEL,
@@ -797,12 +1246,7 @@ def create_app(
                     if event.event == "done":
                         message = event.data.get("message")
                         if isinstance(message, dict):
-                            assistant_content = str(
-                                message.get("content") or assistant_content
-                            )
-                            assistant_thinking = str(
-                                message.get("thinking") or assistant_thinking
-                            )
+                            assistant_output.apply_done_message(message)
                             persist_assistant("completed")
                     await append_run_event(run, event.event, event.data)
             except asyncio.CancelledError:
@@ -817,12 +1261,23 @@ def create_app(
                 raise
             except Exception as error:
                 logger.exception("Workspace response failed")
-                persist_assistant("failed")
-                await append_run_event(
-                    run,
-                    "error",
-                    {"message": str(error) or "Message could not be sent."},
+                if (
+                    current_tool_id is not None
+                    and current_tool_id in assistant_output.tools
+                    and assistant_output.tools[current_tool_id].status == "running"
+                ):
+                    assistant_output.update_tool(
+                        current_tool_id,
+                        {"content": str(error) or "Tool failed.", "status": "failed"},
+                    )
+                error_item = assistant_output.append_error(
+                    run_error_output_item(
+                        assistant_message.id,
+                        str(error) or EMPTY_MODEL_RESPONSE_DETAIL,
+                    )
                 )
+                persist_assistant("failed")
+                await append_run_event(run, "error", run_error_event_data(error_item))
             finally:
                 run.is_done = True
                 async with run.condition:
@@ -900,7 +1355,7 @@ def create_app(
         connection = selected_connection(state)
         checkpoint = store.read_active_compaction_checkpoint()
         model_history = [
-            *runtime_context_messages(cwd),
+            *runtime_context_messages(cwd, state.settings.agent_prompt),
             *workspace_chat_messages(
                 state.messages,
                 store.read_compacted_context(),
@@ -909,14 +1364,13 @@ def create_app(
         ]
 
         try:
-            compact_result = await compact_provider.compact(
-                connection,
-                CompactInput(
-                    messages=state.messages,
-                    model_history=model_history,
-                    trigger="manual",
-                ),
-                completion=chat_completion,
+            marker, _ = await save_context_checkpoint(
+                connection=connection,
+                marker_content=COMPACTED_CONTEXT_MARKER,
+                messages=state.messages,
+                model_history=model_history,
+                source_message_id=None,
+                trigger="manual",
             )
         except HTTPException:
             raise
@@ -927,33 +1381,8 @@ def create_app(
                 detail="Context could not be compacted.",
             ) from error
 
-        marker = StoredMessage(
-            author="system",
-            content=COMPACTED_CONTEXT_MARKER,
-            id=str(uuid4()),
-        )
-        source_message_id = state.messages[-1].id if state.messages else None
-        store.save_compaction_checkpoint(
-            StoredCompactionCheckpoint(
-                id=str(uuid4()),
-                method=compact_result.method,
-                replacement_history=compact_result.replacement_history,
-                source_message_id=source_message_id,
-                summary=compact_result.summary,
-                token_after=compact_result.token_after,
-                token_before=compact_result.token_before,
-                trigger="manual",
-            )
-        )
         store.save_messages([*state.messages, marker])
-        logger.info(
-            "Workspace compact completed method=%s summary_length=%s token_before=%s token_after=%s",
-            compact_result.method,
-            len(compact_result.summary),
-            compact_result.token_before,
-            compact_result.token_after,
-        )
-        logger.log(TRACE_LEVEL, "Workspace compact summary=%r", compact_result.summary)
+        logger.info("Workspace compact completed")
         return WorkspaceCompactResponse(message=marker)
 
     @app.post("/api/workspace/respond")