flowent 0.1.4 → 0.2.0

package/backend/tests/test_workspace_chat.py

@@ -14,6 +14,7 @@ from flowent.sandbox import CommandResult, SandboxRunner
 def configure_provider(
     client,
     *,
+    agent_prompt: str = "",
     base_url: str = "",
     model: str = "gpt-5.1",
     name: str = "OpenAI",
@@ -35,6 +36,7 @@ def configure_provider(
     client.put(
         "/api/settings",
         json={
+            "agent_prompt": agent_prompt,
             "reasoning_effort": reasoning_effort,
             "selected_model": model,
             "selected_provider_id": provider_id,
@@ -45,6 +47,7 @@ def configure_provider(
 async def configure_provider_async(
     client: httpx.AsyncClient,
     *,
+    agent_prompt: str = "",
     base_url: str = "",
     model: str = "gpt-5.1",
     name: str = "OpenAI",
@@ -66,6 +69,7 @@ async def configure_provider_async(
     await client.put(
         "/api/settings",
         json={
+            "agent_prompt": agent_prompt,
             "reasoning_effort": reasoning_effort,
             "selected_model": model,
             "selected_provider_id": provider_id,
@@ -409,6 +413,288 @@ def test_workspace_response_uses_compacted_context_after_compact(
     assert {"role": "user", "content": "Context compacted"} not in response_messages
 
 
+def test_workspace_response_auto_compacts_before_next_message(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    monkeypatch.setenv("FLOWENT_AUTO_COMPACT_TOKEN_LIMIT", "120")
+    captured_requests: list[dict[str, object]] = []
+
+    async def fake_completion(**request: object) -> object:
+        captured_requests.append(request)
+        if not request.get("stream"):
+            return {
+                "choices": [
+                    {
+                        "message": {
+                            "content": "Keep the launch plan summary.",
+                            "role": "assistant",
+                        }
+                    }
+                ]
+            }
+
+        async def chunks() -> object:
+            yield {"choices": [{"delta": {"content": "Continuing."}}]}
+
+        return chunks()
+
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client)
+    client.put(
+        "/api/workspace/messages",
+        json={
+            "messages": [
+                {
+                    "author": "user",
+                    "content": "Original request. " * 80,
+                    "id": "message-1",
+                },
+                {
+                    "author": "assistant",
+                    "content": "Detailed work log. " * 80,
+                    "id": "message-2",
+                },
+            ]
+        },
+    )
+
+    response = client.post(
+        "/api/workspace/respond",
+        json={"content": "Continue from there."},
+    )
+
+    assert response.status_code == 200
+    events = stream_events(response.text)
+    assert events[0]["event"] == "context_optimized"
+    assert json.loads(events[0]["data"])["message"]["content"] == ("Context optimized")
+    assert len(captured_requests) == 2
+    assert (
+        "CONTEXT CHECKPOINT COMPACTION"
+        in captured_requests[0]["messages"][-1]["content"]
+    )
+    response_messages = captured_requests[1]["messages"]
+    compacted_messages = [
+        message
+        for message in response_messages
+        if str(message["content"]).startswith(
+            "Another language model started working on this Flowent workspace session"
+        )
+    ]
+    assert len(compacted_messages) == 1
+    assert "Keep the launch plan summary." in compacted_messages[0]["content"]
+    assert {"role": "user", "content": "Context optimized"} not in response_messages
+    state = client.get("/api/state").json()
+    assert [message["content"] for message in state["messages"]][-3:] == [
+        "Context optimized",
+        "Continue from there.",
+        "Continuing.",
+    ]
+
+
+def test_workspace_response_auto_compacts_after_tool_result(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    monkeypatch.setenv("FLOWENT_AUTO_COMPACT_TOKEN_LIMIT", "1200")
+    (tmp_path / "notes.txt").write_text("Launch notes. " * 600)
+    captured_requests: list[dict[str, object]] = []
+
+    async def fake_completion(**request: object) -> object:
+        captured_requests.append(request)
+        if not request.get("stream"):
+            return {
+                "choices": [
+                    {
+                        "message": {
+                            "content": "Keep the file findings from notes.txt.",
+                            "role": "assistant",
+                        }
+                    }
+                ]
+            }
+
+        async def chunks() -> object:
+            if len(captured_requests) == 1:
+                yield tool_call_chunk("read_file", '{"path": "notes.txt"}')
+                return
+            yield {"choices": [{"delta": {"content": "Done."}}]}
+
+        return chunks()
+
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client)
+
+    response = client.post(
+        "/api/workspace/respond",
+        json={"content": "Read the launch notes."},
+    )
+
+    assert response.status_code == 200
+    events = stream_events(response.text)
+    assert [event["event"] for event in events] == [
+        "start",
+        "output_start",
+        "tool_start",
+        "tool_done",
+        "context_optimized",
+        "output_start",
+        "delta",
+        "done",
+    ]
+    assert json.loads(events[4]["data"])["message"]["content"] == ("Context optimized")
+    assert len(captured_requests) == 3
+    assert "Launch notes." in captured_requests[1]["messages"][-1]["content"]
+    response_messages = captured_requests[2]["messages"]
+    compacted_messages = [
+        message
+        for message in response_messages
+        if str(message["content"]).startswith(
+            "Another language model started working on this Flowent workspace session"
+        )
+    ]
+    assert len(compacted_messages) == 1
+    assert "Keep the file findings from notes.txt." in compacted_messages[0]["content"]
+    state = client.get("/api/state").json()
+    assert [message["content"] for message in state["messages"]] == [
+        "Read the launch notes.",
+        "Context optimized",
+        "Done.",
+    ]
+
+
+def test_workspace_auto_compact_failure_keeps_existing_checkpoint(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    monkeypatch.setenv("FLOWENT_AUTO_COMPACT_TOKEN_LIMIT", "120")
+
+    async def fake_completion(**request: object) -> object:
+        if not request.get("stream"):
+            raise RuntimeError("summary failed")
+
+        async def chunks() -> object:
+            yield {"choices": [{"delta": {"content": "Should not run."}}]}
+
+        return chunks()
+
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client)
+    client.put(
+        "/api/workspace/messages",
+        json={
+            "messages": [
+                {
+                    "author": "user",
+                    "content": "Original request. " * 80,
+                    "id": "message-1",
+                }
+            ]
+        },
+    )
+
+    response = client.post(
+        "/api/workspace/respond",
+        json={"content": "Continue from there."},
+    )
+
+    assert response.status_code == 200
+    events = stream_events(response.text)
+    assert events[-1]["event"] == "error"
+    assert json.loads(events[-1]["data"])["message"] == (
+        "Context could not be optimized."
+    )
+    state = client.get("/api/state").json()
+    assert "Context optimized" not in [
+        message["content"] for message in state["messages"]
+    ]
+
+
+def test_workspace_response_uses_auto_compaction_checkpoint_after_restart(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    monkeypatch.setenv("FLOWENT_AUTO_COMPACT_TOKEN_LIMIT", "120")
+    captured_requests: list[dict[str, object]] = []
+
+    async def fake_completion(**request: object) -> object:
+        captured_requests.append(request)
+        if not request.get("stream"):
+            return {
+                "choices": [
+                    {
+                        "message": {
+                            "content": "Auto checkpoint survives restarts.",
+                            "role": "assistant",
+                        }
+                    }
+                ]
+            }
+
+        async def chunks() -> object:
+            yield {"choices": [{"delta": {"content": "Continuing."}}]}
+
+        return chunks()
+
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client)
+    client.put(
+        "/api/workspace/messages",
+        json={
+            "messages": [
+                {
+                    "author": "user",
+                    "content": "Original request. " * 80,
+                    "id": "message-1",
+                }
+            ]
+        },
+    )
+
+    first_response = client.post(
+        "/api/workspace/respond",
+        json={"content": "Continue from there."},
+    )
+    monkeypatch.setenv("FLOWENT_AUTO_COMPACT_TOKEN_LIMIT", "100000")
+    restarted_client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    second_response = restarted_client.post(
+        "/api/workspace/respond",
+        json={"content": "Continue after restart."},
+    )
+
+    assert first_response.status_code == 200
+    assert second_response.status_code == 200
+    response_messages = captured_requests[2]["messages"]
+    compacted_messages = [
+        message
+        for message in response_messages
+        if str(message["content"]).startswith(
+            "Another language model started working on this Flowent workspace session"
+        )
+    ]
+    assert len(compacted_messages) == 1
+    assert "Auto checkpoint survives restarts." in compacted_messages[0]["content"]
+    assert {"role": "user", "content": "Context optimized"} not in response_messages
+    assert response_messages[-1] == {
+        "role": "user",
+        "content": "Continue after restart.",
+    }
+
+
 def test_workspace_response_includes_project_and_environment_context(
     tmp_path, monkeypatch
 ) -> None:
@@ -973,17 +1259,45 @@ def test_workspace_persists_failed_draft_when_stream_errors(
     assert assistant["author"] == "assistant"
     assert assistant["content"] == "Partial answer."
     assert assistant["status"] == "failed"
+    assert assistant["groups"][-1] == {
+        "id": f"{assistant['id']}-errors",
+        "items": [
+            {
+                "detail": "provider stopped",
+                "id": f"{assistant['id']}-error-1",
+                "message": "Check the model connection settings and try again.",
+                "title": "Request failed",
+                "type": "error",
+            }
+        ],
+    }
 
 
-def test_workspace_marks_draft_complete_when_stream_finishes(
-    tmp_path, monkeypatch
+def test_workspace_persists_error_block_when_responses_stream_fails(
+    tmp_path, monkeypatch, fake_litellm_responses_transformer
 ) -> None:
     monkeypatch.chdir(tmp_path)
     monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
 
     async def fake_completion(**request: object) -> object:
         async def chunks() -> object:
-            yield {"choices": [{"delta": {"content": "Done."}}]}
+            from litellm.completion_extras.litellm_responses_transformation.transformation import (
+                OpenAiResponsesToChatCompletionStreamIterator,
+            )
+
+            yield {"choices": [{"delta": {"content": "Partial answer."}}]}
+            yield OpenAiResponsesToChatCompletionStreamIterator.translate_responses_chunk_to_openai_stream(
+                {
+                    "response": {
+                        "error": {
+                            "code": "upstream_error",
+                            "message": "Upstream request failed",
+                        },
+                        "status": "failed",
+                    },
+                    "type": "response.failed",
+                }
+            )
 
         return chunks()
 
@@ -995,34 +1309,315 @@ def test_workspace_marks_draft_complete_when_stream_finishes(
     response = client.post("/api/workspace/respond", json={"content": "Hello."})
 
     assert response.status_code == 200
+    events = stream_events(response.text)
+    assert events[-1]["event"] == "error"
     state = client.get("/api/state").json()
     assistant = state["messages"][-1]
     assert assistant["author"] == "assistant"
-    assert assistant["content"] == "Done."
-    assert assistant.get("status", "completed") == "completed"
+    assert assistant["content"] == "Partial answer."
+    assert assistant["status"] == "failed"
+    assert json.loads(events[-1]["data"])["error"] == {
+        "detail": "Upstream request failed",
+        "id": f"{assistant['id']}-error-1",
+        "message": "Check the model connection settings and try again.",
+        "title": "Request failed",
+        "type": "error",
+    }
 
 
-@pytest.mark.anyio
-async def test_workspace_run_continues_without_stream_consumer(
+def test_workspace_persists_error_block_when_model_fails_before_output(
     tmp_path, monkeypatch
 ) -> None:
     monkeypatch.chdir(tmp_path)
     monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
-    first_chunk_sent = asyncio.Event()
-    finish_response = asyncio.Event()
 
     async def fake_completion(**request: object) -> object:
-        async def chunks() -> object:
-            yield {"choices": [{"delta": {"content": "Partial "}}]}
-            first_chunk_sent.set()
-            await asyncio.wait_for(finish_response.wait(), timeout=2)
-            yield {"choices": [{"delta": {"content": "answer."}}]}
+        raise RuntimeError("provider unavailable")
 
-        return chunks()
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client)
 
-    app = create_app(serve_frontend=False, chat_completion=fake_completion)
-    async with httpx.AsyncClient(
-        transport=httpx.ASGITransport(app=app), base_url="http://testserver"
+    response = client.post("/api/workspace/respond", json={"content": "Hello."})
+
+    assert response.status_code == 200
+    events = stream_events(response.text)
+    assert events[-1]["event"] == "error"
+    assistant_id = json.loads(events[0]["data"])["id"]
+    assert json.loads(events[-1]["data"]) == {
+        "error": {
+            "detail": "provider unavailable",
+            "id": f"{assistant_id}-error-1",
+            "message": "Check the model connection settings and try again.",
+            "title": "Request failed",
+            "type": "error",
+        },
+        "message": "Check the model connection settings and try again.",
+    }
+    state = client.get("/api/state").json()
+    assistant = state["messages"][-1]
+    assert assistant["author"] == "assistant"
+    assert assistant["content"] == ""
+    assert assistant["status"] == "failed"
+    assert assistant["groups"] == [
+        {
+            "id": f"{assistant['id']}-group-1",
+            "items": [],
+        },
+        {
+            "id": f"{assistant['id']}-errors",
+            "items": [
+                {
+                    "detail": "provider unavailable",
+                    "id": f"{assistant['id']}-error-1",
+                    "message": "Check the model connection settings and try again.",
+                    "title": "Request failed",
+                    "type": "error",
+                }
+            ],
+        },
+    ]
+
+
+def test_workspace_treats_empty_model_result_as_failed_error_block(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+
+    async def fake_completion(**request: object) -> object:
+        async def chunks() -> object:
+            if False:
+                yield {}
+
+        return chunks()
+
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client)
+
+    response = client.post("/api/workspace/respond", json={"content": "Hello."})
+
+    assert response.status_code == 200
+    events = stream_events(response.text)
+    assert events[-1]["event"] == "error"
+    state = client.get("/api/state").json()
+    assistant = state["messages"][-1]
+    assert assistant["status"] == "failed"
+    assert assistant["groups"][-1]["items"] == [
+        {
+            "detail": "The model did not return a response.",
+            "id": f"{assistant['id']}-error-1",
+            "message": "Check the model connection settings and try again.",
+            "title": "Request failed",
+            "type": "error",
+        }
+    ]
+
+
+def test_workspace_includes_previous_error_summary_in_next_request(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    captured_requests: list[dict[str, object]] = []
+
+    async def fake_completion(**request: object) -> object:
+        captured_requests.append(request)
+
+        async def chunks() -> object:
+            yield {"choices": [{"delta": {"content": "Recovered."}}]}
+
+        return chunks()
+
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client)
+    client.put(
+        "/api/workspace/messages",
+        json={
+            "messages": [
+                {
+                    "author": "user",
+                    "content": "Try once.",
+                    "id": "message-user-1",
+                },
+                {
+                    "author": "assistant",
+                    "content": "",
+                    "groups": [
+                        {
+                            "id": "message-assistant-1-errors",
+                            "items": [
+                                {
+                                    "detail": "HTML response returned.",
+                                    "id": "message-assistant-1-error-1",
+                                    "message": "Check the model connection settings and try again.",
+                                    "title": "Request failed",
+                                    "type": "error",
+                                }
+                            ],
+                        }
+                    ],
+                    "id": "message-assistant-1",
+                    "status": "failed",
+                },
+            ]
+        },
+    )
+
+    response = client.post("/api/workspace/respond", json={"content": "Try again."})
+
+    assert response.status_code == 200
+    request_messages = captured_requests[0]["messages"]
+    assert {
+        "role": "assistant",
+        "content": "Previous response failed: Request failed. Check the model connection settings and try again. Detail: HTML response returned.",
+    } in request_messages
+
+
+def test_workspace_marks_running_tool_failed_when_stream_errors(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+
+    async def fake_run_async(self, command, **kwargs):
+        raise RuntimeError("sandbox failed")
+
+    monkeypatch.setattr(SandboxRunner, "run_async", fake_run_async)
+
+    async def fake_completion(**request: object) -> object:
+        async def chunks() -> object:
+            yield tool_call_chunk("shell_command", '{"command": "boom"}')
+
+        return chunks()
+
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client)
+
+    response = client.post("/api/workspace/respond", json={"content": "Run it."})
+
+    assert response.status_code == 200
+    events = stream_events(response.text)
+    assert events[-1]["event"] == "error"
+    state = client.get("/api/state").json()
+    assistant = state["messages"][-1]
+    assert assistant["status"] == "failed"
+    assert assistant["tools"][0]["name"] == "shell_command"
+    assert assistant["tools"][0]["status"] == "failed"
+    assert "sandbox failed" in assistant["tools"][0]["content"]
+
+
+def test_workspace_marks_draft_complete_when_stream_finishes(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+
+    async def fake_completion(**request: object) -> object:
+        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)
+
+    response = client.post("/api/workspace/respond", json={"content": "Hello."})
+
+    assert response.status_code == 200
+    state = client.get("/api/state").json()
+    assistant = state["messages"][-1]
+    assert assistant["author"] == "assistant"
+    assert assistant["content"] == "Done."
+    assert assistant.get("status", "completed") == "completed"
+
+
+def test_workspace_persists_assistant_output_groups_after_tool_round(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    (tmp_path / "notes.txt").write_text("Launch notes")
+    completion_calls = 0
+
+    async def fake_completion(**request: object) -> object:
+        nonlocal completion_calls
+        completion_calls += 1
+
+        async def chunks() -> object:
+            if completion_calls == 1:
+                yield tool_call_chunk("read_file", '{"path": "notes.txt"}')
+                return
+            yield {"choices": [{"delta": {"content": "The notes are ready."}}]}
+
+        return chunks()
+
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client)
+
+    response = client.post("/api/workspace/respond", json={"content": "Read notes."})
+    state = client.get("/api/state").json()
+    assistant = state["messages"][-1]
+    tool_id = assistant["tools"][0]["id"]
+
+    assert response.status_code == 200
+    assert assistant["content"] == "The notes are ready."
+    assert assistant["groups"] == [
+        {
+            "id": f"{assistant['id']}-group-1",
+            "items": [
+                {
+                    "id": f"tool-{tool_id}",
+                    "tool": assistant["tools"][0],
+                    "type": "tool",
+                }
+            ],
+        },
+        {
+            "id": f"{assistant['id']}-group-2",
+            "items": [
+                {
+                    "content": "The notes are ready.",
+                    "id": f"{assistant['id']}-text-1",
+                    "type": "text",
+                }
+            ],
+        },
+    ]
+
+
+@pytest.mark.anyio
+async def test_workspace_run_continues_without_stream_consumer(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    first_chunk_sent = asyncio.Event()
+    finish_response = asyncio.Event()
+
+    async def fake_completion(**request: object) -> object:
+        async def chunks() -> object:
+            yield {"choices": [{"delta": {"content": "Partial "}}]}
+            first_chunk_sent.set()
+            await asyncio.wait_for(finish_response.wait(), timeout=2)
+            yield {"choices": [{"delta": {"content": "answer."}}]}
+
+        return chunks()
+
+    app = create_app(serve_frontend=False, chat_completion=fake_completion)
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app), base_url="http://testserver"
     ) as client:
         await configure_provider_async(client)
         response = await client.post(
@@ -1092,7 +1687,7 @@ async def test_workspace_state_exposes_active_run_for_reconnect(
 
 
 @pytest.mark.anyio
-async def test_workspace_state_exposes_pending_permission_for_reconnect(
+async def test_workspace_persists_automatic_review_result_during_stream(
     tmp_path, monkeypatch
 ) -> None:
     monkeypatch.chdir(tmp_path)
@@ -1110,7 +1705,34 @@ async def test_workspace_state_exposes_pending_permission_for_reconnect(
 +beta
 *** End Patch"""
 
+    review_started = asyncio.Event()
+    finish_review = asyncio.Event()
+    review_payload: dict[str, object] = {}
+
     async def fake_completion(**request: object) -> object:
+        messages = request["messages"]
+        if messages[0]["content"].startswith("You are Flowent Approval Reviewer"):
+            review_payload.update(json.loads(messages[-1]["content"]))
+            review_started.set()
+            await asyncio.wait_for(finish_review.wait(), timeout=2)
+            return {
+                "choices": [
+                    {
+                        "message": {
+                            "content": json.dumps(
+                                {
+                                    "risk_level": "high",
+                                    "risk_score": 85,
+                                    "rationale": "Outside the task scope.",
+                                    "evidence": [],
+                                }
+                            ),
+                            "role": "assistant",
+                        }
+                    }
+                ]
+            }
+
         async def chunks() -> object:
             if request["messages"][-1]["role"] == "user":
                 yield tool_call_chunk(
@@ -1136,28 +1758,141 @@ async def test_workspace_state_exposes_pending_permission_for_reconnect(
             json={"content": "Edit notes."},
         )
         run_id = response.json()["run_id"]
-
-        for _ in range(20):
-            state = (await client.get("/api/state")).json()
-            if state.get("permission_requests"):
-                break
-            await asyncio.sleep(0.05)
-        else:
-            raise AssertionError("Permission request was not exposed.")
-
-        request = state["permission_requests"][0]
-        await client.post(
-            "/api/workspace/permissions/approve",
-            json={"decision": "deny", "id": request["id"]},
+        await asyncio.wait_for(review_started.wait(), timeout=2)
+        state = (await client.get("/api/state")).json()
+        finish_review.set()
+        stream_response = await client.get(
+            f"/api/workspace/runs/{run_id}/stream?after={state['active_run_event_index']}"
         )
 
     assistant = state["messages"][-1]
     assert state["active_run_id"] == run_id
-    assert request["path"] == str(outside_dir)
-    assert request["reason"] == "The edit needs to write this path."
-    assert request["tool_call_id"] == assistant["tools"][0]["id"]
     assert assistant["tools"][0]["name"] == "apply_patch"
-    assert assistant["tools"][0]["status"] == "waiting"
+    assert assistant["tools"][0]["status"] == "running"
+    events = stream_events(stream_response.text)
+    tool_error = next(event for event in events if event["event"] == "tool_error")
+    tool_error_data = json.loads(str(tool_error["data"]))
+    assert tool_error_data["data"]["approval"]["decision"] == "denied"
+    assert tool_error_data["data"]["approval"]["reason"] == "Outside the task scope."
+    assert review_payload["user_request"] == "Edit notes."
+    assert target.read_text() == "alpha\n"
+
+
+@pytest.mark.anyio
+async def test_workspace_review_request_includes_recent_transcript(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    work_dir = tmp_path / "work"
+    work_dir.mkdir()
+    review_payload: dict[str, object] = {}
+
+    async def fake_completion(**request: object) -> object:
+        messages = request["messages"]
+        if messages[0]["content"].startswith("You are Flowent Approval Reviewer"):
+            review_payload.update(json.loads(messages[-1]["content"]))
+            return {
+                "choices": [
+                    {
+                        "message": {
+                            "content": json.dumps(
+                                {
+                                    "risk_level": "high",
+                                    "risk_score": 85,
+                                    "rationale": "No run is needed for this test.",
+                                    "evidence": [],
+                                }
+                            ),
+                            "role": "assistant",
+                        }
+                    }
+                ]
+            }
+
+        async def chunks() -> object:
+            if request["messages"][-1]["role"] == "user":
+                yield tool_call_chunk(
+                    "shell_command",
+                    json.dumps(
+                        {
+                            "additional_permissions": {
+                                "file_system": {"write": ["/var/run/docker.sock"]}
+                            },
+                            "command": (
+                                "docker compose up -d --force-recreate flowent"
+                            ),
+                            "sandbox_permissions": "with_additional_permissions",
+                        }
+                    ),
+                )
+                return
+            yield {"choices": [{"delta": {"content": "Stopped."}}]}
+
+        return chunks()
+
+    app = create_app(
+        workdir=work_dir,
+        serve_frontend=False,
+        chat_completion=fake_completion,
+    )
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app), base_url="http://testserver"
+    ) as client:
+        await configure_provider_async(client)
+        await client.put(
+            "/api/workspace/messages",
+            json={
+                "messages": [
+                    {
+                        "author": "user",
+                        "content": "Can you recreate the dev container?",
+                        "id": "user-1",
+                    },
+                    {
+                        "author": "assistant",
+                        "content": (
+                            "This will recreate the Flowent dev container through "
+                            "Docker and may briefly interrupt the running service."
+                        ),
+                        "id": "assistant-1",
+                        "tools": [
+                            {
+                                "arguments": {"command": "docker compose ps"},
+                                "content": "flowent-dev-preview-flowent-1 running",
+                                "data": {},
+                                "id": "tool-1",
+                                "name": "shell_command",
+                                "status": "success",
+                                "title": "Ran docker compose ps",
+                            }
+                        ],
+                    },
+                ]
+            },
+        )
+        response = await client.post(
+            "/api/workspace/runs",
+            json={"content": "确认"},
+        )
+        run_id = response.json()["run_id"]
+        stream_response = await client.get(f"/api/workspace/runs/{run_id}/stream")
+
+    events = stream_events(stream_response.text)
+    assert "tool_error" in [event["event"] for event in events]
+    assert review_payload["user_request"] == "确认"
+    transcript = review_payload["transcript"]
+    assert {"role": "user", "content": "确认"} in transcript
+    assert any(
+        entry["role"] == "assistant" and "briefly interrupt" in entry["content"]
+        for entry in transcript
+    )
+    assert any(
+        entry["role"] == "tool"
+        and entry["name"] == "shell_command"
+        and "flowent-dev-preview-flowent-1" in entry["content"]
+        for entry in transcript
+    )
 
 
 @pytest.mark.anyio
@@ -1306,3 +2041,134 @@ def test_workspace_compact_is_unavailable_while_response_is_running(
         assert response.status_code == 200
 
     asyncio.run(run_test())
+
+
+def configured_agent_prompt_message(
+    request: dict[str, object],
+) -> dict[str, object] | None:
+    for message in request["messages"]:
+        if str(message["content"]).startswith("# Flowent configured agent prompt"):
+            return message
+    return None
+
+
+def test_workspace_response_includes_configured_agent_prompt_before_agents_md(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    (tmp_path / ".git").mkdir()
+    (tmp_path / "AGENTS.md").write_text("Use project instructions.")
+    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, agent_prompt="Use UI configured instructions first.")
+
+    response = client.post("/api/workspace/respond", json={"content": "Hello."})
+
+    assert response.status_code == 200
+    configured_message = configured_agent_prompt_message(captured_request)
+    project_message = project_context_message(captured_request)
+    assert configured_message is not None
+    assert project_message is not None
+    assert configured_message["role"] == "system"
+    assert "Use UI configured instructions first." in configured_message["content"]
+    assert "Use project instructions." in project_message["content"]
+    assert captured_request["messages"].index(configured_message) < captured_request[
+        "messages"
+    ].index(project_message)
+
+
+def test_workspace_compacted_response_includes_latest_configured_agent_prompt(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    captured_requests: list[dict[str, object]] = []
+
+    async def fake_completion(**request: object) -> object:
+        captured_requests.append(request)
+        if len(captured_requests) == 1:
+            return {
+                "choices": [
+                    {
+                        "message": {
+                            "content": "Keep compacted state.",
+                            "role": "assistant",
+                        }
+                    }
+                ]
+            }
+
+        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, agent_prompt="Prompt before compact.")
+    client.put(
+        "/api/workspace/messages",
+        json={
+            "messages": [
+                {"author": "user", "content": "Original request.", "id": "message-1"}
+            ]
+        },
+    )
+
+    compact_response = client.post("/api/workspace/compact")
+    client.put(
+        "/api/settings",
+        json={
+            "agent_prompt": "Prompt after compact.",
+            "reasoning_effort": "default",
+            "selected_model": "gpt-5.1",
+            "selected_provider_id": "provider-openai",
+        },
+    )
+    response = client.post("/api/workspace/respond", json={"content": "Continue."})
+
+    assert compact_response.status_code == 200
+    assert response.status_code == 200
+    configured_message = configured_agent_prompt_message(captured_requests[1])
+    assert configured_message is not None
+    assert "Prompt after compact." in configured_message["content"]
+    assert "Prompt before compact." not in configured_message["content"]
+
+
+def test_workspace_response_trims_blank_configured_agent_prompt(
+    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, agent_prompt="\n\n")
+
+    response = client.post("/api/workspace/respond", json={"content": "Hello."})
+
+    assert response.status_code == 200
+    assert configured_agent_prompt_message(captured_request) is None