flowent 0.0.11 → 0.0.13

package/backend/tests/test_channels.py

@@ -0,0 +1,360 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+import pytest
+from fastapi.testclient import TestClient
+
+from flowent.channels import TelegramBotManager, split_telegram_message
+from flowent.main import create_app
+from flowent.storage import StateStore, StoredTelegramBot, StoredTelegramSession
+
+
+class FakeTelegramTransport:
+    def __init__(self) -> None:
+        self.sent_messages: list[dict[str, str]] = []
+        self.updates: list[dict[str, Any]] = []
+        self.error: Exception | None = None
+        self.get_updates_calls = 0
+
+    async def get_updates(
+        self,
+        *,
+        offset: int | None,
+        timeout: int,
+        token: str,
+    ) -> list[dict[str, Any]]:
+        self.get_updates_calls += 1
+        if self.error is not None:
+            raise self.error
+        return self.updates
+
+    async def send_message(
+        self,
+        *,
+        chat_id: str,
+        text: str,
+        token: str,
+    ) -> None:
+        self.sent_messages.append(
+            {
+                "chat_id": chat_id,
+                "text": text,
+                "token": token,
+            }
+        )
+
+
+def stored_bot(
+    *,
+    bot_token: str = "telegram-secret",
+    enabled: bool = True,
+    sessions: list[StoredTelegramSession] | None = None,
+) -> StoredTelegramBot:
+    return StoredTelegramBot(
+        bot_token=bot_token,
+        enabled=enabled,
+        sessions=sessions or [],
+    )
+
+
+def stored_session(
+    *,
+    chat_id: str = "2001",
+    display_name: str = "Alice Example",
+    recent_message: str = "Hello Flowent",
+    status: str = "approved",
+    user_id: str = "1001",
+    username: str = "alice",
+) -> StoredTelegramSession:
+    return StoredTelegramSession(
+        chat_id=chat_id,
+        display_name=display_name,
+        recent_message=recent_message,
+        status=status,
+        user_id=user_id,
+        username=username,
+    )
+
+
+def telegram_update(
+    *,
+    chat_id: int = 2001,
+    text: str = "Hello Flowent",
+    update_id: int = 1,
+    user_id: int = 1001,
+    username: str = "alice",
+) -> dict[str, Any]:
+    return {
+        "message": {
+            "chat": {"id": chat_id},
+            "from": {
+                "first_name": "Alice",
+                "id": user_id,
+                "last_name": "Example",
+                "username": username,
+            },
+            "text": text,
+        },
+        "update_id": update_id,
+    }
+
+
+async def static_reply(_: str) -> str:
+    return "Reply"
+
+
+@pytest.mark.anyio
+async def test_disabled_telegram_bot_does_not_start_polling(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path))
+    transport = FakeTelegramTransport()
+    manager = TelegramBotManager(
+        message_handler=static_reply,
+        store=StateStore(tmp_path),
+        telegram_transport=transport,
+    )
+
+    await manager.poll_once(stored_bot(enabled=False))
+
+    assert transport.get_updates_calls == 0
+    assert manager.bot_with_status(stored_bot(enabled=False)).status == "disabled"
+
+
+@pytest.mark.anyio
+async def test_enabled_telegram_bot_polls_and_reports_running_status(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path))
+    transport = FakeTelegramTransport()
+    manager = TelegramBotManager(
+        message_handler=static_reply,
+        store=StateStore(tmp_path),
+        telegram_transport=transport,
+    )
+
+    await manager.poll_once(stored_bot())
+
+    assert transport.get_updates_calls == 1
+    assert manager.bot_with_status(stored_bot()).status == "running"
+
+
+@pytest.mark.anyio
+async def test_unapproved_telegram_message_creates_pending_request(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path))
+    handled_messages: list[str] = []
+    transport = FakeTelegramTransport()
+    transport.updates = [telegram_update(text="Pair this chat")]
+    store = StateStore(tmp_path)
+
+    async def handle_message(content: str) -> str:
+        handled_messages.append(content)
+        return "Reply"
+
+    manager = TelegramBotManager(
+        message_handler=handle_message,
+        store=store,
+        telegram_transport=transport,
+    )
+
+    await manager.poll_once(stored_bot())
+
+    assert handled_messages == []
+    assert store.read_telegram_bot().sessions == [
+        StoredTelegramSession(
+            chat_id="2001",
+            display_name="Alice Example",
+            recent_message="Pair this chat",
+            status="pending",
+            updated_at=store.read_telegram_bot().sessions[0].updated_at,
+            user_id="1001",
+            username="alice",
+        )
+    ]
+    assert transport.sent_messages == [
+        {
+            "chat_id": "2001",
+            "text": "Request received. Approve this conversation in Flowent.",
+            "token": "telegram-secret",
+        }
+    ]
+
+
+@pytest.mark.anyio
+async def test_approved_telegram_message_enters_workspace_and_replies(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path))
+    handled_messages: list[str] = []
+    transport = FakeTelegramTransport()
+    transport.updates = [telegram_update()]
+    store = StateStore(tmp_path)
+    store.save_telegram_session(stored_session())
+
+    async def handle_message(content: str) -> str:
+        handled_messages.append(content)
+        return "Reply"
+
+    manager = TelegramBotManager(
+        message_handler=handle_message,
+        store=store,
+        telegram_transport=transport,
+    )
+
+    await manager.poll_once(stored_bot())
+
+    assert handled_messages == ["Hello Flowent"]
+    assert transport.sent_messages == [
+        {
+            "chat_id": "2001",
+            "text": "Reply",
+            "token": "telegram-secret",
+        }
+    ]
+
+
+def test_approved_telegram_message_is_persisted_in_workspace(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    transport = FakeTelegramTransport()
+    transport.updates = [telegram_update(text="Draft from Telegram")]
+
+    async def fake_completion(**request: object) -> object:
+        async def chunks() -> object:
+            yield {"choices": [{"delta": {"content": "Telegram reply"}}]}
+
+        return chunks()
+
+    app = create_app(
+        serve_frontend=False,
+        chat_completion=fake_completion,
+        telegram_transport=transport,
+    )
+    client = TestClient(app)
+    with client:
+        client.post(
+            "/api/providers",
+            json={
+                "api_key": "sk-local",
+                "base_url": "",
+                "id": "provider-openai",
+                "models": ["gpt-5.1"],
+                "name": "OpenAI",
+                "type": "openai",
+            },
+        )
+        client.put(
+            "/api/settings",
+            json={
+                "reasoning_effort": "default",
+                "selected_model": "gpt-5.1",
+                "selected_provider_id": "provider-openai",
+            },
+        )
+        StateStore(tmp_path / "data").save_telegram_session(stored_session())
+        asyncio.run(app.state.telegram_bot_manager.poll_once(stored_bot()))
+
+        state = client.get("/api/state").json()
+
+    assert [message["content"] for message in state["messages"]] == [
+        "Draft from Telegram",
+        "Telegram reply",
+    ]
+
+
+def test_telegram_bot_config_is_saved_and_reported_in_state(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path))
+    client = TestClient(create_app(serve_frontend=False))
+
+    response = client.put(
+        "/api/telegram-bot",
+        json={
+            "bot_token": "telegram-secret",
+            "enabled": False,
+            "sessions": [],
+        },
+    )
+    state = client.get("/api/state").json()
+
+    assert response.status_code == 200
+    assert state["telegram_bot"] == {
+        "bot_token": "telegram-secret",
+        "enabled": False,
+        "error": "",
+        "sessions": [],
+        "status": "disabled",
+    }
+
+
+def test_pending_telegram_request_can_be_approved(tmp_path, monkeypatch) -> None:
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path))
+    store = StateStore(tmp_path)
+    store.save_telegram_session(stored_session(status="pending"))
+    client = TestClient(create_app(serve_frontend=False))
+
+    response = client.post(
+        "/api/telegram-bot/approve",
+        json={"chat_id": "2001"},
+    )
+    state = client.get("/api/state").json()
+
+    assert response.status_code == 200
+    assert response.json()["status"] == "approved"
+    assert state["telegram_bot"]["sessions"][0]["status"] == "approved"
+
+
+@pytest.mark.anyio
+async def test_telegram_reply_is_split_when_it_is_too_long(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path))
+    transport = FakeTelegramTransport()
+    transport.updates = [telegram_update()]
+    long_reply = "x" * 4100
+    store = StateStore(tmp_path)
+    store.save_telegram_session(stored_session())
+
+    async def handle_message(_: str) -> str:
+        return long_reply
+
+    manager = TelegramBotManager(
+        message_handler=handle_message,
+        store=store,
+        telegram_transport=transport,
+    )
+
+    await manager.poll_once(stored_bot())
+
+    assert [len(message["text"]) for message in transport.sent_messages] == [4096, 4]
+
+
+@pytest.mark.anyio
+async def test_telegram_connection_failure_reports_error_status(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path))
+    transport = FakeTelegramTransport()
+    transport.error = RuntimeError("Secret is invalid")
+    manager = TelegramBotManager(
+        message_handler=static_reply,
+        store=StateStore(tmp_path),
+        telegram_transport=transport,
+    )
+
+    await manager.poll_once(stored_bot())
+    bot = manager.bot_with_status(stored_bot())
+
+    assert bot.status == "error"
+    assert bot.error == "Secret is invalid"
+
+
+def test_split_telegram_message_keeps_empty_reply_sendable() -> None:
+    assert split_telegram_message("") == [""]

package/backend/tests/test_llm_providers.py

@@ -4,7 +4,9 @@ from flowent.llm import (
     ChatMessage,
     ProviderConnection,
     ProviderFormat,
+    ReasoningEffort,
     build_litellm_request,
+    chunk_delta_reasoning,
     complete_chat,
     stream_chat,
 )
@@ -45,6 +47,62 @@ def test_build_litellm_request_maps_provider_connection_to_completion_args() ->
     }
 
 
+def test_build_litellm_request_omits_default_reasoning_effort() -> None:
+    connection = ProviderConnection(
+        name="Primary",
+        provider=ProviderFormat.OPENAI,
+        model="gpt-5.1",
+        secret_reference="connection-primary",
+        reasoning_effort=ReasoningEffort.DEFAULT,
+    )
+
+    request = build_litellm_request(
+        connection, [ChatMessage(role="user", content="Draft a checklist.")]
+    )
+
+    assert "reasoning_effort" not in request
+
+
+def test_build_litellm_request_includes_selected_reasoning_effort() -> None:
+    connection = ProviderConnection(
+        name="Primary",
+        provider=ProviderFormat.OPENAI,
+        model="gpt-5.1",
+        secret_reference="connection-primary",
+        reasoning_effort=ReasoningEffort.XHIGH,
+    )
+
+    request = build_litellm_request(
+        connection, [ChatMessage(role="user", content="Draft a checklist.")]
+    )
+
+    assert request["reasoning_effort"] == "xhigh"
+
+
+def test_chunk_delta_reasoning_reads_litellm_reasoning_fields() -> None:
+    assert (
+        chunk_delta_reasoning(
+            {"choices": [{"delta": {"reasoning_content": "Checking files."}}]}
+        )
+        == "Checking files."
+    )
+    assert (
+        chunk_delta_reasoning(
+            {
+                "choices": [
+                    {
+                        "delta": {
+                            "thinking_blocks": [{"thinking": "Read files."}],
+                            "reasoning_items": [{"summary": "Summarize."}],
+                        }
+                    }
+                ]
+            }
+        )
+        == "Read files.Summarize."
+    )
+
+
 @pytest.mark.anyio
 async def test_complete_chat_uses_injected_litellm_completion() -> None:
     captured_request: dict[str, object] = {}

package/backend/tests/test_persistence.py

@@ -39,6 +39,36 @@ def test_app_state_persists_providers_across_app_instances(
     ]
 
 
+def test_app_state_persists_telegram_bot_across_app_instances(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path))
+    client = TestClient(create_app(serve_frontend=False))
+
+    response = client.put(
+        "/api/telegram-bot",
+        json={
+            "bot_token": "telegram-secret",
+            "enabled": False,
+            "sessions": [],
+        },
+    )
+
+    assert response.status_code == 200
+
+    restarted_client = TestClient(create_app(serve_frontend=False))
+    state_response = restarted_client.get("/api/state")
+
+    assert state_response.status_code == 200
+    assert state_response.json()["telegram_bot"] == {
+        "bot_token": "telegram-secret",
+        "enabled": False,
+        "error": "",
+        "sessions": [],
+        "status": "disabled",
+    }
+
+
 def test_app_state_persists_settings_and_workspace_messages(
     tmp_path, monkeypatch
 ) -> None:
@@ -59,6 +89,7 @@ def test_app_state_persists_settings_and_workspace_messages(
     settings_response = client.put(
         "/api/settings",
         json={
+            "reasoning_effort": "xhigh",
             "selected_model": "claude-sonnet-4-5",
             "selected_provider_id": "provider-anthropic",
         },
@@ -71,6 +102,7 @@ def test_app_state_persists_settings_and_workspace_messages(
                     "author": "assistant",
                     "content": "Draft a launch checklist",
                     "id": "message-1",
+                    "thinking": "Read the request.",
                     "tools": [
                         {
                             "id": "tool-1",
@@ -91,6 +123,7 @@ def test_app_state_persists_settings_and_workspace_messages(
     state = restarted_client.get("/api/state").json()
 
     assert state["settings"] == {
+        "reasoning_effort": "xhigh",
         "selected_model": "claude-sonnet-4-5",
         "selected_provider_id": "provider-anthropic",
     }
@@ -99,6 +132,7 @@ def test_app_state_persists_settings_and_workspace_messages(
             "author": "assistant",
             "content": "Draft a launch checklist",
             "id": "message-1",
+            "thinking": "Read the request.",
             "tools": [
                 {
                     "arguments": None,
@@ -123,3 +157,15 @@ def test_data_directory_uses_flowent_data_dir(tmp_path, monkeypatch) -> None:
 
     assert response.status_code == 200
     assert (data_dir / "flowent.db").is_file()
+
+
+def test_app_state_defaults_reasoning_effort_for_existing_settings(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path))
+    client = TestClient(create_app(serve_frontend=False))
+
+    response = client.get("/api/state")
+
+    assert response.status_code == 200
+    assert response.json()["settings"]["reasoning_effort"] == "default"

package/backend/tests/test_startup_requirements.py

@@ -0,0 +1,48 @@
+import pytest
+
+from flowent.cli import main
+from flowent.main import create_app
+from flowent.sandbox import SandboxError
+
+
+def test_create_app_fails_when_sandbox_is_missing(monkeypatch) -> None:
+    monkeypatch.setattr("flowent.sandbox.sandbox_binary", lambda: None)
+
+    with pytest.raises(SandboxError, match="Install bubblewrap"):
+        create_app(serve_frontend=False)
+
+
+def test_create_app_starts_when_bwrap_is_available(monkeypatch) -> None:
+    monkeypatch.setattr("flowent.sandbox.sandbox_binary", lambda: "/usr/bin/bwrap")
+
+    app = create_app(serve_frontend=False)
+
+    assert app.title == "Flowent"
+
+
+def test_create_app_starts_when_bubblewrap_fallback_is_available(monkeypatch) -> None:
+    monkeypatch.setattr("flowent.sandbox.sandbox_binary", lambda: "/usr/bin/bubblewrap")
+
+    app = create_app(serve_frontend=False)
+
+    assert app.title == "Flowent"
+
+
+def test_doctor_reports_missing_sandbox(monkeypatch, capsys) -> None:
+    monkeypatch.setattr("flowent.sandbox.sandbox_binary", lambda: None)
+
+    with pytest.raises(SystemExit) as error:
+        main(["doctor"])
+
+    assert error.value.code == 1
+    assert "Sandbox: missing." in capsys.readouterr().err
+
+
+def test_doctor_reports_available_sandbox(monkeypatch, capsys) -> None:
+    monkeypatch.setattr("flowent.sandbox.sandbox_binary", lambda: "/usr/bin/bwrap")
+
+    with pytest.raises(SystemExit) as error:
+        main(["doctor"])
+
+    assert error.value.code == 0
+    assert "Sandbox: /usr/bin/bwrap" in capsys.readouterr().out

package/backend/tests/test_workspace_chat.py

@@ -12,6 +12,7 @@ def configure_provider(
     name: str = "OpenAI",
     provider_id: str = "provider-openai",
     provider_type: str = "openai",
+    reasoning_effort: str = "default",
 ) -> None:
     client.post(
         "/api/providers",
@@ -27,6 +28,7 @@ def configure_provider(
     client.put(
         "/api/settings",
         json={
+            "reasoning_effort": reasoning_effort,
             "selected_model": model,
             "selected_provider_id": provider_id,
         },
@@ -324,6 +326,32 @@ def test_workspace_response_includes_project_and_environment_context(
     }
 
 
+def test_workspace_response_uses_selected_reasoning_effort(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    captured_request: dict[str, object] = {}
+
+    async def fake_completion(**request: object) -> object:
+        captured_request.update(request)
+
+        async def chunks() -> object:
+            yield {"choices": [{"delta": {"content": "Done."}}]}
+
+        return chunks()
+
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client, reasoning_effort="xhigh")
+
+    response = client.post("/api/workspace/respond", json={"content": "Hello."})
+
+    assert response.status_code == 200
+    assert captured_request["reasoning_effort"] == "xhigh"
+
+
 def test_workspace_response_prefers_agents_override(tmp_path, monkeypatch) -> None:
     monkeypatch.chdir(tmp_path)
     monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))

package/backend/uv.lock

@@ -388,7 +388,7 @@ wheels = [
 
 [[package]]
 name = "flowent"
-version = "0.0.11"
+version = "0.0.13"
 source = { editable = "." }
 dependencies = [
     { name = "fastapi", extra = ["standard"] },