flowent 0.1.2 → 0.1.4

package/backend/pyproject.toml

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

package/backend/src/flowent/agent.py

@@ -39,6 +39,7 @@ Use tools deliberately:
 - Search files when you need to find definitions, references, or related behavior.
 - Apply structured patches for file edits.
 - Run shell commands for diagnostics, builds, tests, and operations that require the local environment.
+- When a shell command needs to write outside the current workspace, declare each needed writable directory with sandbox_permissions set to with_additional_permissions and additional_permissions.file_system.write.
 - Search the web only when current external information is needed.
 - Update the plan when a task has multiple meaningful steps.
 

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)