Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
"""Tests for ``POST /api/sessions/<id>/messages`` (fire-and-forget dispatch)
and ``POST /api/sessions/<id>/cancel`` in ``vibe.ui_server``.
These cover the bridge between the browser and the controller's Unix socket:
the session/page-scoped model persists the user row and fire-and-forgets the
turn (the reply arrives over the ``message.new`` stream). We mock
``vibe.internal_client`` so the tests stay hermetic and don't need a real
controller process.
"""
from __future__ import annotations
import json
import sqlite3
import sys
from contextlib import contextmanager
from pathlib import Path
from types import SimpleNamespace
from typing import Any
from unittest.mock import AsyncMock, Mock, patch
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
import pytest
from sqlalchemy import select, update
from storage.importer import ensure_sqlite_state
from storage.db import create_sqlite_engine
from storage import message_deliveries, messages_service
from storage.models import agent_sessions, messages
from storage.models import scope_settings
from storage.settings_service import upsert_scope
from tests.ui_server_test_helpers import _save_config, csrf_headers, remote_session_cookie
from vibe import remote_access
@pytest.fixture()
def isolated_state(monkeypatch, tmp_path):
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
ensure_sqlite_state()
yield tmp_path
def _make_session(
tmp_path: Path,
*,
agent_name: str = "worker",
agent_backend: str = "claude",
) -> tuple[str, str]:
"""Create a real avibe project + session row so the route handler
can find it. Returns ``(scope_id, session_id)``.
"""
from core.services import sessions as sessions_service
from storage.db import create_sqlite_engine
agent = _ensure_vibe_agent(agent_name, agent_backend)
engine = create_sqlite_engine()
with engine.begin() as conn:
scope_id = upsert_scope(
conn,
platform="avibe",
scope_type="project",
native_id="proj_stream",
now="2026-05-26T13:00:00Z",
)
conn.execute(
scope_settings.insert().values(
scope_id=scope_id,
enabled=1,
role=None,
workdir=str(tmp_path),
agent_name=None,
agent_backend=None,
agent_variant=None,
model=None,
reasoning_effort=None,
require_mention=None,
settings_version=1,
settings_json="{}",
created_at="2026-05-26T13:00:00Z",
updated_at="2026-05-26T13:00:00Z",
)
)
session = sessions_service.create_session(
conn,
scope_id=scope_id,
agent_backend=agent.backend,
agent_id=agent.id,
agent_name=agent.name,
)
return scope_id, session["id"]
def _ensure_vibe_agent(name: str, backend: str):
from core.vibe_agents import VibeAgentStore
store = VibeAgentStore()
try:
agent = store.get(name)
if agent is None:
agent = store.create(name=name, backend=backend)
return agent
finally:
store.close()
def _seed_opencode_messages(xdg_home: Path, native_session_id: str, roles: list[str]) -> None:
db_path = xdg_home / "opencode" / "opencode.db"
db_path.parent.mkdir(parents=True, exist_ok=True)
with sqlite3.connect(db_path) as conn:
conn.execute("CREATE TABLE message (id TEXT PRIMARY KEY, data TEXT)")
conn.execute(
"CREATE TABLE part (id TEXT PRIMARY KEY, session_id TEXT, message_id TEXT, time_created INTEGER, data TEXT)"
)
for index, role in enumerate(roles, start=1):
message_id = f"oc-msg-{index}"
conn.execute(
"INSERT INTO message (id, data) VALUES (?, ?)",
(message_id, json.dumps({"role": role})),
)
conn.execute(
"INSERT INTO part (id, session_id, message_id, time_created, data) VALUES (?, ?, ?, ?, ?)",
(f"part-{index}", native_session_id, message_id, index, json.dumps({"type": "text"})),
)
def _settle_reserved_delivery(payload: dict, *, state: str) -> dict:
with create_sqlite_engine().begin() as conn:
delivery = message_deliveries.get_delivery(conn, payload["user_message_id"])
assert delivery is not None and delivery["state"] == "reserved"
if state == "queued":
settled = message_deliveries.cas_delivery(
conn,
delivery["id"],
expected_version=delivery["version"],
expected_states=("reserved",),
values={"state": "queued"},
)
else:
turn_id = message_deliveries.new_turn_id()
message_deliveries.insert_turn(
conn,
turn_id=turn_id,
session_id=delivery["session_id"],
initial_delivery_id=delivery["id"],
state="starting",
backend="claude",
)
attempt_id = message_deliveries.new_attempt_id()
message_deliveries.open_start_attempt(
conn,
delivery["id"],
expected_version=delivery["version"],
turn_id=turn_id,
attempt_id=attempt_id,
)
turn = message_deliveries.get_turn(conn, turn_id)
assert turn is not None
assert message_deliveries.bind_native_start(
conn,
turn_id,
expected_version=int(turn["version"]),
runtime_key=f"runtime:{turn_id}",
runtime_turn_id=f"runtime-turn:{turn_id}",
native_turn_id=f"native:{turn_id}",
) is not None
accepted = message_deliveries.materialize_start_acceptance(
conn,
turn_id=turn_id,
evidence={"kind": "test_native_acceptance"},
)
settled = accepted[0] if accepted else None
assert settled is not None
return settled
def _seed_claimed_batch(
*,
scope_id: str,
session_id: str,
texts: list[str],
platform: str = "avibe",
metadata: dict[str, Any] | None = None,
) -> dict[str, Any]:
"""Create the pre-native-write state that must remain visible in Chat."""
with create_sqlite_engine().begin() as conn:
deliveries = [
message_deliveries.insert_delivery(
conn,
delivery_id=f"msg_claimed_{session_id}_{index}",
session_id=session_id,
priority="p1",
state="reserved",
snapshot=message_deliveries.message_snapshot(
scope_id=scope_id,
session_id=session_id,
platform=platform,
author="user",
source="user",
text=text,
metadata=metadata,
),
dispatch_text=text,
)
for index, text in enumerate(texts)
]
turn_id = message_deliveries.new_turn_id()
return message_deliveries.claim_start_batch(
conn,
turn_id=turn_id,
session_id=session_id,
backend="opencode",
deliveries=deliveries,
dispatch_text="\n".join(texts),
)
def _accepted_dispatch(session_id: str) -> AsyncMock:
async def dispatch(payload: dict) -> dict:
settled = _settle_reserved_delivery(payload, state="accepted")
return {
"status_code": 202,
"body": {
"ok": True,
"session_id": session_id,
"delivery_state": settled["state"],
},
}
return AsyncMock(side_effect=dispatch)
@pytest.mark.parametrize(
"payload",
[
{"text": "Yes", "metadata": {"quick_reply_for": "agent-message-1"}},
{"text": "forwarded text", "metadata": {"forwarded": True}},
],
)
def test_workbench_side_actions_have_fail_closed_core_message_kinds(
isolated_state,
tmp_path,
payload,
):
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
dispatch = _accepted_dispatch(session_id)
with patch("vibe.internal_client.dispatch_async", dispatch):
client = app.test_client()
response = client.post(
f"/api/sessions/{session_id}/messages",
json=payload,
headers=csrf_headers(client),
)
assert response.status_code == 201
expected_kind = (
"quick_reply"
if "quick_reply_for" in payload.get("metadata", {})
else "forwarded"
)
assert dispatch.await_args.args[0]["message_kind"] == expected_kind
assert response.get_json()["draft_advanced"] is (
"quick_reply_for" not in payload.get("metadata", {})
)
def test_quick_reply_choice_publishes_the_answered_row_after_it_commits(
isolated_state,
tmp_path,
):
"""Scenario: other windows (another tab, the desktop pet) learn that a
quick-reply group was answered from one ``message.updated`` event that is
published only after the choice is persisted, and only once."""
from vibe.ui_server import app
scope_id, session_id = _make_session(tmp_path)
engine = create_sqlite_engine()
with engine.begin() as conn:
agent_row = messages_service.append(
conn,
scope_id=scope_id,
session_id=session_id,
platform="avibe",
author="agent",
source="agent",
message_type="result",
text="Pick one",
content={"kind": "result", "quick_replies": ["Yes", "No"]},
)
published: list[tuple[str, dict, str | None]] = []
def record(event_type: str, data: Any) -> None:
# Read the committed row at publish time: the event must never
# precede the write it announces.
with engine.connect() as conn:
persisted = messages_service.get_quick_reply_chosen(
conn, session_id, agent_row["id"],
)
published.append((event_type, data, persisted))
client = app.test_client()
headers = csrf_headers(client)
with patch("vibe.internal_client.dispatch_async", _accepted_dispatch(session_id)), \
patch("vibe.sse_broker.broker.publish", side_effect=record):
first = client.post(
f"/api/sessions/{session_id}/messages",
json={"text": "Yes", "metadata": {"quick_reply_for": agent_row["id"]}},
headers=headers,
)
updates_after_first = [event for event in published if event[0] == "message.updated"]
second = client.post(
f"/api/sessions/{session_id}/messages",
json={"text": "No", "metadata": {"quick_reply_for": agent_row["id"]}},
headers=headers,
)
assert first.status_code == 201
assert second.get_json() == {"already_answered": True}
assert len(updates_after_first) == 1
_, data, persisted = updates_after_first[0]
assert data["id"] == agent_row["id"]
assert data["session_id"] == session_id
assert data["content"]["quick_reply_chosen"] == "Yes"
assert persisted == "Yes"
# Set-once: the second click records nothing new, so it publishes no update.
assert [event for event in published if event[0] == "message.updated"] == updates_after_first
def test_workbench_text_uses_authenticated_author_and_core_message_kind(
isolated_state,
tmp_path,
):
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
dispatch = _accepted_dispatch(session_id)
client = app.test_client()
headers = csrf_headers(client, "http://127.0.0.1:15131")
with patch("vibe.internal_client.dispatch_async", dispatch):
response = client.post(
f"/api/sessions/{session_id}/messages",
json={"text": "/memory status"},
headers=headers,
base_url="http://127.0.0.1:15131",
environ_base={"REMOTE_ADDR": "127.0.0.1"},
)
assert response.status_code == 201
response_payload = response.get_json()
assert response_payload["text"] == "/memory status"
payload = dispatch.await_args.args[0]
assert payload["text"] == "/memory status"
assert payload["author_id"] == "local"
assert payload["message_id"] == response_payload["id"]
assert payload["message_kind"] == "original"
assert "memory_cli_admitted" not in payload
assert "user_id" not in payload
def test_workbench_dispatch_propagates_attachment_and_resolved_identity(
isolated_state,
tmp_path,
):
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
dispatch = _accepted_dispatch(session_id)
client = app.test_client()
headers = csrf_headers(client, "http://127.0.0.1:15131")
upload = client.post(
f"/api/sessions/{session_id}/attachments",
data={"upload_id": "upload-id-123456"},
files={"file": ("diagram.png", b"attachment-bytes", "image/png")},
headers=headers,
base_url="http://127.0.0.1:15131",
)
assert upload.status_code == 201
with patch("vibe.internal_client.dispatch_async", dispatch):
response = client.post(
f"/api/sessions/{session_id}/messages",
json={
"content": {
"text": "remember this diagram",
"attachments": [{"token": upload.get_json()["token"]}],
}
},
headers=headers,
base_url="http://127.0.0.1:15131",
environ_base={"REMOTE_ADDR": "127.0.0.1"},
)
assert response.status_code == 201
payload = dispatch.await_args.args[0]
assert payload["author_id"] == "local"
assert payload["message_kind"] == "original"
assert payload["message_id"] == response.get_json()["id"]
assert len(payload["files"]) == 1
assert payload["files"][0]["name"] == "diagram.png"
assert Path(payload["files"][0]["path"]).read_bytes() == b"attachment-bytes"
def test_queued_projection_carries_the_uploaded_file_identity(isolated_state, tmp_path):
"""A queued message names the file it is waiting to send, in the shape the
queue strip draws (issue #2042).
The strip renders a thumbnail only for a same-origin ``/api/media/<token>``
URL, and resolves the rest from ``content.attachments``. That makes three
things a backend contract rather than a browser detail: the upload hands back
that URL and a ``kind``, the queued projection still carries them on both the
live queue read and the reload path, and the same token still resolves to the
uploaded bytes — so the file previewed in the queue is the file that reaches
the turn when it flushes.
"""
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
client = app.test_client()
headers = csrf_headers(client, "http://127.0.0.1:15131")
upload = client.post(
f"/api/sessions/{session_id}/attachments",
data={"upload_id": "upload-id-queued-1"},
files={"file": ("annotation-region.png", b"queued-image-bytes", "image/png")},
headers=headers,
base_url="http://127.0.0.1:15131",
)
assert upload.status_code == 201
uploaded = upload.get_json()
# Same-origin media proxy, not a remote URL: this is the one form the queue
# row is allowed to put in an <img src>.
assert uploaded["url"] == f"/api/media/{uploaded['token']}"
assert uploaded["kind"] == "image"
assert uploaded["name"] == "annotation-region.png"
async def dispatch(payload):
settled = _settle_reserved_delivery(payload, state="queued")
return {
"status_code": 202,
"body": {"ok": True, "queued": True, "delivery_state": settled["state"]},
}
sent_attachment = {
"token": uploaded["token"],
"name": uploaded["name"],
"mime": uploaded["mime"],
"size": uploaded["size"],
"kind": uploaded["kind"],
"url": uploaded["url"],
}
with patch("vibe.internal_client.dispatch_async", AsyncMock(side_effect=dispatch)):
response = client.post(
f"/api/sessions/{session_id}/messages",
json={"text": "", "content": {"text": "", "attachments": [sent_attachment]}},
headers=headers,
base_url="http://127.0.0.1:15131",
environ_base={"REMOTE_ADDR": "127.0.0.1"},
)
assert response.status_code == 202
assert response.get_json()["queued"] is True
def queued_attachment(body: dict) -> dict:
assert len(body["queued"]) == 1
content = body["queued"][0]["content"]
assert len(content["attachments"]) == 1
return content["attachments"][0]
# The live queue read and the reload path project the same identity — an
# image-only queued row stays identifiable across a refresh.
live = client.get(f"/api/sessions/{session_id}/queue")
assert live.status_code == 200
assert queued_attachment(live.get_json()) == sent_attachment
with patch(
"vibe.api.get_vibe_agents",
return_value={"agents": [], "default_agent_name": None},
):
bootstrap = client.get(f"/api/sessions/{session_id}/bootstrap")
assert bootstrap.status_code == 200
assert queued_attachment(bootstrap.get_json()) == sent_attachment
# The previewed URL is fetchable same-origin, and the token the preview was
# drawn from is the one the flush resolves into the agent turn.
media = client.get(uploaded["url"])
assert media.status_code == 200
assert media.content == b"queued-image-bytes"
from core.workbench_media import resolve_attachment_specs
from storage.db import create_sqlite_engine
with create_sqlite_engine().connect() as conn:
specs = resolve_attachment_specs(
conn,
session_id=session_id,
attachments=[queued_attachment(live.get_json())],
)
assert len(specs) == 1
assert specs[0]["name"] == "annotation-region.png"
assert Path(specs[0]["path"]).read_bytes() == b"queued-image-bytes"
def test_route_reads_the_materialized_message_id_for_a_merged_batch(
isolated_state,
tmp_path,
) -> None:
from vibe.ui_server import app
scope_id, session_id = _make_session(tmp_path)
older_delivery_id = "msg_merged_segment_head"
async def dispatch(payload):
with create_sqlite_engine().begin() as conn:
current = message_deliveries.get_delivery(conn, payload["user_message_id"])
assert current is not None and current["state"] == "reserved"
older = message_deliveries.insert_delivery(
conn,
delivery_id=older_delivery_id,
session_id=session_id,
priority="p3",
state="queued",
snapshot=message_deliveries.message_snapshot(
scope_id=scope_id,
session_id=session_id,
platform="avibe",
author="user",
source="user",
text="older queued input",
metadata={"_web_push_user_key": "remote:user-a"},
author_id="remote:user-a",
message_kind="original",
),
dispatch_text="older queued input",
now="2026-01-01T00:00:00Z",
)
turn_id = message_deliveries.new_turn_id()
claimed = message_deliveries.claim_start_batch(
conn,
turn_id=turn_id,
session_id=session_id,
backend="claude",
deliveries=[older, current],
dispatch_text="older queued input\nnew input",
)
turn = claimed["turn"]
assert message_deliveries.bind_native_start(
conn,
turn_id,
expected_version=int(turn["version"]),
runtime_key=f"runtime:{turn_id}",
runtime_turn_id=f"runtime-turn:{turn_id}",
native_turn_id=f"native:{turn_id}",
) is not None
accepted = message_deliveries.materialize_start_acceptance(
conn,
turn_id=turn_id,
evidence={"kind": "test_native_acceptance"},
)
current_after = message_deliveries.get_delivery(
conn,
payload["user_message_id"],
)
assert accepted and current_after is not None
return {
"status_code": 202,
"body": {
"ok": True,
"session_id": session_id,
"delivery_id": payload["user_message_id"],
"message_id": accepted[0]["message_id"],
"delivery_state": current_after["state"],
},
}
with (
patch("vibe.internal_client.dispatch_async", AsyncMock(side_effect=dispatch)),
patch("vibe.ui_server._web_push_user_key", return_value="remote:user-a"),
patch(
"vibe.ui_server._workbench_author_id",
return_value="remote:user-a",
),
):
client = app.test_client()
response = client.post(
f"/api/sessions/{session_id}/messages",
json={"text": "new input"},
headers=csrf_headers(client),
)
assert response.status_code == 201
body = response.get_json()
assert body["id"] == older_delivery_id
assert body["message_id"] == older_delivery_id
assert body["delivery_id"] != older_delivery_id
def test_route_enqueues_when_turn_in_progress(isolated_state, tmp_path):
"""When the controller reports a turn already running (202 {queued}), the
route persists the user row, hands its id to the controller to re-type as
queued, and returns 202 {queued:true} marked as the queued type. (The actual
re-type is the controller's atomic job, covered in test_internal_server.)"""
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
async def dispatch(payload):
settled = _settle_reserved_delivery(payload, state="queued")
return {
"status_code": 202,
"body": {
"ok": True,
"queued": True,
"delivery_state": settled["state"],
},
}
dispatch_mock = AsyncMock(side_effect=dispatch)
with patch("vibe.internal_client.dispatch_async", dispatch_mock):
client = app.test_client()
headers = csrf_headers(client)
response = client.post(
f"/api/sessions/{session_id}/messages",
json={"text": "while busy"},
headers=headers,
)
assert response.status_code == 202
body = response.get_json()
assert body["queued"] is True
assert body["type"] == "queued"
assert body["text"] == "while busy"
# The user row was persisted first, and its id handed to the controller to
# re-type as queued (atomic, no second row).
dispatch_mock.assert_awaited_once()
sent = dispatch_mock.await_args.args[0]
assert sent["user_message_id"] == body["id"]
@pytest.mark.parametrize(
("error_kind", "expected_status", "expected_error", "expected_delivery_state"),
(
("timeout", 504, "dispatch_pending", "reserved"),
("ambiguous", 502, "dispatch_pending", "reserved"),
("unavailable", 502, "internal_unavailable", "retired"),
),
)
def test_route_dispatch_failure_classifies_unclaimed_delivery_outside_transcript(
isolated_state,
tmp_path,
monkeypatch,
error_kind,
expected_status,
expected_error,
expected_delivery_state,
):
from vibe import internal_client
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
published = []
async def fail_after_connect(_payload):
if error_kind == "timeout":
raise internal_client.InternalServerTimeout("acceptance unknown")
if error_kind == "unavailable":
raise internal_client.InternalServerUnavailable("socket missing")
raise RuntimeError("ambiguous response")
monkeypatch.setattr(
"vibe.sse_broker.broker.publish",
lambda event_type, data: published.append((event_type, data)),
)
dispatch_mock = AsyncMock(side_effect=fail_after_connect)
with patch("vibe.internal_client.dispatch_async", dispatch_mock):
client = app.test_client()
response = client.post(
f"/api/sessions/{session_id}/messages",
json={"text": "settle this after the timeout"},
headers=csrf_headers(client),
)
assert response.status_code == expected_status
body = response.get_json()
assert body["dispatch_error"] == expected_error
assert body["type"] == "user"
dispatch_mock.assert_awaited_once()
with create_sqlite_engine().connect() as conn:
queued = message_deliveries.list_queued(conn, session_id)
visible = messages_service.list_session_messages(
conn,
session_id=session_id,
around_id=body["id"],
limit=1,
types=messages_service.TRANSCRIPT_TYPES,
)
delivery = message_deliveries.get_delivery(conn, body["id"])
assert queued == []
assert visible["messages"] == []
assert delivery is not None and delivery["state"] == expected_delivery_state
assert "message.new" not in [event_type for event_type, _data in published]
def test_route_definitive_dispatch_rejection_retires_reserved_delivery(
isolated_state,
tmp_path,
):
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
dispatch_mock = AsyncMock(
return_value={
"status_code": 500,
"body": {"error": "backend resolution failed"},
}
)
with patch("vibe.internal_client.dispatch_async", dispatch_mock):
client = app.test_client()
response = client.post(
f"/api/sessions/{session_id}/messages",
json={"text": "definitively rejected"},
headers=csrf_headers(client),
)
assert response.status_code == 502
body = response.get_json()
assert body["dispatch_error"] == "dispatch_failed"
with create_sqlite_engine().connect() as conn:
delivery = message_deliveries.get_delivery(conn, body["id"])
assert delivery is not None and delivery["state"] == "retired"
def test_route_timeout_observes_controller_queue_without_republishing(
isolated_state,
tmp_path,
monkeypatch,
):
from vibe import internal_client
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
published = []
async def timeout_after_controller_queues(payload):
_settle_reserved_delivery(payload, state="queued")
published.append(("queue.updated", {"session_id": session_id}))
raise internal_client.InternalServerTimeout("response lost after enqueue")
monkeypatch.setattr(
"vibe.sse_broker.broker.publish",
lambda event_type, data: published.append((event_type, data)),
)
dispatch_mock = AsyncMock(side_effect=timeout_after_controller_queues)
with patch("vibe.internal_client.dispatch_async", dispatch_mock):
client = app.test_client()
response = client.post(
f"/api/sessions/{session_id}/messages",
json={"text": "already queued by the controller"},
headers=csrf_headers(client),
)
assert response.status_code == 504
body = response.get_json()
assert body["dispatch_error"] == "dispatch_pending"
assert body["type"] == "queued"
dispatch_mock.assert_awaited_once()
with create_sqlite_engine().connect() as conn:
queued = message_deliveries.list_queued(conn, session_id)
assert [row["id"] for row in queued] == [body["id"]]
assert "message.new" not in [event_type for event_type, _data in published]
assert [event_type for event_type, _data in published].count("queue.updated") == 1
def test_startup_has_no_type_owned_pending_recovery(isolated_state, tmp_path):
from vibe import ui_server
scope_id, session_id = _make_session(tmp_path)
engine = create_sqlite_engine()
with engine.begin() as conn:
pending = message_deliveries.insert_delivery(
conn,
delivery_id="msg_reserved_startup",
session_id=session_id,
priority="p1",
state="reserved",
snapshot=message_deliveries.message_snapshot(
scope_id=scope_id,
session_id=session_id,
platform="avibe",
author="user",
source="user",
text="stuck reserved",
),
dispatch_text="stuck reserved",
)
assert not hasattr(ui_server, "_recover_stale_pending_messages")
with engine.connect() as conn:
stored = message_deliveries.get_delivery(conn, pending["id"])
materialized = conn.execute(
select(messages.c.id).where(messages.c.id == pending["id"])
).scalar_one_or_none()
assert stored is not None and stored["state"] == "reserved"
assert materialized is None
def test_create_session_without_backend_defers_to_default_agent(isolated_state, tmp_path):
"""POST /api/sessions with no ``agent_backend`` must NOT stamp a concrete
backend onto the session. A stamped backend is treated by message_handler
as an explicit override and bypasses default Vibe Agent resolution, so a
plain "new chat" leaves the backend empty and lets the shared resolver
pick the configured default agent at dispatch time.
"""
from storage import projects_service
from storage.db import create_sqlite_engine
from vibe.ui_server import app
engine = create_sqlite_engine()
with engine.begin() as conn:
project = projects_service.create_project(conn, folder_path=str(tmp_path))
client = app.test_client()
headers = csrf_headers(client)
response = client.post(
"/api/sessions",
json={"project_id": project["id"]},
headers=headers,
)
assert response.status_code == 201
# Empty/absent backend — resolution is deferred to dispatch, not pinned here.
assert not response.get_json().get("agent_backend")
def test_create_and_patch_session_reject_archived_agent(isolated_state, tmp_path):
from core.vibe_agents import VibeAgentStore
from storage import projects_service
from storage.db import create_sqlite_engine
from vibe.ui_server import app
engine = create_sqlite_engine()
with engine.begin() as conn:
project = projects_service.create_project(conn, folder_path=str(tmp_path))
store = VibeAgentStore()
try:
store.create(name="archive-fallback", backend="codex")
original = store.create(name="retired-reviewer", backend="codex")
archived = store.archive("retired-reviewer")
assert archived is not None
replacement = store.create(name="retired-reviewer", backend="codex")
finally:
store.close()
client = app.test_client()
headers = csrf_headers(client)
create_response = client.post(
"/api/sessions",
json={
"project_id": project["id"],
"agent_backend": "codex",
"agent_name": archived.archived_name,
},
headers=headers,
)
assert create_response.status_code == 404
assert "not found or disabled" in create_response.get_json()["error"]
for invalid_identity in (
{"agent_id": original.id},
{"agent_id": original.id, "agent_name": replacement.name},
):
create_response = client.post(
"/api/sessions",
json={"project_id": project["id"], **invalid_identity},
headers=headers,
)
assert create_response.status_code == 404
assert "not found or disabled" in create_response.get_json()["error"]
session_response = client.post(
"/api/sessions",
json={"project_id": project["id"]},
headers=headers,
)
session_id = session_response.get_json()["id"]
patch_response = client.patch(
f"/api/sessions/{session_id}",
json={
"agent_backend": "codex",
"agent_name": archived.archived_name,
},
headers=headers,
)
assert patch_response.status_code == 404
assert "not found or disabled" in patch_response.get_json()["error"]
for invalid_identity in (
{"agent_id": original.id},
{"agent_id": original.id, "agent_name": replacement.name},
):
patch_response = client.patch(
f"/api/sessions/{session_id}",
json=invalid_identity,
headers=headers,
)
assert patch_response.status_code == 404
assert "not found or disabled" in patch_response.get_json()["error"]
def test_create_and_patch_session_canonicalize_agent_identity(isolated_state, tmp_path):
from core.vibe_agents import VibeAgentStore
from storage import projects_service
from storage.db import create_sqlite_engine
from vibe.ui_server import app
engine = create_sqlite_engine()
with engine.begin() as conn:
project = projects_service.create_project(conn, folder_path=str(tmp_path))
store = VibeAgentStore()
try:
agent = store.create(name="active-reviewer", backend="codex")
finally:
store.close()
client = app.test_client()
headers = csrf_headers(client)
create_response = client.post(
"/api/sessions",
json={
"project_id": project["id"],
"agent_id": agent.id,
"agent_backend": "claude",
},
headers=headers,
)
assert create_response.status_code == 201
created = create_response.get_json()
assert (created["agent_id"], created["agent_name"], created["agent_backend"]) == (
agent.id,
agent.name,
agent.backend,
)
plain_response = client.post(
"/api/sessions",
json={"project_id": project["id"]},
headers=headers,
)
patch_response = client.patch(
f"/api/sessions/{plain_response.get_json()['id']}",
json={"agent_id": agent.id},
headers=headers,
)
assert patch_response.status_code == 200
patched = patch_response.get_json()
assert (patched["agent_id"], patched["agent_name"], patched["agent_backend"]) == (
agent.id,
agent.name,
agent.backend,
)
cleared_response = client.patch(
f"/api/sessions/{plain_response.get_json()['id']}",
json={"agent_name": None},
headers=headers,
)
assert cleared_response.status_code == 200
cleared = cleared_response.get_json()
assert cleared["agent_id"] is None
assert cleared["agent_name"] is None
# Clearing the Agent selector does not clear the durable backend pin.
assert cleared["agent_backend"] == "codex"
def test_fork_session_creates_new_workbench_session(isolated_state, tmp_path):
"""POST /api/sessions/<id>/fork reserves a new Avibe Session row that is
ready for the native backend fork on the first turn, and returns the row the
sidebar needs to prepend/navigate immediately.
"""
from sqlalchemy import update
from storage import messages_service
from storage.db import create_sqlite_engine
from storage.models import agent_sessions
from vibe.ui_server import app
scope_id, session_id = _make_session(tmp_path)
engine = create_sqlite_engine()
with engine.begin() as conn:
conn.execute(
update(agent_sessions)
.where(agent_sessions.c.id == session_id)
.values(native_session_id="native-source-1", title="Source session")
)
source_message = messages_service.append(
conn,
scope_id=scope_id,
session_id=session_id,
platform="avibe",
author="user",
message_type="user",
text="fork from here",
)
with patch("vibe.sse_broker.broker.publish") as publish:
client = app.test_client()
headers = csrf_headers(client)
response = client.post(f"/api/sessions/{session_id}/fork", json={}, headers=headers)
assert response.status_code == 201
payload = response.get_json()
assert payload["id"] != session_id
assert payload["scope_id"] == scope_id
assert payload["project_id"] == "proj_stream"
assert payload["title"] == "Fork Source session"
assert payload["agent_backend"] == "claude"
assert payload["agent_name"] == "worker"
assert payload["native_session_id"] == ""
assert payload["metadata"]["created_via"] == "session_fork"
assert payload["metadata"]["fork_source_session_id"] == session_id
assert payload["metadata"]["fork_source_session_title"] == "Source session"
assert payload["metadata"]["fork_source_message_id"] == source_message["id"]
assert payload["metadata"]["fork_source_native_session_id"] == "native-source-1"
publish.assert_called_with(
"session.activity",
{"session_id": payload["id"], "scope_id": scope_id, "event": "created"},
)
def test_fork_session_marks_running_source_for_trim(isolated_state, tmp_path, monkeypatch):
from sqlalchemy import update
from storage import messages_service
from storage.db import create_sqlite_engine
from storage.models import agent_sessions
from vibe.ui_server import app
xdg_home = tmp_path / "xdg"
monkeypatch.setenv("XDG_DATA_HOME", str(xdg_home))
_seed_opencode_messages(xdg_home, "native-source-1", ["user", "assistant", "user"])
scope_id, session_id = _make_session(
tmp_path,
agent_name="opencode",
agent_backend="opencode",
)
engine = create_sqlite_engine()
with engine.begin() as conn:
conn.execute(
update(agent_sessions)
.where(agent_sessions.c.id == session_id)
.values(
agent_backend="opencode",
agent_variant="opencode",
agent_name="opencode",
native_session_id="native-source-1",
title="Source session",
)
)
messages_service.append(
conn,
scope_id=scope_id,
session_id=session_id,
platform="avibe",
author="user",
message_type="user",
text="do work",
)
in_flight = AsyncMock(
return_value={
"status_code": 200,
"body": {"ok": True, "in_flight": True, "native_turn_started": True},
}
)
with (
patch("vibe.sse_broker.broker.publish"),
patch("vibe.internal_client.turn_state", in_flight),
):
client = app.test_client()
headers = csrf_headers(client)
response = client.post(f"/api/sessions/{session_id}/fork", json={}, headers=headers)
assert response.status_code == 201
payload = response.get_json()
assert payload["metadata"]["fork_trim_latest_running_turn"] is True
assert payload["metadata"]["fork_native_turn_started"] is True
assert payload["metadata"]["fork_opencode_message_id"] == "oc-msg-3"
in_flight.assert_awaited_once_with(session_id)
def test_fork_session_does_not_mark_claude_running_source_for_trim(isolated_state, tmp_path):
from sqlalchemy import update
from storage.db import create_sqlite_engine
from storage.models import agent_sessions
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
engine = create_sqlite_engine()
with engine.begin() as conn:
conn.execute(
update(agent_sessions)
.where(agent_sessions.c.id == session_id)
.values(native_session_id="claude-source-1", title="Source session")
)
in_flight = AsyncMock(
return_value={
"status_code": 200,
"body": {"ok": True, "in_flight": True, "native_turn_started": True},
}
)
with (
patch("vibe.sse_broker.broker.publish"),
patch("vibe.internal_client.turn_state", in_flight),
):
client = app.test_client()
headers = csrf_headers(client)
response = client.post(f"/api/sessions/{session_id}/fork", json={}, headers=headers)
assert response.status_code == 201
payload = response.get_json()
assert payload["metadata"]["fork_source_backend"] == "claude"
assert payload["metadata"]["fork_trim_latest_running_turn"] is False
assert payload["metadata"]["fork_native_turn_started"] is False
def test_fork_session_trims_post_accept_open_code_before_native_turn_starts(isolated_state, tmp_path, monkeypatch):
from sqlalchemy import update
from storage.db import create_sqlite_engine
from storage.models import agent_sessions
from vibe.ui_server import app
xdg_home = tmp_path / "xdg"
monkeypatch.setenv("XDG_DATA_HOME", str(xdg_home))
_seed_opencode_messages(xdg_home, "native-source-1", ["user"])
_, session_id = _make_session(
tmp_path,
agent_name="opencode",
agent_backend="opencode",
)
engine = create_sqlite_engine()
with engine.begin() as conn:
conn.execute(
update(agent_sessions)
.where(agent_sessions.c.id == session_id)
.values(
agent_backend="opencode",
agent_variant="opencode",
agent_name="opencode",
native_session_id="native-source-1",
title="Source session",
)
)
in_flight = AsyncMock(
return_value={
"status_code": 200,
"body": {"ok": True, "in_flight": True, "native_turn_started": False},
}
)
with (
patch("vibe.sse_broker.broker.publish"),
patch("vibe.internal_client.turn_state", in_flight),
):
client = app.test_client()
headers = csrf_headers(client)
response = client.post(f"/api/sessions/{session_id}/fork", json={}, headers=headers)
assert response.status_code == 201
payload = response.get_json()
assert payload["metadata"]["fork_trim_latest_running_turn"] is True
assert payload["metadata"]["fork_native_turn_started"] is True
assert payload["metadata"]["fork_opencode_message_id"] == "oc-msg-1"
def test_fork_session_rejects_unbound_source_session(isolated_state, tmp_path):
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
client = app.test_client()
headers = csrf_headers(client)
response = client.post(f"/api/sessions/{session_id}/fork", json={}, headers=headers)
assert response.status_code == 409
assert response.get_json()["code"] == "session_not_bound"
def test_patch_rejects_backend_switch_for_pending_fork(isolated_state, tmp_path):
from sqlalchemy import update
from storage.db import create_sqlite_engine
from storage.models import agent_sessions
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
_ensure_vibe_agent("codex", "codex")
engine = create_sqlite_engine()
with engine.begin() as conn:
conn.execute(
update(agent_sessions)
.where(agent_sessions.c.id == session_id)
.values(native_session_id="native-source-1")
)
client = app.test_client()
headers = csrf_headers(client)
fork_response = client.post(f"/api/sessions/{session_id}/fork", json={}, headers=headers)
assert fork_response.status_code == 201
forked_id = fork_response.get_json()["id"]
response = client.patch(
f"/api/sessions/{forked_id}",
json={"agent_backend": "codex", "agent_name": "codex"},
headers=headers,
)
assert response.status_code == 409
body = response.get_json()
assert body["code"] == "backend_locked"
assert body["current_backend"] == "claude"
assert body["requested_backend"] == "codex"
def test_chat_bootstrap_returns_first_screen_payload(isolated_state, tmp_path):
from storage import messages_service
from storage.db import create_sqlite_engine
from vibe.ui_server import app
scope_id, session_id = _make_session(tmp_path)
engine = create_sqlite_engine()
with engine.begin() as conn:
messages_service.append(
conn,
scope_id=scope_id,
session_id=session_id,
platform="avibe",
author="user",
message_type="user",
text="question",
)
messages_service.append(
conn,
scope_id=scope_id,
session_id=session_id,
platform="avibe",
author="agent",
message_type="assistant",
text="thinking",
)
messages_service.append(
conn,
scope_id=scope_id,
session_id=session_id,
platform="avibe",
author="agent",
message_type="result",
text="answer",
)
message_deliveries.enqueue_queued(
conn,
scope_id=scope_id,
session_id=session_id,
text="follow-up",
)
message_deliveries.set_draft(conn, session_id, "draft text")
async def in_flight(session_id_inner):
assert session_id_inner == session_id
return {
"status_code": 200,
"body": {
"in_flight": True,
"foreground": "running",
"pending_input_count": 1,
"background_activities": [
{
"id": "task-1",
"backend": "claude",
"runtime_key": "runtime-1",
"kind": "background_task",
"status": "running",
"item_kind": "backend_activity",
"label": "Waiting for turn",
}
],
"pending_activity_output_count": 0,
"connection": "connected",
},
}
with (
patch("vibe.internal_client.turn_state", in_flight),
patch(
"vibe.api.get_vibe_agents",
return_value={
"agents": [{"name": "worker", "backend": "claude", "enabled": True}],
"default_agent_name": "worker",
},
),
):
client = app.test_client()
response = client.get(f"/api/sessions/{session_id}/bootstrap")
assert response.status_code == 200
body = response.get_json()
assert body["session"]["id"] == session_id
assert body["default_agent_name"] == "worker"
assert body["agents"][0]["name"] == "worker"
assert body["config"]["setup_state"]["needs_setup"] is True
assert [message["text"] for message in body["messages"]] == ["question", "answer"]
assert [message["type"] for message in body["messages"]] == ["user", "result"]
assert body["queued"][0]["text"] == "follow-up"
assert body["draft"]["text"] == "draft text"
assert body["draft"]["updated_at"] is not None
assert body["turn_state"]["in_flight"] is True
assert body["turn_state"]["foreground"] == "running"
assert body["turn_state"]["pending_input_count"] == 1
assert body["turn_state"]["background_activities"][0]["id"] == "task-1"
assert body["turn_state"]["background_activities"][0]["label"] == "Waiting for turn"
assert body["turn_state"]["connection"] == "connected"
def test_message_delivery_024_claimed_active_input_survives_transcript_reload(
isolated_state,
tmp_path,
):
"""MESSAGE-DELIVERY-024: claimed Web input survives and then reconciles."""
from vibe.ui_server import app
scope_id, session_id = _make_session(
tmp_path,
agent_name="opencode-worker",
agent_backend="opencode",
)
claimed = _seed_claimed_batch(
scope_id=scope_id,
session_id=session_id,
texts=["first input", "second input"],
metadata={"resource_user_context": {"sub": "must-not-leak"}},
)
first_delivery = claimed["deliveries"][0]
turn_state = AsyncMock(
return_value={
"status_code": 200,
"body": {"in_flight": True, "native_turn_started": False},
}
)
with (
patch("vibe.internal_client.turn_state", turn_state),
patch(
"vibe.api.get_vibe_agents",
return_value={"agents": [], "default_agent_name": None},
),
):
client = app.test_client()
messages_response = client.get(f"/api/sessions/{session_id}/messages?tail=1")
bootstrap_response = client.get(f"/api/sessions/{session_id}/bootstrap")
assert messages_response.status_code == 200
assert bootstrap_response.status_code == 200
for rows in (
messages_response.get_json()["messages"],
bootstrap_response.get_json()["messages"],
):
assert [row["id"] for row in rows] == [first_delivery["id"]]
assert rows[0]["text"] == "first input\nsecond input"
assert rows[0]["type"] == "user"
assert rows[0]["metadata"]["merged_delivery_ids"] == [
delivery["id"] for delivery in claimed["deliveries"]
]
assert rows[0]["projection"] == "claimed_delivery"
assert rows[0]["delivered_at"] == claimed["turn"]["started_at"]
assert "resource_user_context" not in rows[0]["metadata"]
with create_sqlite_engine().connect() as conn:
assert conn.execute(
select(messages.c.id).where(messages.c.session_id == session_id)
).scalar_one_or_none() is None
with create_sqlite_engine().begin() as conn:
turn = message_deliveries.get_turn(conn, claimed["turn"]["id"])
assert turn is not None
assert message_deliveries.bind_native_start(
conn,
turn["id"],
expected_version=int(turn["version"]),
runtime_key="runtime:accepted",
runtime_turn_id="runtime-turn:accepted",
native_turn_id="native:accepted",
) is not None
assert message_deliveries.materialize_start_acceptance(
conn,
turn_id=turn["id"],
evidence={"kind": "test_native_acceptance"},
)
accepted_response = client.get(f"/api/sessions/{session_id}/messages?tail=1")
accepted_rows = accepted_response.get_json()["messages"]
assert accepted_rows[0]["id"] == first_delivery["id"]
assert accepted_rows[0]["text"] == "first input\nsecond input"
assert "projection" not in accepted_rows[0]
assert "workbench_claimed_delivery" not in accepted_rows[0]["metadata"]
from core.services import sessions as sessions_service
im_agent = _ensure_vibe_agent("im-opencode-worker", "opencode")
with create_sqlite_engine().begin() as conn:
im_session = sessions_service.create_session(
conn,
scope_id=scope_id,
agent_backend=im_agent.backend,
agent_id=im_agent.id,
agent_name=im_agent.name,
)
im_session_id = im_session["id"]
_seed_claimed_batch(
scope_id=scope_id,
session_id=im_session_id,
texts=["unaccepted IM input"],
platform="slack",
)
im_response = client.get(f"/api/sessions/{im_session_id}/messages?tail=1")
assert im_response.get_json()["messages"] == []
def test_claimed_projection_follows_the_result_before_its_turn(isolated_state, tmp_path):
"""MESSAGE-DELIVERY-024: projection enters at claim time, not submission time."""
from vibe.ui_server import app
scope_id, session_id = _make_session(
tmp_path,
agent_name="opencode-order",
agent_backend="opencode",
)
with create_sqlite_engine().begin() as conn:
result = messages_service.append(
conn,
scope_id=scope_id,
session_id=session_id,
platform="avibe",
author="agent",
message_type="result",
text="previous turn result",
)
claimed = _seed_claimed_batch(
scope_id=scope_id,
session_id=session_id,
texts=["next turn input"],
)
response = app.test_client().get(f"/api/sessions/{session_id}/messages?tail=1")
assert response.status_code == 200
rows = response.get_json()["messages"]
assert [row["id"] for row in rows] == [result["id"], claimed["deliveries"][0]["id"]]
assert rows[1]["delivered_at"] == claimed["turn"]["started_at"]
def test_chat_bootstrap_filters_harness_activities_for_viewer(isolated_state, tmp_path):
from vibe.ui_server import app
monkeypatch = pytest.MonkeyPatch()
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _save_config(tmp_path, paired=True)
_, session_id = _make_session(tmp_path)
client = app.test_client()
client.set_cookie(
remote_access.SESSION_COOKIE_NAME,
remote_session_cookie(
config,
"[email protected]",
"user-viewer",
role="viewer",
),
domain="alex.avibe.bot",
)
async def projected(_session_id):
return {
"status_code": 200,
"body": {
"in_flight": False,
"foreground": "idle",
"pending_input_count": 0,
"background_activities": [
{
"id": "backend-1",
"item_kind": "backend_activity",
"label": "Waiting for approval",
"status": "running",
},
{
"id": "task-1",
"item_kind": "task",
"label": "private prompt head",
"status": "scheduled",
},
],
"pending_activity_output_count": 1,
"connection": "reconnecting",
},
}
with (
patch("vibe.internal_client.turn_state", projected),
patch(
"vibe.api.get_vibe_agents",
return_value={
"agents": [{"name": "worker", "backend": "claude", "enabled": True}],
"default_agent_name": "worker",
},
),
):
response = client.get(
f"/api/sessions/{session_id}/bootstrap",
base_url="https://alex.avibe.bot",
environ_base={"REMOTE_ADDR": "203.0.113.10"},
)
monkeypatch.undo()
assert response.status_code == 200
body = response.get_json()
assert [item["id"] for item in body["turn_state"]["background_activities"]] == ["backend-1"]
assert body["turn_state"]["background_activities"][0]["label"] == "Waiting for approval"
def test_turn_state_route_preserves_harness_activities_for_editor(isolated_state, tmp_path):
from vibe.ui_server import app
monkeypatch = pytest.MonkeyPatch()
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _save_config(tmp_path, paired=True)
_, session_id = _make_session(tmp_path)
client = app.test_client()
client.set_cookie(
remote_access.SESSION_COOKIE_NAME,
remote_session_cookie(
config,
"[email protected]",
"user-editor",
role="editor",
),
domain="alex.avibe.bot",
)
async def projected(session_id_inner):
assert session_id_inner == session_id
return {
"status_code": 200,
"body": {
"in_flight": False,
"foreground": "idle",
"pending_input_count": 0,
"background_activities": [
{
"id": "backend-1",
"item_kind": "backend_activity",
"label": "Waiting for approval",
"status": "running",
},
{
"id": "watch-1",
"item_kind": "watch",
"label": "private waiter prompt",
"status": "enabled",
},
],
"pending_activity_output_count": 1,
"connection": "reconnecting",
},
}
with patch("vibe.internal_client.turn_state", projected):
response = client.get(
f"/api/sessions/{session_id}/turn-state",
base_url="https://alex.avibe.bot",
environ_base={"REMOTE_ADDR": "203.0.113.10"},
)
monkeypatch.undo()
assert response.status_code == 200
body = response.get_json()
assert [item["id"] for item in body["background_activities"]] == [
"backend-1",
"watch-1",
]
assert body["background_activities"][1]["label"] == "private waiter prompt"
def test_session_draft_compare_and_set_protects_newer_writes_and_clears(
isolated_state,
tmp_path,
):
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
client = app.test_client()
headers = csrf_headers(client)
path = f"/api/sessions/{session_id}/draft"
created = client.put(
path,
json={"text": "first", "expected_updated_at": None},
headers=headers,
)
assert created.status_code == 200
created_draft = created.get_json()["draft"]
assert created_draft["text"] == "first"
first_revision = created_draft["updated_at"]
assert first_revision is not None
fetched = client.get(path)
assert fetched.status_code == 200
assert fetched.get_json() == created_draft
stale = client.put(
path,
json={"text": "stale", "expected_updated_at": None},
headers=headers,
)
assert stale.status_code == 409
assert stale.get_json() == {
"ok": False,
"code": "draft_conflict",
"draft": created_draft,
}
revisionless = client.put(
path,
json={"text": "legacy overwrite"},
headers=headers,
)
assert revisionless.status_code == 409
assert revisionless.get_json() == {
"ok": False,
"code": "draft_conflict",
"draft": created_draft,
}
updated = client.put(
path,
json={"text": "second", "expected_updated_at": first_revision},
headers=headers,
)
assert updated.status_code == 200
updated_draft = updated.get_json()["draft"]
assert updated_draft["text"] == "second"
second_revision = updated_draft["updated_at"]
assert second_revision not in (None, first_revision)
cleared = client.put(
path,
json={"text": "", "expected_updated_at": second_revision},
headers=headers,
)
assert cleared.status_code == 200
cleared_draft = cleared.get_json()["draft"]
assert cleared_draft["text"] == ""
assert cleared_draft["updated_at"] not in (None, second_revision)
resurrect = client.put(
path,
json={"text": "resurrected", "expected_updated_at": second_revision},
headers=headers,
)
assert resurrect.status_code == 409
assert resurrect.get_json()["draft"] == cleared_draft
def test_session_draft_reserves_writer_before_cas_reads(isolated_state, tmp_path):
from core.services import sessions as sessions_service
from storage.agent_session_rows import reserve_write_lock as real_reserve_write_lock
from vibe.ui_server import app
real_get_session = sessions_service.get_session
_, session_id = _make_session(tmp_path)
client = app.test_client()
headers = csrf_headers(client)
calls = []
def reserve_write_lock(conn):
calls.append("write_lock")
return real_reserve_write_lock(conn)
def get_session(conn, target_session_id):
calls.append("session_read")
return real_get_session(conn, target_session_id)
with (
patch("storage.agent_session_rows.reserve_write_lock", reserve_write_lock),
patch("core.services.sessions.get_session", get_session),
):
response = client.put(
f"/api/sessions/{session_id}/draft",
json={"text": "serialized", "expected_updated_at": None},
headers=headers,
)
assert response.status_code == 200
assert calls[:2] == ["write_lock", "session_read"]
def test_queue_row_send_now_passes_the_exact_delivery_id(isolated_state, tmp_path):
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
send_now = AsyncMock(
return_value={
"status_code": 409,
"body": {"ok": False, "code": "stale_head"},
}
)
with patch("vibe.internal_client.send_now", send_now):
client = app.test_client()
response = client.post(
f"/api/sessions/{session_id}/queue/del_requested/send-now",
headers=csrf_headers(client),
)
assert response.status_code == 409
assert response.get_json()["code"] == "stale_head"
send_now.assert_awaited_once_with(
session_id,
expected_delivery_id="del_requested",
)
def test_chat_bootstrap_keeps_timeout_turn_state_unknown(isolated_state, tmp_path):
from vibe import internal_client
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
async def timeout(session_id_inner):
raise internal_client.InternalServerTimeout("slow internal turn-state")
with (
patch("vibe.internal_client.turn_state", timeout),
patch("vibe.api.get_vibe_agents", return_value={"agents": [], "default_agent_name": None}),
):
client = app.test_client()
response = client.get(f"/api/sessions/{session_id}/bootstrap")
assert response.status_code == 200
assert response.get_json()["turn_state"]["in_flight"] is None
def test_cancel_route_proxies_to_internal_socket(isolated_state, tmp_path):
_, session_id = _make_session(tmp_path)
from vibe.ui_server import app
cancel_mock = AsyncMock(
return_value={"status_code": 200, "body": {"ok": True, "status": "cancel_requested"}}
)
with patch("vibe.internal_client.cancel_dispatch", cancel_mock):
client = app.test_client()
headers = csrf_headers(client)
response = client.post(f"/api/sessions/{session_id}/cancel", headers=headers)
assert response.status_code == 200
body = response.json()
assert body["ok"] is True
assert body["status"] == "cancel_requested"
cancel_mock.assert_awaited_once_with(session_id)
def test_cancel_route_returns_503_when_socket_unavailable(isolated_state, tmp_path):
from vibe import internal_client
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
async def fail(session_id_inner):
raise internal_client.InternalServerUnavailable("socket missing")
with patch("vibe.internal_client.cancel_dispatch", fail):
client = app.test_client()
headers = csrf_headers(client)
response = client.post(f"/api/sessions/{session_id}/cancel", headers=headers)
assert response.status_code == 503
body = response.json()
assert body["ok"] is False
assert body["code"] == "internal_unavailable"
def test_cancel_route_forwards_controller_status_recovery(isolated_state, tmp_path):
from core.services import sessions as sessions_service
from storage.db import create_sqlite_engine
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
engine = create_sqlite_engine()
with engine.begin() as conn:
assert sessions_service.set_agent_status(conn, session_id, "running") is True
cancel_mock = AsyncMock(
return_value={
"status_code": 404,
"body": {
"ok": False,
"code": "not_in_flight",
"recovered_agent_status": True,
},
}
)
with patch("vibe.internal_client.cancel_dispatch", cancel_mock):
client = app.test_client()
headers = csrf_headers(client)
response = client.post(f"/api/sessions/{session_id}/cancel", headers=headers)
assert response.status_code == 404
body = response.get_json()
assert body["code"] == "not_in_flight"
assert body["recovered_agent_status"] is True
with engine.connect() as conn:
assert sessions_service.get_session(conn, session_id)["agent_status"] == "running"
def test_cancel_route_does_not_recover_failed_status_on_not_in_flight(isolated_state, tmp_path):
from core.services import sessions as sessions_service
from storage.db import create_sqlite_engine
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
engine = create_sqlite_engine()
with engine.begin() as conn:
assert sessions_service.set_agent_status(conn, session_id, "failed") is True
cancel_mock = AsyncMock(
return_value={"status_code": 404, "body": {"ok": False, "code": "not_in_flight"}}
)
with patch("vibe.internal_client.cancel_dispatch", cancel_mock):
client = app.test_client()
headers = csrf_headers(client)
response = client.post(f"/api/sessions/{session_id}/cancel", headers=headers)
assert response.status_code == 404
body = response.get_json()
assert body["code"] == "not_in_flight"
assert body["recovered_agent_status"] is False
with engine.connect() as conn:
assert sessions_service.get_session(conn, session_id)["agent_status"] == "failed"
def test_cancel_route_preserves_not_in_flight_for_missing_session(isolated_state):
from vibe.ui_server import app
cancel_mock = AsyncMock(
return_value={"status_code": 404, "body": {"ok": False, "code": "not_in_flight"}}
)
with patch("vibe.internal_client.cancel_dispatch", cancel_mock):
client = app.test_client()
headers = csrf_headers(client)
response = client.post("/api/sessions/ses_missing/cancel", headers=headers)
assert response.status_code == 404
body = response.get_json()
assert body["code"] == "not_in_flight"
assert body["recovered_agent_status"] is False
def test_turn_state_route_returns_504_on_probe_timeout(isolated_state, tmp_path):
from vibe import internal_client
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
async def timeout(session_id_inner):
raise internal_client.InternalServerTimeout("slow internal turn-state")
with patch("vibe.internal_client.turn_state", timeout):
client = app.test_client()
response = client.get(f"/api/sessions/{session_id}/turn-state")
assert response.status_code == 504
assert response.get_json()["error"]["code"] == "turn_state_timeout"
def test_turn_state_forwards_controller_status_recovery(isolated_state, tmp_path):
from core.services import sessions as sessions_service
from storage.db import create_sqlite_engine
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
engine = create_sqlite_engine()
with engine.begin() as conn:
assert sessions_service.set_agent_status(conn, session_id, "running") is True
async def idle(session_id_inner):
assert session_id_inner == session_id
return {
"status_code": 200,
"body": {"in_flight": False, "recovered_agent_status": True},
}
with patch("vibe.internal_client.turn_state", idle):
client = app.test_client()
response = client.get(f"/api/sessions/{session_id}/turn-state")
assert response.status_code == 200
body = response.get_json()
assert body["in_flight"] is False
assert body["recovered_agent_status"] is True
with engine.connect() as conn:
assert sessions_service.get_session(conn, session_id)["agent_status"] == "running"
def test_turn_state_route_preserves_orthogonal_runtime_axes(isolated_state, tmp_path):
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
async def projected(session_id_inner):
assert session_id_inner == session_id
return {
"status_code": 200,
"body": {
"in_flight": False,
"foreground": "idle",
"native_turn_started": False,
"pending_input_count": 2,
"background_activities": [
{
"id": "task-1",
"backend": "claude",
"runtime_key": "runtime-1",
"kind": "background_task",
"status": "running",
"item_kind": "backend_activity",
}
],
"pending_activity_output_count": 1,
"connection": "reconnecting",
},
}
with patch("vibe.internal_client.turn_state", projected):
client = app.test_client()
response = client.get(f"/api/sessions/{session_id}/turn-state")
assert response.status_code == 200
body = response.get_json()
assert body["foreground"] == "idle"
assert body["in_flight"] is False
assert body["pending_input_count"] == 2
assert body["pending_activity_output_count"] == 1
assert [item["id"] for item in body["background_activities"]] == ["task-1"]
assert body["connection"] == "reconnecting"
def test_turn_state_idle_does_not_recover_failed_status(isolated_state, tmp_path):
from core.services import sessions as sessions_service
from storage.db import create_sqlite_engine
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
engine = create_sqlite_engine()
with engine.begin() as conn:
assert sessions_service.set_agent_status(conn, session_id, "failed") is True
async def idle(session_id_inner):
assert session_id_inner == session_id
return {"status_code": 200, "body": {"in_flight": False}}
with patch("vibe.internal_client.turn_state", idle):
client = app.test_client()
response = client.get(f"/api/sessions/{session_id}/turn-state")
assert response.status_code == 200
body = response.get_json()
assert body["in_flight"] is False
assert body["recovered_agent_status"] is False
with engine.connect() as conn:
assert sessions_service.get_session(conn, session_id)["agent_status"] == "failed"
def test_turn_state_idle_preserves_response_for_missing_session(isolated_state):
from vibe.ui_server import app
async def idle(session_id_inner):
assert session_id_inner == "ses_missing"
return {"status_code": 200, "body": {"in_flight": False}}
with patch("vibe.internal_client.turn_state", idle):
client = app.test_client()
response = client.get("/api/sessions/ses_missing/turn-state")
assert response.status_code == 200
body = response.get_json()
assert body["in_flight"] is False
assert body["recovered_agent_status"] is False
def test_patch_backend_switch_blocked_while_turn_in_flight(isolated_state, tmp_path):
"""The row's ``agent_status`` lags turn acceptance (``submit`` registers the
in-flight gate before dispatch writes ``running``), so a cross-backend PATCH
in that startup window must consult the controller's gate and 409 — otherwise
the bind-time backend backfill would silently undo the switch."""
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
_ensure_vibe_agent("codex", "codex")
in_flight = AsyncMock(return_value={"status_code": 200, "body": {"ok": True, "in_flight": True}})
with patch("vibe.internal_client.turn_state", in_flight):
client = app.test_client()
headers = csrf_headers(client)
response = client.patch(
f"/api/sessions/{session_id}",
json={"agent_backend": "codex", "agent_name": "codex"},
headers=headers,
)
assert response.status_code == 409
assert response.get_json()["code"] == "backend_locked"
in_flight.assert_awaited_once()
def test_patch_session_visibility_and_scope_are_independent(isolated_state, tmp_path, monkeypatch):
from storage.db import create_sqlite_engine
from storage.models import agent_sessions
import vibe.sse_broker as sse_broker
from vibe.ui_server import app
original_scope_id, session_id = _make_session(tmp_path)
published: list[tuple[str, dict]] = []
monkeypatch.setattr(sse_broker.broker, "publish", lambda topic, data: published.append((topic, data)))
engine = create_sqlite_engine()
with engine.connect() as conn:
original_workdir = conn.execute(
agent_sessions.select().where(agent_sessions.c.id == session_id)
).mappings().one()["workdir"]
client = app.test_client()
headers = csrf_headers(client)
visibility_response = client.patch(
f"/api/sessions/{session_id}",
json={"visibility": "background"},
headers=headers,
)
assert visibility_response.status_code == 200
assert visibility_response.get_json()["visibility"] == "background"
assert visibility_response.get_json()["scope_id"] == original_scope_id
activity = [data for topic, data in published if topic == "session.activity"]
assert activity[-2]["event"] == "updated"
assert activity[-2]["visibility"] == "background"
assert activity[-1] == {
"session_id": session_id,
"scope_id": original_scope_id,
"event": "user_message",
"reason": "session_placement_changed",
}
published.clear()
scope_response = client.patch(
f"/api/sessions/{session_id}",
json={"scope_id": None},
headers=headers,
)
assert scope_response.status_code == 200
body = scope_response.get_json()
assert body["visibility"] == "background"
assert body["scope_id"] is None
assert body["project_id"] is None
assert body["workdir"] == original_workdir
activity = [data for topic, data in published if topic == "session.activity"]
assert [event["event"] for event in activity] == ["updated", "user_message"]
assert activity[-1]["scope_id"] == original_scope_id
published.clear()
foreground_response = client.patch(
f"/api/sessions/{session_id}",
json={"visibility": "foreground", "scope_id": original_scope_id},
headers=headers,
)
assert foreground_response.status_code == 200
assert foreground_response.get_json()["workdir"] == original_workdir
activity = [data for topic, data in published if topic == "session.activity"]
assert [event["event"] for event in activity] == ["updated", "created"]
assert activity[-1]["scope_id"] == original_scope_id
def test_patch_session_pin_persists_and_broadcasts(isolated_state, tmp_path, monkeypatch):
import vibe.sse_broker as sse_broker
from vibe.ui_server import app
scope_id, session_id = _make_session(tmp_path)
published: list[tuple[str, dict]] = []
monkeypatch.setattr(sse_broker.broker, "publish", lambda topic, data: published.append((topic, data)))
client = app.test_client()
response = client.patch(
f"/api/sessions/{session_id}",
json={"pinned": True},
headers=csrf_headers(client),
)
assert response.status_code == 200
assert response.get_json()["pinned"] is True
activity = [data for topic, data in published if topic == "session.activity"]
assert activity == [
{
"session_id": session_id,
"scope_id": scope_id,
"event": "updated",
"title": None,
"visibility": "foreground",
"pinned": True,
}
]
get_response = client.get(f"/api/sessions/{session_id}")
assert get_response.get_json()["pinned"] is True
def test_patch_session_rejects_non_boolean_pin(isolated_state, tmp_path):
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
client = app.test_client()
response = client.patch(
f"/api/sessions/{session_id}",
json={"pinned": "true"},
headers=csrf_headers(client),
)
assert response.status_code == 400
assert response.get_json()["error"] == "pinned must be a boolean"
def test_patch_session_rejects_invalid_visibility(isolated_state, tmp_path):
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
client = app.test_client()
response = client.patch(
f"/api/sessions/{session_id}",
json={"visibility": "hidden"},
headers=csrf_headers(client),
)
assert response.status_code == 400
def test_patch_session_rejects_unknown_target_scope_as_invalid_value(isolated_state, tmp_path):
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
client = app.test_client()
response = client.patch(
f"/api/sessions/{session_id}",
json={"scope_id": "avibe::project::missing"},
headers=csrf_headers(client),
)
assert response.status_code == 400
def test_standalone_session_accepts_attachment_upload(isolated_state, monkeypatch):
import base64
import threading
from core.services import sessions as sessions_service
from storage.db import create_sqlite_engine
from storage.models import media_objects
from vibe import ui_server
engine = create_sqlite_engine()
with engine.begin() as conn:
session = sessions_service.create_session(
conn,
scope_id=None,
agent_backend="codex",
visibility="foreground",
)
loop_threads: list[int] = []
engine_threads: list[int] = []
session_threads: list[int] = []
decode_threads: list[int] = []
original_dispatch = ui_server._dispatch_native_ui_request
original_projects_engine = ui_server._projects_engine
original_get_session = sessions_service.get_session
original_b64decode = base64.b64decode
async def tracked_dispatch(starlette_request, handler):
loop_threads.append(threading.get_ident())
return await original_dispatch(starlette_request, handler)
def tracked_projects_engine():
engine_threads.append(threading.get_ident())
return original_projects_engine()
def tracked_get_session(*args, **kwargs):
session_threads.append(threading.get_ident())
return original_get_session(*args, **kwargs)
def tracked_b64decode(*args, **kwargs):
decode_threads.append(threading.get_ident())
return original_b64decode(*args, **kwargs)
monkeypatch.setattr(ui_server, "_dispatch_native_ui_request", tracked_dispatch)
monkeypatch.setattr(ui_server, "_projects_engine", tracked_projects_engine)
monkeypatch.setattr(sessions_service, "get_session", tracked_get_session)
monkeypatch.setattr(base64, "b64decode", tracked_b64decode)
client = ui_server.app.test_client()
response = client.post(
f"/api/sessions/{session['id']}/attachments",
json={
"name": "standalone.txt",
"mime": "text/plain",
"data": "data:text/plain;base64,"
+ base64.b64encode(b"standalone upload").decode("ascii"),
},
headers=csrf_headers(client),
)
assert response.status_code == 201
token = response.get_json()["token"]
with engine.connect() as conn:
row = conn.execute(
media_objects.select().where(media_objects.c.token == token)
).mappings().one()
assert row["scope_id"] is None
assert row["session_id"] == session["id"]
assert len(loop_threads) == 1
assert engine_threads
assert session_threads
assert decode_threads
assert all(
thread_id != loop_threads[0]
for thread_id in (*engine_threads, *session_threads, *decode_threads)
)
def test_legacy_attachment_upload_preserves_json_contract(isolated_state, tmp_path, monkeypatch):
import base64
from core import workbench_media
from storage import media_service
from storage.db import create_sqlite_engine
from vibe.ui_server import app
raw = b"legacy upload"
monkeypatch.setattr(workbench_media, "MAX_WORKBENCH_ATTACHMENT_BYTES", len(raw))
encoded = base64.b64encode(raw).decode("ascii")
wrapped = " \t\r\n\v\f".join(encoded[index : index + 4] for index in range(0, len(encoded), 4))
_, session_id = _make_session(tmp_path)
client = app.test_client()
response = client.post(
f"/api/sessions/{session_id}/attachments",
content=json.dumps(
{
"name": "legacy.txt",
"mime": "text/plain",
"data": f"data:text/plain;base64,{wrapped}",
}
),
headers={
**csrf_headers(client),
"Content-Type": "application/vnd.avibe+json; charset=utf-8",
},
)
assert response.status_code == 201
payload = response.get_json()
assert payload["size"] == len(raw)
with create_sqlite_engine().connect() as conn:
row = media_service.get_by_token(conn, payload["token"])
assert row is not None
assert Path(row["local_path"]).read_bytes() == raw
def test_legacy_attachment_upload_rejects_invalid_base64(isolated_state, tmp_path):
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
client = app.test_client()
response = client.post(
f"/api/sessions/{session_id}/attachments",
json={"name": "broken.txt", "mime": "text/plain", "data": "aGVs!bG8="},
headers=csrf_headers(client),
)
assert response.status_code == 400
assert response.get_json()["code"] == "invalid_upload"
def test_legacy_attachment_upload_rejects_oversized_base64(isolated_state, tmp_path, monkeypatch):
import base64
from core import workbench_media
from vibe.ui_server import app
monkeypatch.setattr(workbench_media, "MAX_WORKBENCH_ATTACHMENT_BYTES", 4)
_, session_id = _make_session(tmp_path)
client = app.test_client()
response = client.post(
f"/api/sessions/{session_id}/attachments",
json={
"name": "large.txt",
"mime": "text/plain",
"data": base64.b64encode(b"1234567").decode("ascii"),
},
headers=csrf_headers(client),
)
assert response.status_code == 413
assert response.get_json()["code"] == "too_large"
assert response.get_json()["max_file_bytes"] == 4
def test_attachment_upload_preserves_unicode_name_and_binary_body(isolated_state, tmp_path):
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
client = app.test_client()
response = client.post(
f"/api/sessions/{session_id}/attachments",
data={"upload_id": "upload-id-123456"},
files={"file": ("报告.txt", b"raw-binary\x00body", "text/plain")},
headers=csrf_headers(client),
)
assert response.status_code == 201
payload = response.get_json()
assert payload["name"] == "报告.txt"
assert payload["mime"] == "text/plain"
assert payload["size"] == 15
from storage import media_service
from storage.db import create_sqlite_engine
with create_sqlite_engine().connect() as conn:
row = media_service.get_by_token(conn, payload["token"])
assert row is not None
assert Path(row["local_path"]).read_bytes() == b"raw-binary\x00body"
def test_attachment_upload_rejects_oversized_part_without_partial_file(
isolated_state,
tmp_path,
monkeypatch,
):
from config import paths
from core import workbench_media
from vibe.ui_server import app
monkeypatch.setattr(workbench_media, "MAX_WORKBENCH_ATTACHMENT_BYTES", 4)
_, session_id = _make_session(tmp_path)
client = app.test_client()
response = client.post(
f"/api/sessions/{session_id}/attachments",
data={"upload_id": "upload-id-123456"},
files={"file": ("large.bin", b"12345", "application/octet-stream")},
headers=csrf_headers(client),
)
assert response.status_code == 413
assert response.get_json() == {
"ok": False,
"error": {
"code": "too_large",
"message": "The file exceeds the attachment size limit.",
},
"code": "too_large",
"message": "The file exceeds the attachment size limit.",
"max_file_bytes": 4,
}
upload_dir = paths.get_attachments_dir() / "avibe" / session_id
assert not upload_dir.exists() or not list(upload_dir.iterdir())
def test_attachment_upload_cleans_partial_file_after_registration_failure(
isolated_state,
tmp_path,
monkeypatch,
):
from config import paths
from storage import media_service
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
def fail_register(*_args, **_kwargs):
raise OSError("database unavailable")
monkeypatch.setattr(media_service, "register", fail_register)
client = app.test_client()
response = client.post(
f"/api/sessions/{session_id}/attachments",
data={"upload_id": "upload-id-123456"},
files={"file": ("note.txt", b"hello", "text/plain")},
headers=csrf_headers(client),
)
assert response.status_code == 500
assert response.get_json()["error"]["code"] == "upload_failed"
upload_dir = paths.get_attachments_dir() / "avibe" / session_id
assert not upload_dir.exists() or not list(upload_dir.iterdir())
def test_attachment_upload_cleans_failed_commit_before_releasing_upload_lock(
isolated_state,
tmp_path,
monkeypatch,
):
from config import paths
from core import workbench_media
from storage import media_service
from storage.db import create_sqlite_engine
from vibe import ui_server
_, session_id = _make_session(tmp_path)
engine = create_sqlite_engine()
original_begin = engine.begin
original_lock = workbench_media.workbench_attachment_upload_lock
original_unlink = Path.unlink
fail_commit = True
lock_held = False
cleanup_lock_states: list[bool] = []
@contextmanager
def fail_first_commit():
nonlocal fail_commit
with original_begin() as conn:
yield conn
if fail_commit:
fail_commit = False
raise OSError("commit failed")
@contextmanager
def tracked_upload_lock(*args, **kwargs):
nonlocal lock_held
with original_lock(*args, **kwargs):
lock_held = True
try:
yield
finally:
lock_held = False
def tracked_unlink(path: Path, *args, **kwargs):
if path.name.startswith("upload-id-123456_"):
cleanup_lock_states.append(lock_held)
return original_unlink(path, *args, **kwargs)
monkeypatch.setattr(engine, "begin", fail_first_commit)
monkeypatch.setattr(ui_server, "_projects_engine", lambda: engine)
monkeypatch.setattr(
workbench_media,
"workbench_attachment_upload_lock",
tracked_upload_lock,
)
monkeypatch.setattr(Path, "unlink", tracked_unlink)
client = ui_server.app.test_client()
headers = csrf_headers(client)
first = client.post(
f"/api/sessions/{session_id}/attachments",
data={"upload_id": "upload-id-123456"},
files={"file": ("note.txt", b"first", "text/plain")},
headers=headers,
)
retried = client.post(
f"/api/sessions/{session_id}/attachments",
data={"upload_id": "upload-id-123456"},
files={"file": ("note.txt", b"retry", "text/plain")},
headers=headers,
)
assert first.status_code == 500
assert cleanup_lock_states == [True]
assert retried.status_code == 201
with engine.connect() as conn:
row = media_service.get_by_token(conn, retried.get_json()["token"])
assert row is not None
assert Path(row["local_path"]).read_bytes() == b"retry"
upload_dir = paths.get_attachments_dir() / "avibe" / session_id
assert list(upload_dir.iterdir()) == [Path(row["local_path"])]
def test_attachment_upload_retry_reuses_committed_file_and_token(isolated_state, tmp_path):
from config import paths
from storage.db import create_sqlite_engine
from storage.models import media_objects
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
client = app.test_client()
headers = csrf_headers(client)
first = client.post(
f"/api/sessions/{session_id}/attachments",
data={"upload_id": "upload-id-123456"},
files={"file": ("note.txt", b"hello", "text/plain")},
headers=headers,
)
retried = client.post(
f"/api/sessions/{session_id}/attachments",
data={"upload_id": "upload-id-123456"},
files={"file": ("note.txt", b"hello", "text/plain")},
headers=headers,
)
assert first.status_code == 201
assert retried.status_code == 200
assert retried.get_json()["token"] == first.get_json()["token"]
upload_dir = paths.get_attachments_dir() / "avibe" / session_id
assert len(list(upload_dir.iterdir())) == 1
with create_sqlite_engine().connect() as conn:
rows = conn.execute(
select(media_objects.c.token).where(
media_objects.c.session_id == session_id,
media_objects.c.source == "user_upload",
)
).all()
assert rows == [(first.get_json()["token"],)]
def test_attachment_upload_errors_follow_configured_language(isolated_state, monkeypatch):
import threading
from core.services import settings as settings_service
from vibe import ui_server
loop_threads: list[int] = []
config_threads: list[int] = []
original_dispatch = ui_server._dispatch_native_ui_request
async def tracked_dispatch(starlette_request, handler):
loop_threads.append(threading.get_ident())
return await original_dispatch(starlette_request, handler)
def load_config():
config_threads.append(threading.get_ident())
return SimpleNamespace(language="zh")
monkeypatch.setattr(ui_server, "_dispatch_native_ui_request", tracked_dispatch)
monkeypatch.setattr(
settings_service,
"load_config_or_default",
load_config,
)
client = ui_server.app.test_client()
response = client.post(
"/api/sessions/ses_missing/attachments",
data={"upload_id": "upload-id-123456"},
files={"file": ("note.txt", b"hello", "text/plain")},
headers=csrf_headers(client),
)
assert response.status_code == 404
assert response.get_json()["error"] == {
"code": "session_not_found",
"message": "当前会话已不可用。",
}
assert len(loop_threads) == 1
assert config_threads
assert all(thread_id != loop_threads[0] for thread_id in config_threads)
def test_patch_agent_name_only_backend_switch_blocked_while_turn_in_flight(isolated_state, tmp_path):
"""A selected Vibe Agent implies its backend. The UI often sends only
``agent_name`` when changing the picker, so the route must derive the
backend before deciding whether to consult the controller's in-flight gate.
"""
from core.vibe_agents import VibeAgentStore
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
store = VibeAgentStore()
try:
store.create(name="reviewer", backend="codex")
finally:
store.close()
in_flight = AsyncMock(return_value={"status_code": 200, "body": {"ok": True, "in_flight": True}})
with patch("vibe.internal_client.turn_state", in_flight):
client = app.test_client()
headers = csrf_headers(client)
response = client.patch(
f"/api/sessions/{session_id}",
json={"agent_name": "reviewer"},
headers=headers,
)
assert response.status_code == 409
body = response.get_json()
assert body["code"] == "backend_locked"
assert body["current_backend"] == "claude"
assert body["requested_backend"] == "codex"
in_flight.assert_awaited_once()
def test_patch_agent_name_only_backend_switch_refreshes_variant_when_idle(isolated_state, tmp_path):
from core.vibe_agents import VibeAgentStore
from storage.db import create_sqlite_engine
from storage.models import agent_sessions
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
engine = create_sqlite_engine()
with engine.begin() as conn:
conn.execute(
agent_sessions.update()
.where(agent_sessions.c.id == session_id)
.values(agent_variant="old-claude-profile")
)
store = VibeAgentStore()
try:
store.create(name="reviewer", backend="codex")
finally:
store.close()
idle = AsyncMock(return_value={"status_code": 200, "body": {"ok": True, "in_flight": False}})
with patch("vibe.internal_client.turn_state", idle):
client = app.test_client()
headers = csrf_headers(client)
response = client.patch(
f"/api/sessions/{session_id}",
json={"agent_name": "reviewer"},
headers=headers,
)
assert response.status_code == 200
body = response.get_json()
assert body["agent_name"] == "reviewer"
assert body["agent_backend"] == "codex"
assert body["agent_variant"] == "codex"
idle.assert_awaited_once()
def test_patch_same_backend_change_skips_in_flight_gate(isolated_state, tmp_path):
"""Same-backend agent/model changes stay allowed mid-turn and don't pay the
internal turn-state round-trip."""
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
_ensure_vibe_agent("claude-pro", "claude")
gate = AsyncMock(return_value={"status_code": 200, "body": {"ok": True, "in_flight": True}})
with patch("vibe.internal_client.turn_state", gate):
client = app.test_client()
headers = csrf_headers(client)
response = client.patch(
f"/api/sessions/{session_id}",
json={"agent_backend": "claude", "agent_name": "claude-pro", "model": "opus"},
headers=headers,
)
assert response.status_code == 200
assert response.get_json()["agent_name"] == "claude-pro"
gate.assert_not_awaited()
def test_patch_backend_switch_allowed_when_idle(isolated_state, tmp_path):
"""No native + no in-flight turn → the (project-default) backend is a soft
pin and the cross-backend switch lands."""
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
_ensure_vibe_agent("codex", "codex")
idle = AsyncMock(return_value={"status_code": 200, "body": {"ok": True, "in_flight": False}})
with patch("vibe.internal_client.turn_state", idle):
client = app.test_client()
headers = csrf_headers(client)
response = client.patch(
f"/api/sessions/{session_id}",
json={"agent_backend": "codex", "agent_name": "codex"},
headers=headers,
)
assert response.status_code == 200
assert response.get_json()["agent_backend"] == "codex"
def test_patch_backend_switch_falls_back_to_row_guard_when_controller_down(isolated_state, tmp_path):
"""An unreachable controller must not brick the picker: the gate check is
best-effort and the row-status guard inside ``update_session`` still
applies."""
from vibe import internal_client
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
_ensure_vibe_agent("codex", "codex")
async def unavailable(session_id_inner):
raise internal_client.InternalServerUnavailable("socket missing")
with patch("vibe.internal_client.turn_state", unavailable):
client = app.test_client()
headers = csrf_headers(client)
response = client.patch(
f"/api/sessions/{session_id}",
json={"agent_backend": "codex", "agent_name": "codex"},
headers=headers,
)
assert response.status_code == 200
assert response.get_json()["agent_backend"] == "codex"
def test_route_fire_and_forgets_dispatch(isolated_state, tmp_path):
"""The web Chat POST persists the user row AND fire-and-forgets the turn via
``/internal/dispatch_async``. The reply arrives over the persistent
``message.new`` stream, so the response returns 201 immediately with the row
(it does NOT hold the turn open).
"""
from vibe.ui_server import app
_, session_id = _make_session(tmp_path)
dispatch_mock = AsyncMock(side_effect=_accepted_dispatch(session_id))
with (
patch("vibe.internal_client.dispatch_async", dispatch_mock),
patch("vibe.ui_server._web_push_user_key", return_value="remote:user-a"),
patch(
"vibe.ui_server._workbench_author_id",
return_value="remote:user-a",
),
):
client = app.test_client()
headers = csrf_headers(client)
saved_draft = client.put(
f"/api/sessions/{session_id}/draft",
json={"text": "draft before send", "expected_updated_at": None},
headers=headers,
).get_json()["draft"]
response = client.post(
f"/api/sessions/{session_id}/messages",
json={"text": "no stream", "author_id": "remote:spoofed"},
headers=headers,
)
assert response.status_code == 201
payload = response.get_json()
assert payload["author"] == "user"
assert payload["author_id"] == "remote:user-a"
assert "_web_push_user_key" not in payload["metadata"]
assert not any(key.startswith("_memory_") for key in payload["metadata"])
assert payload["text"] == "no stream"
assert payload["draft_advanced"] is True
assert payload["draft"]["text"] == ""
assert payload["draft"]["updated_at"] not in (None, saved_draft["updated_at"])
# The turn was kicked off fire-and-forget with the session + text.
dispatch_mock.assert_awaited_once()
sent = dispatch_mock.await_args.args[0]
assert sent["session_id"] == session_id
assert sent["text"] == "no stream"
assert sent["author_id"] == "remote:user-a"
assert sent["message_kind"] == "original"
assert "user_id" not in sent
assert "memory_cli_admitted" not in sent
assert "is_ordinary_text" not in sent