npm - flowent - Versions diffs - 0.0.11 → 0.0.13 - Mend

flowent 0.0.11 → 0.0.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (53) hide show

package/backend/src/flowent/static/index.html CHANGED Viewed

@@ -6,8 +6,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Flowent</title>
     <meta name="description" content="Flowent application" />
-    <script type="module" crossorigin src="/assets/index-C76K95ty.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-iUMNKvlU.css">
+    <script type="module" crossorigin src="/assets/index-S5a0Rkj1.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CEZrWoDG.css">
   </head>
   <body>
     <div id="root"></div>

package/backend/src/flowent/storage.py CHANGED Viewed

@@ -4,10 +4,32 @@ from pathlib import Path
 from pydantic import BaseModel, ConfigDict, Field
-from flowent.llm import ProviderFormat
+from flowent.llm import ProviderFormat, ReasoningEffort
 from flowent.paths import data_directory
+class StoredTelegramSession(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    chat_id: str
+    display_name: str = ""
+    recent_message: str = ""
+    status: str
+    updated_at: int = 0
+    user_id: str = ""
+    username: str = ""
+class StoredTelegramBot(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    bot_token: str
+    enabled: bool
+    error: str = ""
+    sessions: list[StoredTelegramSession] = Field(default_factory=list)
+    status: str = "disabled"
 class StoredProvider(BaseModel):
     model_config = ConfigDict(extra="forbid")
@@ -22,6 +44,7 @@ class StoredProvider(BaseModel):
 class StoredSettings(BaseModel):
     model_config = ConfigDict(extra="forbid")
+    reasoning_effort: ReasoningEffort = ReasoningEffort.DEFAULT
     selected_model: str
     selected_provider_id: str
@@ -44,6 +67,7 @@ class StoredMessage(BaseModel):
     author: str
     content: str
     id: str
+    thinking: str = Field(default="", exclude_if=lambda value: value == "")
     tools: list[StoredToolItem] = Field(default_factory=list)
@@ -53,6 +77,7 @@ class StoredState(BaseModel):
     messages: list[StoredMessage]
     providers: list[StoredProvider]
     settings: StoredSettings
+    telegram_bot: StoredTelegramBot
 class StateStore:
@@ -72,6 +97,7 @@ class StateStore:
     def read_state(self) -> StoredState:
         with self.connect() as connection:
+            telegram_bot = self._read_telegram_bot(connection)
             providers = [
                 StoredProvider(
                     api_key=row["api_key"],
@@ -91,7 +117,7 @@ class StateStore:
             ]
             settings_row = connection.execute(
                 """
-                SELECT selected_provider_id, selected_model
+                SELECT selected_provider_id, selected_model, reasoning_effort
                 FROM settings
                 WHERE id = 1
                 """
@@ -101,6 +127,7 @@ class StateStore:
                     author=row["author"],
                     content=row["content"],
                     id=row["id"],
+                    thinking=row["thinking"],
                     tools=[
                         StoredToolItem.model_validate(tool)
                         for tool in json.loads(row["tools"] or "[]")
@@ -108,7 +135,7 @@ class StateStore:
                 )
                 for row in connection.execute(
                     """
-                    SELECT id, author, content, tools
+                    SELECT id, author, content, tools, thinking
                     FROM messages
                     ORDER BY position, id
                     """
@@ -119,11 +146,113 @@ class StateStore:
             messages=messages,
             providers=providers,
             settings=StoredSettings(
+                reasoning_effort=settings_row["reasoning_effort"]
+                if settings_row
+                else ReasoningEffort.DEFAULT,
                 selected_model=settings_row["selected_model"] if settings_row else "",
                 selected_provider_id=settings_row["selected_provider_id"]
                 if settings_row
                 else "",
             ),
+            telegram_bot=telegram_bot,
+        )
+    def read_telegram_bot(self) -> StoredTelegramBot:
+        with self.connect() as connection:
+            return self._read_telegram_bot(connection)
+    def save_telegram_bot(self, telegram_bot: StoredTelegramBot) -> StoredTelegramBot:
+        with self.connect() as connection:
+            connection.execute(
+                """
+                INSERT INTO telegram_bot (
+                    id,
+                    enabled,
+                    bot_token
+                )
+                VALUES (1, ?, ?)
+                ON CONFLICT(id) DO UPDATE SET
+                    enabled = excluded.enabled,
+                    bot_token = excluded.bot_token,
+                    updated_at = unixepoch()
+                """,
+                (
+                    int(telegram_bot.enabled),
+                    telegram_bot.bot_token,
+                ),
+            )
+            return self._read_telegram_bot(connection)
+    def save_telegram_session(
+        self, session: StoredTelegramSession
+    ) -> StoredTelegramSession:
+        with self.connect() as connection:
+            connection.execute(
+                """
+                INSERT INTO telegram_sessions (
+                    chat_id,
+                    user_id,
+                    username,
+                    display_name,
+                    recent_message,
+                    status
+                )
+                VALUES (?, ?, ?, ?, ?, ?)
+                ON CONFLICT(chat_id) DO UPDATE SET
+                    user_id = excluded.user_id,
+                    username = excluded.username,
+                    display_name = excluded.display_name,
+                    recent_message = excluded.recent_message,
+                    status = excluded.status,
+                    updated_at = unixepoch()
+                """,
+                (
+                    session.chat_id,
+                    session.user_id,
+                    session.username,
+                    session.display_name,
+                    session.recent_message,
+                    session.status,
+                ),
+            )
+        return session
+    def approve_telegram_session(self, chat_id: str) -> StoredTelegramSession:
+        with self.connect() as connection:
+            connection.execute(
+                """
+                UPDATE telegram_sessions
+                SET status = 'approved',
+                    updated_at = unixepoch()
+                WHERE chat_id = ?
+                """,
+                (chat_id,),
+            )
+            row = connection.execute(
+                """
+                SELECT
+                    chat_id,
+                    user_id,
+                    username,
+                    display_name,
+                    recent_message,
+                    status,
+                    updated_at
+                FROM telegram_sessions
+                WHERE chat_id = ?
+                """,
+                (chat_id,),
+            ).fetchone()
+        if row is None:
+            raise KeyError(chat_id)
+        return StoredTelegramSession(
+            chat_id=row["chat_id"],
+            display_name=row["display_name"],
+            recent_message=row["recent_message"],
+            status=row["status"],
+            updated_at=row["updated_at"],
+            user_id=row["user_id"],
+            username=row["username"],
         )
     def save_provider(self, provider: StoredProvider) -> StoredProvider:
@@ -166,14 +295,24 @@ class StateStore:
         with self.connect() as connection:
             connection.execute(
                 """
-                INSERT INTO settings (id, selected_provider_id, selected_model)
-                VALUES (1, ?, ?)
+                INSERT INTO settings (
+                    id,
+                    selected_provider_id,
+                    selected_model,
+                    reasoning_effort
+                )
+                VALUES (1, ?, ?, ?)
                 ON CONFLICT(id) DO UPDATE SET
                     selected_provider_id = excluded.selected_provider_id,
                     selected_model = excluded.selected_model,
+                    reasoning_effort = excluded.reasoning_effort,
                     updated_at = unixepoch()
                 """,
-                (settings.selected_provider_id, settings.selected_model),
+                (
+                    settings.selected_provider_id,
+                    settings.selected_model,
+                    settings.reasoning_effort.value,
+                ),
             )
         return settings
@@ -182,8 +321,8 @@ class StateStore:
             connection.execute("DELETE FROM messages")
             connection.executemany(
                 """
-                INSERT INTO messages (id, author, content, tools, position)
-                VALUES (?, ?, ?, ?, ?)
+                INSERT INTO messages (id, author, content, tools, thinking, position)
+                VALUES (?, ?, ?, ?, ?, ?)
                 """,
                 [
                     (
@@ -196,6 +335,7 @@ class StateStore:
                                 for tool in message.tools
                             ]
                         ),
+                        message.thinking,
                         position,
                     )
                     for position, message in enumerate(messages)
@@ -246,9 +386,65 @@ class StateStore:
             )
         ]
+    def _read_telegram_bot(self, connection: sqlite3.Connection) -> StoredTelegramBot:
+        bot_row = connection.execute(
+            """
+            SELECT enabled, bot_token
+            FROM telegram_bot
+            WHERE id = 1
+            """
+        ).fetchone()
+        sessions = [
+            StoredTelegramSession(
+                chat_id=row["chat_id"],
+                display_name=row["display_name"],
+                recent_message=row["recent_message"],
+                status=row["status"],
+                updated_at=row["updated_at"],
+                user_id=row["user_id"],
+                username=row["username"],
+            )
+            for row in connection.execute(
+                """
+                SELECT
+                    chat_id,
+                    user_id,
+                    username,
+                    display_name,
+                    recent_message,
+                    status,
+                    updated_at
+                FROM telegram_sessions
+                ORDER BY status DESC, updated_at DESC, chat_id
+                """
+            )
+        ]
+        return StoredTelegramBot(
+            bot_token=bot_row["bot_token"] if bot_row else "",
+            enabled=bool(bot_row["enabled"]) if bot_row else False,
+            sessions=sessions,
+        )
     def _migrate(self, connection: sqlite3.Connection) -> None:
         connection.executescript(
             """
+            CREATE TABLE IF NOT EXISTS telegram_bot (
+                id INTEGER PRIMARY KEY CHECK (id = 1),
+                enabled INTEGER NOT NULL DEFAULT 0,
+                bot_token TEXT NOT NULL,
+                updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+            );
+            CREATE TABLE IF NOT EXISTS telegram_sessions (
+                chat_id TEXT PRIMARY KEY,
+                user_id TEXT NOT NULL DEFAULT '',
+                username TEXT NOT NULL DEFAULT '',
+                display_name TEXT NOT NULL DEFAULT '',
+                recent_message TEXT NOT NULL DEFAULT '',
+                status TEXT NOT NULL,
+                updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+            );
             CREATE TABLE IF NOT EXISTS providers (
                 id TEXT PRIMARY KEY,
                 name TEXT NOT NULL,
@@ -270,6 +466,7 @@ class StateStore:
                 id INTEGER PRIMARY KEY CHECK (id = 1),
                 selected_provider_id TEXT NOT NULL DEFAULT '',
                 selected_model TEXT NOT NULL DEFAULT '',
+                reasoning_effort TEXT NOT NULL DEFAULT 'default',
                 updated_at INTEGER NOT NULL DEFAULT (unixepoch())
             );
@@ -300,3 +497,15 @@ class StateStore:
             connection.execute(
                 "ALTER TABLE messages ADD COLUMN tools TEXT NOT NULL DEFAULT '[]'"
             )
+        if "thinking" not in columns:
+            connection.execute(
+                "ALTER TABLE messages ADD COLUMN thinking TEXT NOT NULL DEFAULT ''"
+            )
+        settings_columns = {
+            row["name"] for row in connection.execute("PRAGMA table_info(settings)")
+        }
+        if "reasoning_effort" not in settings_columns:
+            connection.execute(
+                "ALTER TABLE settings "
+                "ADD COLUMN reasoning_effort TEXT NOT NULL DEFAULT 'default'"
+            )

package/backend/src/flowent/tools.py CHANGED Viewed

@@ -162,7 +162,7 @@ def tool_call_title(name: str, arguments: dict[str, object]) -> str:
     if name == "grep_files":
         return f"Searching {arguments.get('pattern', 'files')}"
     if name == "apply_patch":
-        return "Applying patch"
+        return "Editing files"
     if name == "shell_command":
         return f"Running {arguments.get('command', 'command')}"
     if name == "update_plan":
@@ -192,9 +192,10 @@ def run_tool(
             return web_search(arguments, context)
         raise ValueError("Tool is not available.")
     except Exception as error:
-        return ToolResult(
-            content=str(error), ok=False, title=tool_call_title(name, arguments)
+        title = (
+            "Edit failed" if name == "apply_patch" else tool_call_title(name, arguments)
         )
+        return ToolResult(content=str(error), ok=False, title=title)
 def integer_argument(arguments: dict[str, object], name: str, default: int) -> int:
@@ -262,13 +263,35 @@ def apply_patch_tool(arguments: dict[str, object], context: ToolContext) -> Tool
     )
     if result.exit_code != 0:
         raise SandboxError(tool_failure_content(result))
+    data = json.loads(result.stdout or "{}")
     return ToolResult(
         content=result.stdout,
-        data={"files": [str(path) for path in paths]},
-        title="Applied patch",
+        data=data if isinstance(data, dict) else {},
+        title=patch_title_from_result(data),
     )
+def patch_title_from_result(data: object) -> str:
+    if not isinstance(data, dict):
+        return "Edited files"
+    files = data.get("files")
+    if not isinstance(files, list) or not files:
+        return "Edited files"
+    if len(files) > 1:
+        return f"Edited {len(files)} files"
+    file_info = files[0]
+    if not isinstance(file_info, dict):
+        return "Edited files"
+    raw_path = file_info.get("path")
+    name = Path(str(raw_path)).name if raw_path else "file"
+    status = file_info.get("status")
+    if status == "added":
+        return f"Added {name}"
+    if status == "deleted":
+        return f"Deleted {name}"
+    return f"Edited {name}"
 def tool_failure_content(result: object) -> str:
     stdout = str(getattr(result, "stdout", "") or "").strip()
     stderr = str(getattr(result, "stderr", "") or "").strip()

package/backend/tests/__pycache__/conftest.cpython-313-pytest-9.0.3.pyc ADDED Viewed

Binary file

package/backend/tests/__pycache__/test_agent_tools.cpython-313-pytest-9.0.3.pyc CHANGED Viewed

Binary file

package/backend/tests/__pycache__/test_channels.cpython-313-pytest-9.0.3.pyc ADDED Viewed

Binary file

package/backend/tests/__pycache__/test_health.cpython-313-pytest-9.0.3.pyc CHANGED Viewed

Binary file

package/backend/tests/__pycache__/test_llm_providers.cpython-313-pytest-9.0.3.pyc CHANGED Viewed

Binary file

package/backend/tests/__pycache__/test_logging.cpython-313-pytest-9.0.3.pyc CHANGED Viewed

Binary file

package/backend/tests/__pycache__/test_persistence.cpython-313-pytest-9.0.3.pyc CHANGED Viewed

Binary file

package/backend/tests/__pycache__/test_startup_requirements.cpython-313-pytest-9.0.3.pyc ADDED Viewed

Binary file

package/backend/tests/__pycache__/test_workspace_chat.cpython-313-pytest-9.0.3.pyc CHANGED Viewed

Binary file

package/backend/tests/conftest.py ADDED Viewed

@@ -0,0 +1,21 @@
+import os
+import stat
+import tempfile
+from pathlib import Path
+import pytest
+_test_environment = Path(tempfile.mkdtemp(prefix="flowent-tests-"))
+_test_bin = _test_environment / "bin"
+_test_bin.mkdir(parents=True, exist_ok=True)
+_test_bwrap = _test_bin / "bwrap"
+_test_bwrap.write_text("#!/bin/sh\nexit 0\n")
+_test_bwrap.chmod(_test_bwrap.stat().st_mode | stat.S_IXUSR)
+os.environ.setdefault("FLOWENT_DATA_DIR", str(_test_environment / "data"))
+os.environ["PATH"] = f"{_test_bin}{os.pathsep}{os.environ.get('PATH', '')}"
+@pytest.fixture(autouse=True)
+def sandbox_available(monkeypatch):
+    monkeypatch.setattr("flowent.sandbox.sandbox_binary", lambda: "/usr/bin/bwrap")

package/backend/tests/test_agent_tools.py CHANGED Viewed

@@ -38,6 +38,7 @@ def configure_provider(client: TestClient) -> None:
     client.put(
         "/api/settings",
         json={
+            "reasoning_effort": "default",
             "selected_model": "gpt-5.1",
             "selected_provider_id": "provider-openai",
         },
@@ -72,6 +73,10 @@ def text_chunk(content: str) -> dict[str, object]:
     return {"choices": [{"delta": {"content": content}}]}
+def thinking_chunk(content: str) -> dict[str, object]:
+    return {"choices": [{"delta": {"reasoning_content": content}}]}
 def test_workspace_response_streams_tool_process_and_final_text(
     tmp_path, monkeypatch
 ) -> None:
@@ -248,7 +253,58 @@ def test_apply_patch_modifies_workdir_file(tmp_path) -> None:
     result = run_tool("apply_patch", {"patch": patch}, ToolContext(cwd=tmp_path))
     assert result.ok
+    assert result.title == "Edited notes.txt"
+    assert target.read_text() == "alpha\nready\n"
+def test_apply_patch_added_file_title(tmp_path) -> None:
+    patch = """*** Begin Patch
+*** Add File: created.txt
++hello
+*** End Patch
+"""
+    result = run_tool("apply_patch", {"patch": patch}, ToolContext(cwd=tmp_path))
+    assert result.ok
+    assert result.title == "Added created.txt"
+    assert (tmp_path / "created.txt").read_text() == "hello\n"
+def test_apply_patch_deleted_file_title(tmp_path) -> None:
+    target = tmp_path / "old.txt"
+    target.write_text("remove me\n")
+    patch = """*** Begin Patch
+*** Delete File: old.txt
+*** End Patch
+"""
+    result = run_tool("apply_patch", {"patch": patch}, ToolContext(cwd=tmp_path))
+    assert result.ok
+    assert result.title == "Deleted old.txt"
+    assert not target.exists()
+def test_apply_patch_multiple_files_title(tmp_path) -> None:
+    target = tmp_path / "notes.txt"
+    target.write_text("alpha\nbeta\n")
+    patch = """*** Begin Patch
+*** Update File: notes.txt
+@@
+-beta
++ready
+*** Add File: created.txt
++hello
+*** End Patch
+"""
+    result = run_tool("apply_patch", {"patch": patch}, ToolContext(cwd=tmp_path))
+    assert result.ok
+    assert result.title == "Edited 2 files"
     assert target.read_text() == "alpha\nready\n"
+    assert (tmp_path / "created.txt").read_text() == "hello\n"
 def test_apply_patch_rejects_outside_workdir_file(tmp_path) -> None:
@@ -266,6 +322,7 @@ def test_apply_patch_rejects_outside_workdir_file(tmp_path) -> None:
         result = run_tool("apply_patch", {"patch": patch}, ToolContext(cwd=tmp_path))
         assert not result.ok
+        assert result.title == "Edit failed"
         assert outside.read_text() == "alpha\n"
     finally:
         outside.unlink(missing_ok=True)
@@ -292,6 +349,7 @@ def test_apply_patch_uses_internal_subcommand(tmp_path, monkeypatch) -> None:
     result = run_tool("apply_patch", {"patch": patch}, ToolContext(cwd=tmp_path))
     assert result.ok
+    assert result.title == "Edited files"
     assert calls
     assert calls[0][1:4] == ["-m", "flowent.cli", "apply-patch"]
@@ -321,6 +379,7 @@ def test_apply_patch_reports_patch_error_when_stderr_has_warning(
     result = run_tool("apply_patch", {"patch": patch}, ToolContext(cwd=tmp_path))
     assert not result.ok
+    assert result.title == "Edit failed"
     assert result.content == "Patch context was not found."
@@ -431,6 +490,46 @@ def test_agent_finishes_without_tools(tmp_path, monkeypatch) -> None:
     assert events[-1]["data"]["message"]["content"] == "Direct answer."
+def test_agent_streams_and_persists_thinking(tmp_path, monkeypatch) -> None:
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    monkeypatch.chdir(tmp_path)
+    async def fake_completion(**request: object) -> object:
+        async def chunks() -> object:
+            yield thinking_chunk("Checking context.")
+            yield thinking_chunk(" Preparing answer.")
+            yield text_chunk("Direct answer.")
+        return chunks()
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client)
+    response = client.post(
+        "/api/workspace/respond",
+        json={"content": "Answer directly."},
+    )
+    assert response.status_code == 200
+    events = stream_events(response.text)
+    assert [event["event"] for event in events] == [
+        "start",
+        "output_start",
+        "thinking_delta",
+        "thinking_delta",
+        "delta",
+        "done",
+    ]
+    assert events[2]["data"] == {"content": "Checking context."}
+    assert events[-1]["data"]["message"]["thinking"] == (
+        "Checking context. Preparing answer."
+    )
+    state = client.get("/api/state").json()
+    assert state["messages"][-1]["thinking"] == ("Checking context. Preparing answer.")
 def test_tool_failure_is_reported_and_agent_continues(tmp_path, monkeypatch) -> None:
     monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
     monkeypatch.chdir(tmp_path)