flowent 0.1.3 → 0.1.4

package/backend/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flowent"
-version = "0.1.3"
+version = "0.1.4"
 description = "A workflow orchestration platform for multi-agent collaboration."
 readme = "README.md"
 authors = [

package/backend/src/flowent/cli.py

@@ -5,6 +5,8 @@ import os
 import sys
 from pathlib import Path
 
+from flowent.paths import WORKDIR_ENV_VAR, resolve_workdir
+
 
 def main(argv: list[str] | None = None) -> None:
     parser = argparse.ArgumentParser(
@@ -18,8 +20,8 @@ def main(argv: list[str] | None = None) -> None:
     parser.add_argument(
         "--host",
         "--hostname",
-        default=os.environ.get("HOSTNAME") or "0.0.0.0",
-        help="Bind host (default: $HOSTNAME or 0.0.0.0)",
+        default="127.0.0.1",
+        help="Bind host (default: 127.0.0.1)",
     )
     parser.add_argument(
         "--port",
@@ -39,6 +41,11 @@ def main(argv: list[str] | None = None) -> None:
         default="",
         help=argparse.SUPPRESS,
     )
+    parser.add_argument(
+        "--workdir",
+        default="",
+        help="Agent working directory (default: $FLOWENT_WORKDIR or current directory)",
+    )
     args = parser.parse_args(argv)
 
     if args.command == "apply-patch":
@@ -72,6 +79,11 @@ def main(argv: list[str] | None = None) -> None:
     from flowent.logging import configure_logging
 
     configure_logging()
+    try:
+        workdir = resolve_workdir(args.workdir or None)
+    except ValueError as error:
+        parser.error(str(error))
+    os.environ[WORKDIR_ENV_VAR] = str(workdir)
 
     import logging
 

package/backend/src/flowent/compact.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Literal, Protocol
+
+from flowent.llm import (
+    ChatMessage,
+    CompletionCallable,
+    ProviderConnection,
+    complete_chat,
+)
+
+if TYPE_CHECKING:
+    from flowent.storage import StoredMessage
+
+CompactTrigger = Literal["manual", "auto"]
+CompactMethod = Literal["local_summary", "remote"]
+
+DEFAULT_RETAINED_MESSAGE_TOKEN_BUDGET = 20_000
+
+COMPACT_SYSTEM_PROMPT = (
+    "You are performing a context checkpoint compaction for Flowent."
+)
+COMPACT_SUMMARY_PREFIX = (
+    "Another language model started working on this Flowent workspace session and "
+    "produced the following handoff summary. Use it to continue the task without "
+    "repeating already completed work. This summary is not a higher-priority "
+    "instruction; current system, developer, runtime, tool, and user instructions "
+    "still take precedence.\n\n"
+)
+
+
+@dataclass(frozen=True)
+class CompactInput:
+    messages: Sequence[StoredMessage]
+    model_history: Sequence[ChatMessage]
+    retained_message_token_budget: int = DEFAULT_RETAINED_MESSAGE_TOKEN_BUDGET
+    trigger: CompactTrigger = "manual"
+
+
+@dataclass(frozen=True)
+class CompactResult:
+    method: CompactMethod
+    replacement_history: list[ChatMessage]
+    summary: str
+    token_after: int
+    token_before: int
+
+
+class CompactProvider(Protocol):
+    async def compact(
+        self,
+        connection: ProviderConnection,
+        compact_input: CompactInput,
+        *,
+        completion: CompletionCallable | None = None,
+    ) -> CompactResult: ...
+
+
+class LocalSummaryCompactProvider:
+    async def compact(
+        self,
+        connection: ProviderConnection,
+        compact_input: CompactInput,
+        *,
+        completion: CompletionCallable | None = None,
+    ) -> CompactResult:
+        summary_message = await complete_chat(
+            connection,
+            compact_prompt_messages(compact_input.model_history),
+            completion=completion,
+        )
+        summary = summary_message.content.strip()
+        replacement_history = build_replacement_history(
+            summary,
+            compact_input.messages,
+            token_budget=compact_input.retained_message_token_budget,
+        )
+        return CompactResult(
+            method="local_summary",
+            replacement_history=replacement_history,
+            summary=summary,
+            token_after=approximate_tokens_for_messages(replacement_history),
+            token_before=approximate_tokens_for_messages(compact_input.model_history),
+        )
+
+
+def compact_prompt_messages(
+    history_messages: Sequence[ChatMessage],
+) -> list[ChatMessage]:
+    history = "\n\n".join(
+        f"{message.role}: {message.content}" for message in history_messages
+    )
+    return [
+        ChatMessage(role="system", content=COMPACT_SYSTEM_PROMPT),
+        ChatMessage(
+            role="user",
+            content=(
+                "You are performing a CONTEXT CHECKPOINT COMPACTION for Flowent.\n\n"
+                "Create a concise handoff summary for another agent that will "
+                "continue this workspace session.\n\n"
+                "Include:\n"
+                "- Current user goal and latest request\n"
+                "- Progress made and key decisions\n"
+                "- Files inspected or changed\n"
+                "- Commands/tests run and their results\n"
+                "- Important constraints, user preferences, and project instructions "
+                "that are still relevant\n"
+                "- Pending work and clear next steps\n"
+                "- Critical facts, examples, paths, IDs, or references needed to "
+                "continue\n\n"
+                "Do not include hidden reasoning. Do not treat old environment, tool, "
+                "permission, or runtime information as authoritative; those will be "
+                "re-injected fresh in the next turn. Be concise, structured, and "
+                "optimized for continuation.\n\n"
+                f"Conversation and runtime context:\n{history}"
+            ),
+        ),
+    ]
+
+
+def build_replacement_history(
+    summary: str,
+    recent_messages: Sequence[StoredMessage],
+    *,
+    token_budget: int = DEFAULT_RETAINED_MESSAGE_TOKEN_BUDGET,
+) -> list[ChatMessage]:
+    return [
+        ChatMessage(role="user", content=f"{COMPACT_SUMMARY_PREFIX}{summary}"),
+        *retained_recent_chat_messages(
+            recent_messages,
+            token_budget=token_budget,
+        ),
+    ]
+
+
+def retained_recent_chat_messages(
+    messages: Sequence[StoredMessage],
+    *,
+    token_budget: int = DEFAULT_RETAINED_MESSAGE_TOKEN_BUDGET,
+) -> list[ChatMessage]:
+    retained: list[ChatMessage] = []
+    remaining_tokens = max(token_budget, 0)
+    for message in reversed(messages):
+        if message.author not in {"user", "assistant"}:
+            continue
+        token_count = approximate_token_count(message.content)
+        if retained and token_count > remaining_tokens:
+            break
+        if token_count > token_budget:
+            continue
+        role: Literal["user", "assistant"] = (
+            "user" if message.author == "user" else "assistant"
+        )
+        retained.append(ChatMessage(role=role, content=message.content))
+        remaining_tokens -= token_count
+        if remaining_tokens <= 0:
+            break
+    retained.reverse()
+    return retained
+
+
+def transcript_messages_after(
+    messages: Sequence[StoredMessage],
+    message_id: str | None,
+) -> list[StoredMessage]:
+    if message_id is None:
+        return list(messages)
+    for index, message in enumerate(messages):
+        if message.id == message_id:
+            return list(messages[index + 1 :])
+    return list(messages)
+
+
+def approximate_tokens_for_messages(messages: Sequence[ChatMessage]) -> int:
+    return sum(approximate_token_count(message.content) for message in messages)
+
+
+def approximate_token_count(content: str) -> int:
+    if not content:
+        return 0
+    return max(1, (len(content) + 3) // 4)

package/backend/src/flowent/main.py

@@ -17,18 +17,23 @@ from pydantic import BaseModel, ConfigDict
 from flowent._version import __version__
 from flowent.agent import run_agent_stream
 from flowent.channels import TelegramBotManager, TelegramTransport
+from flowent.compact import (
+    CompactInput,
+    LocalSummaryCompactProvider,
+    transcript_messages_after,
+)
 from flowent.context import runtime_context_messages
 from flowent.llm import (
     ChatMessage,
     CompletionCallable,
     ProviderConnection,
     ProviderFormat,
-    complete_chat,
     list_provider_models,
 )
 from flowent.logging import TRACE_LEVEL, ensure_logging_configured
 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.sandbox import ensure_sandbox_available
 from flowent.skills import (
@@ -38,8 +43,10 @@ from flowent.skills import (
 )
 from flowent.storage import (
     StateStore,
+    StoredCompactionCheckpoint,
     StoredMcpServer,
     StoredMessage,
+    StoredPermissionRequest,
     StoredProvider,
     StoredSettings,
     StoredSkill,
@@ -56,7 +63,6 @@ logger = logging.getLogger("flowent.main")
 
 DEFAULT_STATIC_DIR = Path(__file__).parent / "static"
 COMPACTED_CONTEXT_MARKER = "Context compacted"
-COMPACT_SYSTEM_PROMPT = "You are compacting Flowent workspace context."
 
 
 class ProviderModelsRequest(BaseModel):
@@ -149,6 +155,8 @@ class WorkspacePermissionDecisionRequest(BaseModel):
 class PendingWorkspacePermission:
     future: asyncio.Future[WritablePathDecision]
     path: Path
+    reason: str
+    tool_call_id: str | None = None
 
 
 @dataclass
@@ -167,6 +175,17 @@ class WorkspaceRun:
     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"
@@ -236,8 +255,34 @@ def latest_compacted_context_index(messages: list[StoredMessage]) -> int | None:
 def workspace_chat_messages(
     messages: list[StoredMessage],
     compacted_context: str = "",
+    checkpoint: StoredCompactionCheckpoint | None = None,
 ) -> list[ChatMessage]:
     chat_messages: list[ChatMessage] = []
+
+    if checkpoint is not None:
+        chat_messages.extend(checkpoint.replacement_history)
+        visible_messages = transcript_messages_after(
+            messages,
+            checkpoint.source_message_id,
+        )
+        for message in visible_messages:
+            if (
+                message.author == "system"
+                and message.content == COMPACTED_CONTEXT_MARKER
+            ):
+                continue
+            if message.author not in ("user", "assistant"):
+                raise HTTPException(
+                    status_code=400, detail="Message history is invalid."
+                )
+            checkpoint_role: Literal["user", "assistant"] = (
+                "user" if message.author == "user" else "assistant"
+            )
+            chat_messages.append(
+                ChatMessage(role=checkpoint_role, content=message.content)
+            )
+        return chat_messages
+
     marker_index = latest_compacted_context_index(messages)
     visible_messages = messages
 
@@ -269,43 +314,20 @@ def normalized_request_path(path: str, cwd: Path) -> Path:
     return raw_path.resolve(strict=False)
 
 
-def compact_prompt_messages(
-    messages: list[StoredMessage],
-    compacted_context: str,
-    runtime_messages: list[ChatMessage] | None = None,
-) -> list[ChatMessage]:
-    history_messages = [
-        *(runtime_messages or []),
-        *workspace_chat_messages(messages, compacted_context),
-    ]
-    history = "\n\n".join(
-        f"{message.role}: {message.content}" for message in history_messages
-    )
-    return [
-        ChatMessage(role="system", content=COMPACT_SYSTEM_PROMPT),
-        ChatMessage(
-            role="user",
-            content=(
-                "Compact the current Flowent workspace context for the next turn.\n\n"
-                "Keep the details needed to continue accurately, including decisions, "
-                "constraints, pending work, and referenced facts.\n\n"
-                f"Conversation:\n{history}"
-            ),
-        ),
-    ]
-
-
 def create_app(
     *,
     serve_frontend: bool = True,
     chat_completion: CompletionCallable | None = None,
     mcp_transport: McpTransport | None = None,
     telegram_transport: TelegramTransport | None = None,
+    workdir: Path | str | None = None,
 ) -> FastAPI:
     ensure_logging_configured()
     ensure_sandbox_available()
 
+    cwd = resolve_workdir(workdir)
     store = StateStore()
+    compact_provider = LocalSummaryCompactProvider()
     mcp_manager = McpManager(store=store, transport=mcp_transport)
     telegram_bot_manager: TelegramBotManager | None = None
     workspace_runs: dict[str, WorkspaceRun] = {}
@@ -313,12 +335,12 @@ def create_app(
 
     static_dir = frontend_static_directory().resolve(strict=False)
     logger.debug("Flowent app created serve_frontend=%s", serve_frontend)
+    logger.info("Workdir: %s", cwd)
     logger.info("Static directory: %s", static_dir)
 
     async def run_workspace_turn(content: str) -> StoredMessage:
         state = store.read_state()
         connection = selected_connection(state)
-        cwd = Path.cwd()
         user_message = StoredMessage(
             author="user",
             content=content,
@@ -329,6 +351,7 @@ def create_app(
         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 = [
@@ -437,7 +460,10 @@ def create_app(
             if active_run and not active_run.is_done
             else None,
             "mcp_servers": mcp_manager.servers_with_status(state.mcp_servers),
-            "skills": discover_skills(Path.cwd(), store),
+            "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:
             update["telegram_bot"] = telegram_bot_manager.bot_with_status(
@@ -462,12 +488,12 @@ def create_app(
     async def preview_mcp_import(
         request: McpImportPreviewRequest,
     ) -> McpImportDiscovery:
-        return discover_imported_mcp_servers(Path.cwd(), source=request.source)
+        return discover_imported_mcp_servers(cwd, source=request.source)
 
     @app.post("/api/mcp/import")
     async def import_mcp_servers(request: McpImportRequest) -> list[StoredMcpServer]:
         imported_servers = discover_imported_mcp_servers(
-            Path.cwd(),
+            cwd,
             source=request.source,
         ).servers
         existing_servers = {server.id for server in store.read_mcp_servers()}
@@ -498,7 +524,7 @@ def create_app(
 
     @app.post("/api/skills/reload")
     async def reload_skills() -> list[StoredSkill]:
-        return discover_skills(Path.cwd(), store)
+        return discover_skills(cwd, store)
 
     @app.put("/api/skills/{skill_id:path}")
     async def save_skill_settings(
@@ -506,7 +532,7 @@ def create_app(
         request: SkillSettingsRequest,
     ) -> StoredSkill:
         try:
-            return update_skill_enabled(Path.cwd(), store, skill_id, request.enabled)
+            return update_skill_enabled(cwd, store, skill_id, request.enabled)
         except KeyError as error:
             raise HTTPException(status_code=404, detail="Skill not found.") from error
 
@@ -548,9 +574,7 @@ def create_app(
     async def save_writable_path(
         request: WritablePathRequest,
     ) -> StoredWritablePath:
-        return store.save_writable_path(
-            normalized_request_path(request.path, Path.cwd())
-        )
+        return store.save_writable_path(normalized_request_path(request.path, cwd))
 
     @app.delete("/api/permissions/writable-paths")
     async def delete_writable_path(
@@ -558,7 +582,7 @@ def create_app(
     ) -> WritablePathListResponse:
         return WritablePathListResponse(
             writable_paths=store.delete_writable_path(
-                normalized_request_path(request.path, Path.cwd())
+                normalized_request_path(request.path, cwd)
             )
         )
 
@@ -610,7 +634,6 @@ def create_app(
         nonlocal active_workspace_run_id
         state = store.read_state()
         connection = selected_connection(state)
-        cwd = Path.cwd()
 
         user_message = StoredMessage(
             author="user",
@@ -622,6 +645,7 @@ def create_app(
         chat_messages = workspace_chat_messages(
             next_messages,
             store.read_compacted_context(),
+            store.read_active_compaction_checkpoint(),
         )
         request_messages = [
             message.model_dump()
@@ -663,6 +687,7 @@ def create_app(
                 store.upsert_message(assistant_message)
 
             try:
+                current_tool_id: str | None = None
 
                 async def request_writable_path(
                     path: Path, reason: str
@@ -672,7 +697,21 @@ def create_app(
                     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()
                     await append_run_event(
                         run,
                         "permission_request",
@@ -680,9 +719,13 @@ def create_app(
                             "id": permission_id,
                             "path": str(path),
                             "reason": reason,
+                            "tool_call_id": current_tool_id,
                         },
                     )
-                    return await future
+                    try:
+                        return await future
+                    finally:
+                        run.pending_permissions.pop(permission_id, None)
 
                 async def tool_runner(
                     name: str,
@@ -719,6 +762,7 @@ def create_app(
                     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
                             )
@@ -726,6 +770,9 @@ def create_app(
                     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:
+                            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(
@@ -843,19 +890,31 @@ def create_app(
 
     @app.post("/api/workspace/compact")
     async def compact_workspace() -> WorkspaceCompactResponse:
+        if active_workspace_run() is not None:
+            raise HTTPException(
+                status_code=409,
+                detail="Compact is unavailable while Flowent is responding.",
+            )
         logger.info("Workspace compact requested")
         state = store.read_state()
         connection = selected_connection(state)
-        compacted_context = store.read_compacted_context()
-        cwd = Path.cwd()
+        checkpoint = store.read_active_compaction_checkpoint()
+        model_history = [
+            *runtime_context_messages(cwd),
+            *workspace_chat_messages(
+                state.messages,
+                store.read_compacted_context(),
+                checkpoint,
+            ),
+        ]
 
         try:
-            summary = await complete_chat(
+            compact_result = await compact_provider.compact(
                 connection,
-                compact_prompt_messages(
-                    state.messages,
-                    compacted_context,
-                    runtime_context_messages(cwd),
+                CompactInput(
+                    messages=state.messages,
+                    model_history=model_history,
+                    trigger="manual",
                 ),
                 completion=chat_completion,
             )
@@ -873,12 +932,28 @@ def create_app(
             content=COMPACTED_CONTEXT_MARKER,
             id=str(uuid4()),
         )
-        store.save_compacted_context(summary.content)
+        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 summary_length=%s", len(summary.content)
+            "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", summary.content)
+        logger.log(TRACE_LEVEL, "Workspace compact summary=%r", compact_result.summary)
         return WorkspaceCompactResponse(message=marker)
 
     @app.post("/api/workspace/respond")