Enterprise agent platform for building, deploying, and operating AI teammates.
"""Regression tests for task model-id handling in chat API."""
import logging
import os
import tempfile
from datetime import UTC, datetime
from unittest.mock import MagicMock, patch
import pytest
from fastapi import FastAPI, HTTPException
from fastapi.testclient import TestClient
from tests.shared.auth_database import auth_db_override
from xagent.core.model.chat.basic.base import BaseLLM
from xagent.core.task_runtime import TaskRuntimeClientError
from xagent.web.api.auth import auth_router
from xagent.web.api.chat import chat_router
from xagent.web.api.model import model_router
from xagent.web.models.auth_database import get_auth_db
from xagent.web.models.database import Base, get_db, get_engine
from xagent.web.schemas.chat import MAX_SEED_INTERACTIONS
from xagent.web.services.agent_service_manager import (
AgentServiceManager,
_load_agent_for_task_runtime,
)
from xagent.web.services.workforce_access import WorkforcePolicy, set_workforce_policy
def override_get_db():
db = None
try:
db = next(get_db())
yield db
finally:
if db is not None:
db.close()
test_app = FastAPI()
test_app.include_router(auth_router)
test_app.include_router(model_router)
test_app.include_router(chat_router)
test_app.dependency_overrides[get_db] = override_get_db
test_app.dependency_overrides[get_auth_db] = auth_db_override(override_get_db)
client = TestClient(test_app)
def ensure_system_initialized() -> None:
status_response = client.get("/api/auth/setup-status")
assert status_response.status_code == 200
status_data = status_response.json()
if status_data.get("needs_setup", True):
setup_response = client.post(
"/api/auth/setup-admin",
json={
"username": "admin",
"email": "[email protected]",
"password": "admin123",
},
)
assert setup_response.status_code == 200
assert setup_response.json().get("success") is True
@pytest.fixture(scope="function")
def test_db():
from xagent.web.models.database import init_db
temp_dir = tempfile.mkdtemp()
temp_db_path = os.path.join(temp_dir, "test.db")
database_url = f"sqlite:///{temp_db_path}"
init_db(db_url=database_url)
engine = get_engine()
yield
Base.metadata.drop_all(bind=engine)
try:
import shutil
shutil.rmtree(temp_dir)
except OSError:
pass
@pytest.fixture(autouse=True)
def reset_workforce_policy():
set_workforce_policy(WorkforcePolicy())
yield
set_workforce_policy(WorkforcePolicy())
@pytest.fixture(scope="function")
def user1_headers(test_db):
ensure_system_initialized()
response = client.post(
"/api/auth/register",
json={
"username": "user1",
"email": "[email protected]",
"password": "password123",
},
)
assert response.status_code == 200
login = client.post(
"/api/auth/login", json={"username": "user1", "password": "password123"}
)
assert login.status_code == 200
token = login.json()["access_token"]
return {"Authorization": f"Bearer {token}"}
@pytest.fixture(scope="function")
def user2_headers(test_db):
ensure_system_initialized()
response = client.post(
"/api/auth/register",
json={
"username": "user2",
"email": "[email protected]",
"password": "password123",
},
)
assert response.status_code == 200
login = client.post(
"/api/auth/login", json={"username": "user2", "password": "password123"}
)
assert login.status_code == 200
token = login.json()["access_token"]
return {"Authorization": f"Bearer {token}"}
@pytest.fixture()
def sample_model_data():
return {
"model_id": "user2-private-model",
"category": "llm",
"model_provider": "openai",
"model_name": "gpt-4",
"api_key": "test-api-key",
"base_url": "https://api.openai.com/v1",
"temperature": 0.7,
"abilities": ["chat"],
"description": "User2 private model",
"share_with_users": False,
}
def create_test_models(headers, template, specs, *, shared=False):
for model_id, model_name in specs:
payload = dict(template)
payload.update(
{
"model_id": model_id,
"model_name": model_name,
"share_with_users": shared,
}
)
assert (
client.post("/api/models/", json=payload, headers=headers).status_code
== 200
)
class DummyLLM(BaseLLM):
def __init__(self, name: str):
self._name = name
@property
def abilities(self):
return ["chat"]
@property
def model_name(self):
return self._name
@property
def supports_thinking_mode(self):
return False
async def chat(self, messages, **kwargs):
return "ok"
def test_agent_builder_llm_overlay_preserves_resolved_task_llms():
manager = AgentServiceManager()
task_llm = DummyLLM("task-qwen")
task_compact = DummyLLM("task-compact")
merged = manager._merge_agent_builder_llms(
(task_llm, None, task_llm, task_compact),
(None, None, None, None),
)
assert merged == (task_llm, None, task_llm, task_compact)
def test_agent_builder_llm_overlay_uses_accessible_agent_llms():
manager = AgentServiceManager()
task_llm = DummyLLM("task-qwen")
agent_llm = DummyLLM("agent-model")
merged = manager._merge_agent_builder_llms(
(task_llm, None, task_llm, None),
(agent_llm, None, None, agent_llm),
)
assert merged == (agent_llm, None, task_llm, agent_llm)
def test_runtime_config_preserves_task_llm_when_agent_model_is_unavailable():
manager = AgentServiceManager()
task_llm = DummyLLM("task-qwen")
task = MagicMock(
agent_type="assistant",
model_name="qwen3.6-plus",
compact_model_name=None,
execution_mode="balanced",
agent_id=9,
user_id=71,
)
user = MagicMock(id=71)
from xagent.web.models.agent import AgentStatus
agent = MagicMock(
id=9,
user_id=71,
name="Published Agent",
execution_mode="balanced",
status=AgentStatus.PUBLISHED,
)
db = MagicMock()
db.query.return_value.filter.return_value.first.return_value = agent
fake_agent_builder_config = {
"llms": (None, None, None, None),
"saved_model_ids": {"general": 123},
"saved_model_descriptors": {
"general": {
"pk": 123,
"model_id": "glm4.6v",
"model_name": "glm4.6v",
}
},
"execution_mode": "balanced",
"instructions": "",
"skills": [],
"knowledge_bases": [],
"tool_categories": [],
}
# LLM resolution + agent-builder config loading moved to module-
# level ``resolve_task_runtime_config_core`` (called by both the
# instance method here and ``load_task_setup_snapshot_sync``);
# patch the helpers it actually invokes.
with (
patch(
"xagent.web.services.llm_utils.load_agent_builder_config",
return_value=fake_agent_builder_config,
) as load_cfg_mock,
patch(
"xagent.web.services.llm_utils.UserAwareModelStorage.resolve_llms_from_names",
return_value=(task_llm, None, None, None),
),
patch(
"xagent.web.services.llm_utils.make_normalize_model_id",
return_value=lambda mid, mname: mname,
),
):
runtime_config = manager._resolve_task_runtime_config(
task_id=42,
task=task,
db=db,
user=user,
)
assert runtime_config["task_llm"] is task_llm
load_cfg_mock.assert_called_once_with(agent, db, 71)
def test_runtime_config_uses_accessible_agent_model_over_task_baseline():
manager = AgentServiceManager()
task_llm = DummyLLM("task-qwen")
agent_llm = DummyLLM("agent-qwen")
task = MagicMock(
agent_type="assistant",
model_name="qwen3.6-plus",
compact_model_name=None,
execution_mode="balanced",
agent_id=9,
user_id=71,
)
user = MagicMock(id=71)
db = MagicMock()
from xagent.web.models.agent import AgentStatus
db.query.return_value.filter.return_value.first.return_value = MagicMock(
id=9,
user_id=71,
name="Published Agent",
execution_mode="balanced",
status=AgentStatus.PUBLISHED,
)
fake_agent_builder_config = {
"llms": (agent_llm, None, None, None),
"saved_model_ids": {"general": 123},
"saved_model_descriptors": {},
"execution_mode": "balanced",
"instructions": "",
"skills": [],
"knowledge_bases": [],
"tool_categories": [],
}
with (
patch(
"xagent.web.services.llm_utils.load_agent_builder_config",
return_value=fake_agent_builder_config,
),
patch(
"xagent.web.services.llm_utils.UserAwareModelStorage.resolve_llms_from_names",
return_value=(task_llm, None, None, None),
),
patch(
"xagent.web.services.llm_utils.make_normalize_model_id",
return_value=lambda mid, mname: mname,
),
):
runtime_config = manager._resolve_task_runtime_config(
task_id=42,
task=task,
db=db,
user=user,
)
assert runtime_config["task_llm"] is agent_llm
def test_pick_default_llm_warns_with_agent_context_when_builder_config_present(caplog):
"""Agent builder fallback should log human-readable model identifiers."""
default_llm = DummyLLM("default-llm")
with caplog.at_level(logging.WARNING, logger="xagent.web.api.chat"):
chosen = AgentServiceManager._pick_default_llm_with_warning(
default_llm,
task_id=42,
has_agent_builder_config=True,
agent_id=7,
saved_model_ids={"general": 11, "small_fast": None},
saved_model_descriptors={
"general": {
"pk": 11,
"model_id": "gpt-4o",
"model_name": "gpt-4o-2024-08-06",
},
},
user_id=99,
)
assert chosen is default_llm
matched = [
rec
for rec in caplog.records
if "falling back to default LLM" in rec.getMessage()
]
assert len(matched) == 1
message = matched[0].getMessage()
assert "task_id=42" in message
assert "agent_id=7" in message
assert "user_id=99" in message
# Descriptor fields are preferred over raw DB pks.
assert "gpt-4o" in message
assert "gpt-4o-2024-08-06" in message
assert "agent_saved_models=" in message
assert "fallback_model=default-llm" in message
def test_pick_default_llm_falls_back_to_saved_model_ids_when_descriptors_missing(
caplog,
):
"""Without descriptors the warning falls back to raw saved_model_ids."""
default_llm = DummyLLM("default-llm")
with caplog.at_level(logging.WARNING, logger="xagent.web.api.chat"):
AgentServiceManager._pick_default_llm_with_warning(
default_llm,
task_id=1,
has_agent_builder_config=True,
agent_id=2,
saved_model_ids={"general": 11},
user_id=3,
)
matched = [
rec
for rec in caplog.records
if "falling back to default LLM" in rec.getMessage()
]
assert len(matched) == 1
message = matched[0].getMessage()
assert "agent_saved_models=" in message
assert "general" in message
assert "11" in message
def test_pick_default_llm_warns_with_task_only_message_when_no_builder_config(caplog):
"""Without agent builder config we still warn but skip agent-specific fields."""
default_llm = DummyLLM("default-llm")
with caplog.at_level(logging.WARNING, logger="xagent.web.api.chat"):
chosen = AgentServiceManager._pick_default_llm_with_warning(
default_llm,
task_id=42,
has_agent_builder_config=False,
agent_id=None,
saved_model_ids=None,
user_id=None,
)
assert chosen is default_llm
matched = [
rec
for rec in caplog.records
if "no valid LLM configuration" in rec.getMessage()
]
assert len(matched) == 1
assert "Task 42" in matched[0].getMessage()
assert "default-llm" in matched[0].getMessage()
def test_pick_default_llm_raises_when_no_default_available():
"""If neither task/agent nor global default resolves, fail with a clear error."""
with pytest.raises(HTTPException) as exc_info:
AgentServiceManager._pick_default_llm_with_warning(
None,
task_id=42,
has_agent_builder_config=True,
agent_id=7,
saved_model_ids={"general": 11},
user_id=99,
)
assert exc_info.value.status_code == 500
assert "no global default model" in str(exc_info.value.detail)
def test_task_create_does_not_persist_inaccessible_model_ids(
test_db, user1_headers, user2_headers, sample_model_data
):
# User2 creates a private model.
created = client.post("/api/models/", json=sample_model_data, headers=user2_headers)
assert created.status_code == 200
created_model = created.json()
other_user_model_pk = str(created_model["id"])
other_user_model_id = created_model["model_id"]
# User1 tries to use User2's model by DB pk.
resp = client.post(
"/api/chat/task/create",
json={
"title": "test",
"description": "desc",
"llm_ids": [other_user_model_pk, None, None, None],
},
headers=user1_headers,
)
assert resp.status_code == 200
data = resp.json()
assert data["model_id"] != other_user_model_id
# User1 tries to use User2's model by internal stable model_id.
resp2 = client.post(
"/api/chat/task/create",
json={
"title": "test2",
"description": "desc",
"llm_ids": [other_user_model_id, None, None, None],
},
headers=user1_headers,
)
assert resp2.status_code == 200
data2 = resp2.json()
assert data2["model_id"] != other_user_model_id
def test_task_create_allows_shared_model_ids(
test_db, user1_headers, user2_headers, sample_model_data
):
"""When admin shares a model, other users can use it in task creation (Mode B two-step)."""
# Admin creates and shares a model
admin_login = client.post(
"/api/auth/login", json={"username": "admin", "password": "admin123"}
)
assert admin_login.status_code == 200
admin_headers = {"Authorization": f"Bearer {admin_login.json()['access_token']}"}
shared_data = dict(sample_model_data)
shared_data["share_with_users"] = True
shared_data["model_id"] = "admin-shared-model"
created = client.post("/api/models/", json=shared_data, headers=admin_headers)
assert created.status_code == 200
created_model = created.json()
shared_model_id = created_model["model_id"]
# User1 can use the shared model
resp = client.post(
"/api/chat/task/create",
json={
"title": "shared-model-task",
"description": "desc",
"llm_ids": [shared_model_id, None, None, None],
},
headers=user1_headers,
)
assert resp.status_code == 200
data = resp.json()
# The task should use the shared model
assert data["model_id"] == shared_model_id
def test_task_create_does_not_persist_inactive_owned_or_shared_model_ids(
test_db, user1_headers, sample_model_data
):
from xagent.web.models.database import get_db
from xagent.web.models.model import Model
# An owner link must not make a deactivated model runtime-available.
owned_data = dict(sample_model_data)
owned_data["model_id"] = "inactive-owned-model"
created_owned = client.post("/api/models/", json=owned_data, headers=user1_headers)
assert created_owned.status_code == 200
# A shared link must not bypass the same active gate for another user.
admin_login = client.post(
"/api/auth/login", json={"username": "admin", "password": "admin123"}
)
assert admin_login.status_code == 200
admin_headers = {"Authorization": f"Bearer {admin_login.json()['access_token']}"}
shared_data = dict(sample_model_data)
shared_data.update({"model_id": "inactive-shared-model", "share_with_users": True})
created_shared = client.post(
"/api/models/", json=shared_data, headers=admin_headers
)
assert created_shared.status_code == 200
db = next(get_db())
try:
inactive_ids = ("inactive-owned-model", "inactive-shared-model")
db.query(Model).filter(Model.model_id.in_(inactive_ids)).update(
{Model.is_active: False}, synchronize_session=False
)
db.commit()
finally:
db.close()
for model_id in inactive_ids:
response = client.post(
"/api/chat/task/create",
json={
"title": f"task-{model_id}",
"description": "desc",
"llm_ids": [model_id, None, None, None],
},
headers=user1_headers,
)
assert response.status_code == 200, response.text
assert response.json()["model_id"] != model_id
def test_task_create_falls_back_general_without_replacing_active_explicit_slots(
test_db, user1_headers, sample_model_data
):
from xagent.web.models.database import get_db
from xagent.web.models.model import Model
from xagent.web.models.user import User, UserDefaultModel
model_specs = [
("fallback-general-id", "fallback-general"),
("inactive-general-id", "inactive-general"),
("active-fast-id", "active-fast"),
("active-vision-id", "active-vision"),
("active-compact-id", "active-compact"),
]
create_test_models(user1_headers, sample_model_data, model_specs)
db = next(get_db())
try:
user = db.query(User).filter(User.username == "user1").one()
fallback = db.query(Model).filter(Model.model_id == "fallback-general-id").one()
inactive = db.query(Model).filter(Model.model_id == "inactive-general-id").one()
inactive.is_active = False
db.add(
UserDefaultModel(
user_id=user.id,
model_id=fallback.id,
config_type="general",
)
)
db.commit()
finally:
db.close()
response = client.post(
"/api/chat/task/create",
json={
"title": "slot-wise-create",
"description": "desc",
"llm_ids": [
"inactive-general-id",
"active-fast-id",
"active-vision-id",
"active-compact-id",
],
},
headers=user1_headers,
)
assert response.status_code == 200, response.text
data = response.json()
assert [
data["model_id"],
data["small_fast_model_id"],
data["visual_model_id"],
data["compact_model_id"],
] == [
"fallback-general-id",
"active-fast-id",
"active-vision-id",
"active-compact-id",
]
assert [
data["model_name"],
data["small_fast_model_name"],
data["visual_model_name"],
data["compact_model_name"],
] == ["fallback-general", "active-fast", "active-vision", "active-compact"]
def test_persisted_task_falls_back_general_without_replacing_active_slots(
test_db, user1_headers, sample_model_data
):
from xagent.web.models.database import get_db
from xagent.web.models.model import Model
from xagent.web.models.task import Task
from xagent.web.models.user import User, UserDefaultModel
from xagent.web.services.llm_utils import resolve_task_runtime_config_core
model_specs = [
("resume-fallback-id", "resume-fallback"),
("resume-general-id", "resume-general"),
("resume-fast-id", "resume-fast"),
("resume-vision-id", "resume-vision"),
("resume-compact-id", "resume-compact"),
]
create_test_models(user1_headers, sample_model_data, model_specs)
created = client.post(
"/api/chat/task/create",
json={
"title": "slot-wise-resume",
"description": "desc",
"llm_ids": [
"resume-general-id",
"resume-fast-id",
"resume-vision-id",
"resume-compact-id",
],
},
headers=user1_headers,
)
assert created.status_code == 200, created.text
db = next(get_db())
try:
user = db.query(User).filter(User.username == "user1").one()
fallback = db.query(Model).filter(Model.model_id == "resume-fallback-id").one()
general = db.query(Model).filter(Model.model_id == "resume-general-id").one()
general.is_active = False
db.add(
UserDefaultModel(
user_id=user.id,
model_id=fallback.id,
config_type="general",
)
)
db.commit()
task = db.get(Task, created.json()["task_id"])
runtime = resolve_task_runtime_config_core(task, db, user_id=user.id)
assert [llm.model_name if llm else None for llm in runtime.llms] == [
"resume-fallback",
"resume-fast",
"resume-vision",
"resume-compact",
]
finally:
db.close()
def test_task_create_shared_default_skips_inactive_and_accepts_active(
test_db, user1_headers, sample_model_data
):
from xagent.web.models.database import get_db
from xagent.web.models.model import Model
from xagent.web.models.user import User, UserDefaultModel
admin_login = client.post(
"/api/auth/login", json={"username": "admin", "password": "admin123"}
)
assert admin_login.status_code == 200
admin_headers = {"Authorization": f"Bearer {admin_login.json()['access_token']}"}
create_test_models(
admin_headers,
sample_model_data,
[("shared-default-id", "shared-default")],
shared=True,
)
db = next(get_db())
try:
admin = db.query(User).filter(User.username == "admin").one()
model = db.query(Model).filter(Model.model_id == "shared-default-id").one()
model.is_active = False
db.add(
UserDefaultModel(
user_id=admin.id,
model_id=model.id,
config_type="general",
)
)
db.commit()
finally:
db.close()
inactive_response = client.post(
"/api/chat/task/create",
json={"title": "inactive-shared-default", "description": "desc"},
headers=user1_headers,
)
assert inactive_response.status_code == 200, inactive_response.text
assert inactive_response.json()["model_id"] != "shared-default-id"
db = next(get_db())
try:
model = db.query(Model).filter(Model.model_id == "shared-default-id").one()
model.is_active = True
db.commit()
finally:
db.close()
active_response = client.post(
"/api/chat/task/create",
json={"title": "active-shared-default", "description": "desc"},
headers=user1_headers,
)
assert active_response.status_code == 200, active_response.text
assert active_response.json()["model_id"] == "shared-default-id"
assert active_response.json()["model_name"] == "shared-default"
def test_standalone_task_create_defaults_to_auto(test_db, user1_headers):
resp = client.post(
"/api/chat/task/create",
json={"title": "test", "description": "desc"},
headers=user1_headers,
)
assert resp.status_code == 200
assert resp.json()["execution_mode"] == "auto"
def test_web_task_detail_cache_reuses_response_until_task_changes(
test_db, user1_headers, monkeypatch
):
from xagent.web.services.hot_path_cache import (
InMemoryTTLCache,
set_cache_backend_for_testing,
)
set_cache_backend_for_testing(InMemoryTTLCache())
try:
create_resp = client.post(
"/api/chat/task/create",
json={"title": "cache-test", "description": "desc"},
headers=user1_headers,
)
assert create_resp.status_code == 200
task_id = create_resp.json()["task_id"]
first = client.get(f"/api/chat/task/{task_id}", headers=user1_headers)
assert first.status_code == 200
assert first.json()["title"] == "cache-test"
def fail_if_uncached(*args, **kwargs):
raise AssertionError("cache miss reached model id resolution")
monkeypatch.setattr(
AgentServiceManager,
"_get_task_llm_ids",
fail_if_uncached,
)
cached = client.get(f"/api/chat/task/{task_id}", headers=user1_headers)
assert cached.status_code == 200
assert cached.json()["title"] == "cache-test"
monkeypatch.undo()
update = client.put(
f"/api/chat/task/{task_id}",
json={"title": "cache-test-updated"},
headers=user1_headers,
)
assert update.status_code == 200
refreshed = client.get(f"/api/chat/task/{task_id}", headers=user1_headers)
assert refreshed.status_code == 200
assert refreshed.json()["title"] == "cache-test-updated"
finally:
set_cache_backend_for_testing(None)
def test_get_task_returns_token_usage_grouped_by_actual_model(test_db, user1_headers):
from xagent.web.models.task import Task
create_resp = client.post(
"/api/chat/task/create",
json={"title": "model-usage-test", "description": "desc"},
headers=user1_headers,
)
assert create_resp.status_code == 200
task_id = create_resp.json()["task_id"]
db = next(get_db())
try:
task = db.query(Task).filter(Task.id == task_id).one()
task.input_tokens = 120
task.output_tokens = 30
task.total_tokens = 150
task.token_usage_details = [
{
"type": "input",
"tokens": 100,
"model": "gpt-4.1",
"model_id": "main",
"cached_tokens": 60,
"cache_write_tokens": 15,
},
{
"type": "output",
"tokens": 25,
"model": "gpt-4.1",
"model_id": "main",
},
{
"type": "input",
"tokens": 20,
"model": "gpt-4.1-mini",
"model_id": "compact",
},
{
"type": "output",
"tokens": 5,
"model": "gpt-4.1-mini",
"model_id": "compact",
},
]
db.commit()
finally:
db.close()
response = client.get(f"/api/chat/task/{task_id}", headers=user1_headers)
assert response.status_code == 200
payload = response.json()
assert payload["model_usage"] == [
{
"model_id": "main",
"model_name": "gpt-4.1",
"input_tokens": 100,
"output_tokens": 25,
"cached_input_tokens": 60,
"cache_write_input_tokens": 15,
},
{
"model_id": "compact",
"model_name": "gpt-4.1-mini",
"input_tokens": 20,
"output_tokens": 5,
"cached_input_tokens": 0,
"cache_write_input_tokens": 0,
},
]
assert payload["cached_input_tokens"] == 60
assert payload["cache_write_input_tokens"] == 15
def test_get_task_returns_media_usage_grouped_by_model_and_unit(test_db, user1_headers):
"""Pin ``media_usage`` at the real route, not just at the aggregator.
The aggregator has its own unit tests and the frontend tests mock this
response, so both sides can stay green while the handler omits, renames or
fails to serialise the field. This asserts the exact payload the client
actually receives.
"""
from xagent.web.models.task import Task
create_resp = client.post(
"/api/chat/task/create",
json={"title": "media-usage-test", "description": "desc"},
headers=user1_headers,
)
assert create_resp.status_code == 200
task_id = create_resp.json()["task_id"]
db = next(get_db())
try:
task = db.query(Task).filter(Task.id == task_id).one()
task.token_usage_details = [
# Two calls on the same (model, unit, call_type, resolution) key
# must collapse into one row with summed quantity and calls.
{
"type": "media",
"model": "stable-diffusion-xl",
"model_id": "sd",
"unit": "images",
"call_type": "generate_image",
"resolution": "1K",
"quantity": 2,
"provider_tokens": 30,
},
{
"type": "media",
"model": "stable-diffusion-xl",
"model_id": "sd",
"unit": "images",
"call_type": "generate_image",
"resolution": "1K",
"quantity": 1,
"provider_tokens": 12,
"tokens_estimated": True,
},
# Zero quantity is meaningful and must survive: the call happened,
# its size is not known yet.
{
"type": "media",
"model": "veo-3",
"model_id": "veo",
"unit": "seconds",
"call_type": "video",
"quantity": 0,
},
# An LLM entry must not leak into media_usage.
{
"type": "input",
"tokens": 100,
"model": "gpt-4.1",
"model_id": "main",
},
]
db.commit()
finally:
db.close()
response = client.get(f"/api/chat/task/{task_id}", headers=user1_headers)
assert response.status_code == 200
payload = response.json()
assert payload["media_usage"] == [
{
"model_id": "sd",
"model_name": "stable-diffusion-xl",
"unit": "images",
"call_type": "generate_image",
"resolution": "1K",
"quantity": 3.0,
"calls": 2,
"provider_tokens": 42,
# True because one of the two merged entries was estimated: a mixed
# group must never be priced as if it were fully measured.
"tokens_estimated": True,
},
{
"model_id": "veo",
"model_name": "veo-3",
"unit": "seconds",
"call_type": "video",
"resolution": "",
"quantity": 0.0,
"calls": 1,
"provider_tokens": 0,
"tokens_estimated": False,
},
]
# The LLM entry stayed on its own side of the split.
assert [row["model_id"] for row in payload["model_usage"]] == ["main"]
def test_web_task_detail_cache_serves_media_usage_on_cache_hit(test_db, user1_headers):
"""A cache hit must carry ``media_usage``, not drop it on the second read.
The detail response is cached wholesale, so a field added to the miss path
only is invisible on every subsequent poll -- which is the path the usage
popover actually hits while a task runs.
"""
from xagent.web.models.task import Task
from xagent.web.services.hot_path_cache import (
InMemoryTTLCache,
set_cache_backend_for_testing,
)
set_cache_backend_for_testing(InMemoryTTLCache())
try:
create_resp = client.post(
"/api/chat/task/create",
json={"title": "media-cache-test", "description": "desc"},
headers=user1_headers,
)
assert create_resp.status_code == 200
task_id = create_resp.json()["task_id"]
db = next(get_db())
try:
task = db.query(Task).filter(Task.id == task_id).one()
task.token_usage_details = [
{
"type": "media",
"model": "elevenlabs-tts",
"model_id": "tts-1",
"unit": "characters",
"call_type": "tts",
"quantity": 480,
}
]
db.commit()
finally:
db.close()
first = client.get(f"/api/chat/task/{task_id}", headers=user1_headers)
assert first.status_code == 200
expected = [
{
"model_id": "tts-1",
"model_name": "elevenlabs-tts",
"unit": "characters",
"call_type": "tts",
"resolution": "",
"quantity": 480.0,
"calls": 1,
"provider_tokens": 0,
"tokens_estimated": False,
}
]
assert first.json()["media_usage"] == expected
cached = client.get(f"/api/chat/task/{task_id}", headers=user1_headers)
assert cached.status_code == 200
assert cached.json()["media_usage"] == expected
finally:
set_cache_backend_for_testing(None)
def test_get_task_llm_ids_preserves_stored_id_when_model_missing(test_db):
ensure_system_initialized()
from xagent.web.models.task import Task, TaskStatus
from xagent.web.models.user import User
db = next(get_db())
try:
admin = db.query(User).filter(User.username == "admin").first()
assert admin is not None
task = Task(
user_id=admin.id,
title="t",
description="d",
status=TaskStatus.PENDING,
model_id="deleted-model-id",
small_fast_model_id="deleted-fast-id",
visual_model_id="deleted-visual-id",
compact_model_id="deleted-compact-id",
)
db.add(task)
db.commit()
db.refresh(task)
manager = AgentServiceManager()
ids = manager._get_task_llm_ids(task, db)
assert ids[0] == "deleted-model-id"
assert ids[1] == "deleted-fast-id"
assert ids[2] == "deleted-visual-id"
assert ids[3] == "deleted-compact-id"
finally:
db.close()
def test_get_task_llm_ids_drops_stored_id_when_model_is_inactive(test_db):
ensure_system_initialized()
from xagent.web.models.database import get_db
from xagent.web.models.model import Model
from xagent.web.models.task import Task, TaskStatus
from xagent.web.models.user import User
db = next(get_db())
try:
admin = db.query(User).filter(User.username == "admin").one()
inactive = Model(
model_id="inactive-persisted-model",
category="llm",
model_provider="openai",
model_name="gpt-4.1",
api_key="test-key",
abilities=["chat"],
is_active=False,
)
db.add(inactive)
db.flush()
task = Task(
user_id=admin.id,
title="inactive persisted model",
description="d",
status=TaskStatus.PENDING,
model_id=inactive.model_id,
model_name=inactive.model_name,
)
db.add(task)
db.commit()
ids = AgentServiceManager()._get_task_llm_ids(task, db)
assert ids[0] is None
finally:
db.close()
def test_get_tasks_hides_invisible_tasks_by_default(test_db, user1_headers):
from xagent.web.models.database import get_db
from xagent.web.models.task import Task, TaskStatus
from xagent.web.models.user import User
db = next(get_db())
try:
user = db.query(User).filter(User.username == "user1").one()
normal_task = Task(
user_id=user.id,
title="normal task",
description="normal",
status=TaskStatus.PENDING,
)
sdk_task = Task(
user_id=user.id,
title="sdk task",
description="sdk",
status=TaskStatus.PENDING,
source="sdk",
is_visible=False,
)
db.add_all([normal_task, sdk_task])
db.commit()
default_response = client.get("/api/chat/tasks", headers=user1_headers)
assert default_response.status_code == 200
assert [task["title"] for task in default_response.json()["tasks"]] == [
"normal task"
]
include_response = client.get(
"/api/chat/tasks?include_hidden=true",
headers=user1_headers,
)
assert include_response.status_code == 200
assert {task["title"] for task in include_response.json()["tasks"]} == {
"normal task",
"sdk task",
}
finally:
db.close()
def test_task_search_matches_messages_before_pagination_and_preserves_scope(
test_db, user1_headers
):
from uuid import uuid4
from xagent.web.models.agent import Agent
from xagent.web.models.chat_message import TaskChatMessage
from xagent.web.models.task import Task, TaskStatus
from xagent.web.models.task_execution_event import TaskExecutionEvent
from xagent.web.models.user import User
db = next(get_db())
try:
user = db.query(User).filter(User.username == "user1").one()
admin = db.query(User).filter(User.username == "admin").one()
agent = Agent(user_id=user.id, name="Needle employee", instructions="Test")
db.add(agent)
db.flush()
fixtures = [
("needle title", {}),
("description match", {"description": "needle description"}),
("input match", {"input": "needle input"}),
("output match", {"output": "needle output"}),
("employee match", {"agent_id": agent.id}),
("legacy message", {"conversation_storage_version": 1}),
(
"canonical message",
{"conversation_storage_version": 2, "conversation_event_sequence": 1},
),
("needle hidden", {"is_visible": False}),
("needle foreign", {"user_id": admin.id}),
("unmatched", {}),
("stale projection", {"conversation_storage_version": 2}),
]
rows = {}
for title, values in fixtures:
task = Task(
**{
"user_id": user.id,
"title": title,
"status": TaskStatus.COMPLETED,
**values,
}
)
db.add(task)
db.flush()
rows[title] = task
for title in ("legacy message", "stale projection"):
for _ in range(2):
db.add(
TaskChatMessage(
task_id=rows[title].id,
user_id=user.id,
role="user",
content="needle 100% done",
message_type="user",
)
)
db.add(
TaskExecutionEvent(
event_id=str(uuid4()),
task_id=rows["canonical message"].id,
sequence=1,
scope_id="root",
idempotency_key="input:test",
kind="input_accepted",
payload_version=1,
payload={"content": "Needle canonical"},
occurred_at=datetime.now(UTC),
)
)
db.commit()
first = client.get(
"/api/chat/tasks",
params={"search": " NEEDLE ", "per_page": 2},
headers=user1_headers,
)
assert first.status_code == 200, first.text
assert first.json()["pagination"]["total_count"] == 7
assert first.json()["pagination"]["has_next"] is True
all_results = client.get(
"/api/chat/tasks",
params={"search": "needle", "per_page": 40},
headers=user1_headers,
)
assert {task["title"] for task in all_results.json()["tasks"]} == {
title for title, _ in fixtures[:7]
}
literal = client.get(
"/api/chat/tasks", params={"search": "%"}, headers=user1_headers
)
assert [task["title"] for task in literal.json()["tasks"]] == ["legacy message"]
finally:
db.close()
@pytest.mark.parametrize("storage_version", [1, 2])
def test_task_search_never_matches_redacted_assistant_diagnostics(
test_db, user1_headers, storage_version
):
from uuid import uuid4
from xagent.web.models.chat_message import TaskChatMessage
from xagent.web.models.task import Task, TaskStatus
from xagent.web.models.task_execution_event import TaskExecutionEvent
from xagent.web.models.user import User
from xagent.web.services.client_error_messages import CLIENT_SAFE_TASK_FAILURE
db = next(get_db())
try:
user = db.query(User).filter_by(username="user1").one()
task = Task(
user_id=user.id,
title="Failed conversation",
status=TaskStatus.FAILED,
conversation_storage_version=storage_version,
conversation_event_sequence=8,
)
db.add(task)
db.flush()
for sequence, (role, kind, content) in enumerate(
[
("assistant", "chat_response", "provider-secret-needle"),
("assistant", "assistant_message", "unknown-secret-needle"),
("assistant", "future_type", "future-secret-needle"),
(
"assistant",
"task_failure",
f"failure-secret-needle {CLIENT_SAFE_TASK_FAILURE}",
),
("assistant", "assistant_response", "safe-answer-needle"),
("user", "user_message", "user-input-needle"),
],
start=1,
):
if storage_version == 1:
db.add(
TaskChatMessage(
task_id=task.id,
user_id=user.id,
role=role,
message_type=kind,
content=content,
)
)
else:
db.add(
TaskExecutionEvent(
event_id=str(uuid4()),
task_id=task.id,
sequence=sequence,
scope_id="root",
idempotency_key=f"search:{sequence}",
kind="input_accepted"
if role == "user"
else "assistant_message",
payload_version=1,
payload={"content": content, "message_type": kind},
occurred_at=datetime.now(UTC),
)
)
db.commit()
for keyword in (
"provider-secret",
"unknown-secret",
"future-secret",
"failure-secret",
CLIENT_SAFE_TASK_FAILURE,
):
response = client.get(
"/api/chat/tasks", params={"search": keyword}, headers=user1_headers
)
assert response.status_code == 200, response.text
assert response.json()["pagination"]["total_count"] == 0
for keyword in ("safe-answer", "user-input"):
response = client.get(
"/api/chat/tasks", params={"search": keyword}, headers=user1_headers
)
assert [row["task_id"] for row in response.json()["tasks"]] == [task.id]
finally:
db.close()
def test_task_search_projects_only_public_canonical_questions(test_db, user1_headers):
from uuid import uuid4
from xagent.web.models.task import Task
from xagent.web.models.task_execution_event import TaskExecutionEvent
from xagent.web.models.user import User
db = next(get_db())
try:
user = db.query(User).filter_by(username="user1").one()
task = Task(
user_id=user.id,
title="Questions",
conversation_storage_version=2,
conversation_event_sequence=9,
)
db.add(task)
db.flush()
fixtures = [
("visible-needle", {}),
("hidden-needle", {"visible": False}),
("audit-needle", {"__audit_only__": True}),
("checkpoint-needle", {"checkpoint_type": "agent_execution_checkpoint"}),
("nonquestion-needle", {"expect_response": False}),
("child-needle", {}),
("zero-visible-needle", {"visible": 0}),
("string-response-needle", {"expect_response": "yes"}),
("empty-response-needle", {"expect_response": []}),
("uncommitted-needle", {}),
]
for sequence, (content, extra) in enumerate(fixtures, start=1):
db.add(
TaskExecutionEvent(
event_id=str(uuid4()),
task_id=task.id,
sequence=sequence,
scope_id="child" if sequence == 6 else "root",
idempotency_key=f"search:{sequence}",
kind="agent_message",
payload_version=1,
payload={
"data": {"message": content, "expect_response": True, **extra}
},
occurred_at=datetime.now(UTC),
)
)
db.commit()
for index, (keyword, _) in enumerate(fixtures):
response = client.get(
"/api/chat/tasks", params={"search": keyword}, headers=user1_headers
)
assert response.status_code == 200, response.text
expected = 1 if index in (0, 6, 7) else 0
assert response.json()["pagination"]["total_count"] == expected, keyword
finally:
db.close()
def test_agent_conversation_lookup_uses_latest_activity_and_preserves_scope(
test_db, user1_headers
):
from xagent.web.models.agent import Agent
from xagent.web.models.task import Task
from xagent.web.models.user import User
db = next(get_db())
try:
user = db.query(User).filter_by(username="user1").one()
admin = db.query(User).filter_by(username="admin").one()
agent = Agent(user_id=user.id, name="Teammate", instructions="Test")
other_agent = Agent(user_id=user.id, name="Other teammate", instructions="Test")
db.add_all([agent, other_agent])
db.flush()
for title, agent_id, owner_id, visible, created, updated in [
("resumed old chat", agent.id, user.id, True, 1, 10),
("newer creation", agent.id, user.id, True, 5, 6),
("hidden", agent.id, user.id, False, 11, 11),
("foreign", agent.id, admin.id, True, 12, 12),
("different teammate", other_agent.id, user.id, True, 13, 13),
]:
db.add(
Task(
user_id=owner_id,
agent_id=agent_id,
title=title,
is_visible=visible,
created_at=datetime(2026, 10, created, tzinfo=UTC),
updated_at=datetime(2026, 10, updated, tzinfo=UTC),
)
)
db.commit()
response = client.get(
"/api/chat/tasks",
params={"agent_id": agent.id, "per_page": 1},
headers=user1_headers,
)
assert response.status_code == 200, response.text
assert response.json()["pagination"]["total_count"] == 2
assert [task["title"] for task in response.json()["tasks"]] == [
"resumed old chat"
]
finally:
db.close()
def test_get_tasks_returns_channel_type(test_db, user1_headers):
from xagent.web.models.database import get_db
from xagent.web.models.task import Task, TaskStatus
from xagent.web.models.user import User
from xagent.web.models.user_channel import UserChannel
db = next(get_db())
try:
user = db.query(User).filter(User.username == "user1").one()
telegram_channel = UserChannel(
user_id=user.id,
channel_type="telegram",
channel_name="Xagent Telegram",
config={},
is_active=True,
)
feishu_channel = UserChannel(
user_id=user.id,
channel_type="feishu",
channel_name="Xagent Feishu",
config={},
is_active=True,
)
db.add_all([telegram_channel, feishu_channel])
db.flush()
db.add_all(
[
Task(
user_id=user.id,
title="telegram task",
description="from channel",
status=TaskStatus.PENDING,
channel_id=telegram_channel.id,
channel_name=telegram_channel.channel_name,
),
Task(
user_id=user.id,
title="feishu task",
description="from channel",
status=TaskStatus.PENDING,
channel_id=feishu_channel.id,
channel_name=feishu_channel.channel_name,
),
Task(
user_id=user.id,
title="deleted channel task",
description="from deleted channel",
status=TaskStatus.PENDING,
channel_id=None,
channel_name="Deleted Telegram",
),
]
)
db.commit()
response = client.get("/api/chat/tasks", headers=user1_headers)
assert response.status_code == 200
tasks_by_title = {
item["title"]: item
for item in response.json()["tasks"]
if item["title"] in {"telegram task", "feishu task", "deleted channel task"}
}
assert tasks_by_title["telegram task"]["channel_type"] == "telegram"
assert tasks_by_title["telegram task"]["channel_name"] == "Xagent Telegram"
assert tasks_by_title["feishu task"]["channel_type"] == "feishu"
assert tasks_by_title["feishu task"]["channel_name"] == "Xagent Feishu"
assert tasks_by_title["deleted channel task"]["channel_type"] is None
assert (
tasks_by_title["deleted channel task"]["channel_name"] == "Deleted Telegram"
)
finally:
db.close()
def test_task_create_skips_stale_user_default(test_db, user1_headers):
"""When a user's default model is no longer visible, task falls back to admin shared."""
from xagent.web.models.database import get_db
from xagent.web.models.model import Model as DBModel
from xagent.web.models.user import User, UserDefaultModel, UserModel
db = next(get_db())
try:
user1 = db.query(User).filter(User.username == "user1").first()
admin = db.query(User).filter(User.username == "admin").first()
assert user1 is not None
assert admin is not None
# -- Admin shared fallback model --
admin_shared_model = DBModel(
model_id="admin-shared-fallback",
category="llm",
model_provider="openai",
model_name="gpt-4",
api_key="test-key",
base_url="https://api.openai.com/v1",
temperature=0.7,
abilities=["chat"],
is_active=True,
)
db.add(admin_shared_model)
db.commit()
db.refresh(admin_shared_model)
db.add(
UserModel(
user_id=admin.id,
model_id=admin_shared_model.id,
is_owner=True,
is_shared=True,
)
)
db.add(
UserDefaultModel(
user_id=admin.id,
model_id=admin_shared_model.id,
config_type="general",
)
)
# -- User1's stale default (model with no UserModel row) --
stale_model = DBModel(
model_id="stale-inaccessible-model",
category="llm",
model_provider="openai",
model_name="gpt-4",
api_key="test-key",
base_url="https://api.openai.com/v1",
temperature=0.7,
abilities=["chat"],
is_active=True,
)
db.add(stale_model)
db.commit()
db.refresh(stale_model)
db.add(
UserDefaultModel(
user_id=user1.id,
model_id=stale_model.id,
config_type="general",
)
)
db.commit()
# Create task without specifying llm_ids — should resolve to admin shared fallback
resp = client.post(
"/api/chat/task/create",
json={"title": "test-stale", "description": "desc"},
headers=user1_headers,
)
assert resp.status_code == 200
data = resp.json()
# Must NOT use the stale inaccessible model
assert data.get("model_id") != "stale-inaccessible-model"
# Must use admin's shared fallback model
assert data.get("model_id") == "admin-shared-fallback"
finally:
db.close()
def test_task_create_rejects_agent_id_from_another_user(
test_db, user1_headers, user2_headers
):
from xagent.web.models.agent import Agent, AgentStatus
from xagent.web.models.database import get_db
from xagent.web.models.user import User
db = next(get_db())
try:
user2 = db.query(User).filter(User.username == "user2").first()
assert user2 is not None
agent = Agent(
user_id=user2.id,
name="user2-private-agent",
description="private",
status=AgentStatus.DRAFT,
)
db.add(agent)
db.commit()
db.refresh(agent)
resp = client.post(
"/api/chat/task/create",
json={
"title": "agent-ownership-check",
"description": "desc",
"agent_id": agent.id,
},
headers=user1_headers,
)
assert resp.status_code == 404
assert resp.json()["detail"] == "Agent not found or access denied"
finally:
db.close()
def test_task_create_rejects_generated_workforce_manager_agent(
test_db,
user1_headers,
):
from xagent.web.models.agent import Agent, AgentOrigin, AgentStatus
from xagent.web.models.database import get_db
from xagent.web.models.task import Task, TaskStatus
from xagent.web.models.user import User
db = next(get_db())
try:
user1 = db.query(User).filter(User.username == "user1").first()
assert user1 is not None
agent = Agent(
user_id=user1.id,
name="generated-workforce-manager",
description="private manager",
status=AgentStatus.PUBLISHED,
origin=AgentOrigin.WORKFORCE_GENERATED_MANAGER.value,
)
db.add(agent)
db.commit()
db.refresh(agent)
resp = client.post(
"/api/chat/task/create",
json={
"title": "generated-manager-task",
"description": "desc",
"agent_id": agent.id,
},
headers=user1_headers,
)
assert resp.status_code == 404
assert resp.json()["detail"] == "Agent not found or access denied"
task = Task(
user_id=user1.id,
title="legacy generated manager task",
description="legacy",
status=TaskStatus.PENDING,
agent_id=agent.id,
)
db.add(task)
db.commit()
db.refresh(task)
assert _load_agent_for_task_runtime(db, task) is None
finally:
db.close()
def test_task_create_allows_policy_visible_published_agent(
test_db, user1_headers, user2_headers
):
from xagent.web.models.agent import Agent, AgentStatus
from xagent.web.models.database import get_db
from xagent.web.models.mcp import MCPServer, UserMCPServer
from xagent.web.models.task import Task
from xagent.web.models.user import User
class VisibleAgentPolicy(WorkforcePolicy):
def __init__(self, visible_agent_ids: set[int]) -> None:
self.visible_agent_ids = visible_agent_ids
def get_visible_agent_ids(self, db, user, purpose: str) -> set[int] | None:
del db, user
return self.visible_agent_ids if purpose == "agent_list" else None
db = next(get_db())
try:
user1 = db.query(User).filter(User.username == "user1").first()
assert user1 is not None
user2 = db.query(User).filter(User.username == "user2").first()
assert user2 is not None
shared_agent = Agent(
user_id=user2.id,
name="user2-shared-agent",
description="shared",
instructions="Use shared instructions.",
execution_mode="think",
status=AgentStatus.PUBLISHED,
tool_categories=["mcp"],
)
db.add(shared_agent)
owner_server = MCPServer(
name="owner-runtime-server",
description="owner connector",
managed="external",
transport="streamable_http",
url="https://example.com/owner/mcp",
runtime_input_schema={
"context": {"account_id": {"type": "string", "required": False}}
},
)
actor_server = MCPServer(
name="actor-runtime-server",
description="actor connector",
managed="external",
transport="streamable_http",
url="https://example.com/actor/mcp",
runtime_input_schema={
"context": {"account_id": {"type": "string", "required": False}}
},
)
db.add_all([owner_server, actor_server])
db.flush()
db.add_all(
[
UserMCPServer(
user_id=user2.id,
mcpserver_id=owner_server.id,
is_owner=True,
is_active=True,
),
UserMCPServer(
user_id=user1.id,
mcpserver_id=actor_server.id,
is_owner=True,
is_active=True,
),
]
)
db.commit()
db.refresh(shared_agent)
db.refresh(owner_server)
db.refresh(actor_server)
set_workforce_policy(VisibleAgentPolicy({int(shared_agent.id)}))
resp = client.post(
"/api/chat/task/create",
json={
"title": "shared-agent-task",
"description": "desc",
"agent_id": shared_agent.id,
},
headers=user1_headers,
)
assert resp.status_code == 200, resp.text
task = db.query(Task).filter(Task.id == resp.json()["task_id"]).one()
assert int(task.agent_id) == int(shared_agent.id)
assert _load_agent_for_task_runtime(db, task) == shared_agent
assert task.connector_runtime_selected_refs == [
{"connector_type": "mcp", "connector_id": int(actor_server.id)}
]
assert {"connector_type": "mcp", "connector_id": int(owner_server.id)} not in (
task.connector_runtime_selected_refs or []
)
from xagent.web.services.task_setup_snapshot import (
load_task_setup_snapshot_sync,
)
snapshot = load_task_setup_snapshot_sync(
int(task.id),
task_owner_user_id=int(task.user_id),
)
assert snapshot is not None
assert snapshot.agent is not None
assert snapshot.agent.id == int(shared_agent.id)
assert snapshot.excluded_agent_id == int(shared_agent.id)
finally:
db.close()
def test_delete_task_removes_trace_blobs_and_task_owned_rows(test_db, user1_headers):
from xagent.web.models.chat_message import TaskChatMessage
from xagent.web.models.database import get_db
from xagent.web.models.task import (
DAGExecution,
DAGExecutionPhase,
Task,
TaskStatus,
TraceCheckpointBlob,
TraceEvent,
TraceMessageBlob,
)
from xagent.web.models.uploaded_file import UploadedFile
from xagent.web.models.user import User
db = next(get_db())
try:
user = db.query(User).filter(User.username == "user1").first()
assert user is not None
task = Task(
user_id=user.id,
title="delete me",
description="task with task-owned rows",
status=TaskStatus.COMPLETED,
)
db.add(task)
db.flush()
db.add_all(
[
DAGExecution(
task_id=task.id,
phase=DAGExecutionPhase.COMPLETED,
),
TraceEvent(
task_id=task.id,
build_id=None,
event_id="vibe-event",
event_type="dag_execute_end",
timestamp=datetime.now(UTC),
data={"ok": True},
),
TraceEvent(
task_id=task.id,
build_id="builder-session",
event_id="build-event",
event_type="agent_message",
timestamp=datetime.now(UTC),
data={"ok": True},
),
TraceMessageBlob(
task_id=task.id,
execution_id="exec-delete",
message_hash="message-hash",
message_data={"role": "user", "content": "hello"},
message_bytes=42,
),
TraceCheckpointBlob(
task_id=task.id,
execution_id="exec-delete",
blob_kind="messages",
blob_hash="checkpoint-hash",
blob_data={"messages": []},
blob_bytes=17,
),
TaskChatMessage(
task_id=task.id,
user_id=user.id,
role="user",
content="hello",
message_type="user_message",
),
UploadedFile(
user_id=user.id,
task_id=task.id,
filename="input.txt",
storage_path=f"/tmp/task-{task.id}/input.txt",
file_size=5,
),
]
)
db.commit()
task_id = int(task.id)
finally:
db.close()
resp = client.delete(f"/api/chat/task/{task_id}", headers=user1_headers)
assert resp.status_code == 200, resp.text
db = next(get_db())
try:
assert db.query(Task).filter(Task.id == task_id).count() == 0
assert db.query(TraceMessageBlob).filter_by(task_id=task_id).count() == 0
assert db.query(TraceCheckpointBlob).filter_by(task_id=task_id).count() == 0
assert db.query(TraceEvent).filter_by(task_id=task_id).count() == 0
assert db.query(DAGExecution).filter_by(task_id=task_id).count() == 0
assert db.query(TaskChatMessage).filter_by(task_id=task_id).count() == 0
assert db.query(UploadedFile).filter_by(task_id=task_id).count() == 0
finally:
db.close()
def test_delete_task_keeps_cross_user_access_denied(
test_db, user1_headers, user2_headers
):
from xagent.web.models.database import get_db
from xagent.web.models.task import Task
from xagent.web.models.user import User
db = next(get_db())
try:
user2 = db.query(User).filter(User.username == "user2").first()
assert user2 is not None
task = Task(user_id=user2.id, title="private", description="private")
db.add(task)
db.commit()
task_id = int(task.id)
finally:
db.close()
resp = client.delete(f"/api/chat/task/{task_id}", headers=user1_headers)
assert resp.status_code == 404
db = next(get_db())
try:
assert db.query(Task).filter(Task.id == task_id).count() == 1
finally:
db.close()
def test_filtered_runtime_provider_environment_is_not_added_to_system_prompt():
from xagent.core.agent.service import AgentService
from xagent.core.task_runtime import (
TaskRuntimeContribution,
merge_task_runtime_contributions,
reconcile_task_runtime_contribution_tools,
)
from xagent.core.tools.adapters.vibe.config import ToolConfig
runtime_tool = MagicMock()
runtime_tool.name = "leased_browser"
contribution = merge_task_runtime_contributions(
{
"browser_runtime": TaskRuntimeContribution(
tools=(runtime_tool,),
environment="Use the leased browser.",
)
}
)
filtered, _conflicts = reconcile_task_runtime_contribution_tools(
contribution,
available_tools=(),
)
tool_config = ToolConfig({})
tool_config.get_task_runtime_contribution = lambda: filtered
service = AgentService(
name="filtered-runtime-prompt",
id="filtered-runtime-prompt",
tools=[],
tool_config=tool_config,
enable_workspace=False,
system_prompt="Base prompt.",
)
assert service.system_prompt == "Base prompt."
class _TaskRuntimeProvider:
def __init__(
self,
*,
fail_create: bool = False,
metadata_error: Exception | None = None,
):
self.fail_create = fail_create
self.metadata_error = metadata_error
self.events: list[tuple[str, int]] = []
self.configuration: dict | None = None
self.task_existed_on_delete: list[bool] = []
async def on_task_created(self, context, configuration):
self.events.append(("created", context.task_id))
self.configuration = dict(configuration)
if self.fail_create:
raise TaskRuntimeClientError("invalid target")
async def build_runtime(self, context):
from xagent.core.task_runtime import TaskRuntimeContribution
return TaskRuntimeContribution()
async def public_metadata(self, context):
if self.metadata_error is not None:
raise self.metadata_error
return {"target": self.configuration["target"]} if self.configuration else {}
async def on_task_deleted(self, context):
from xagent.web.models.task import Task
db = context.session_factory()
try:
self.task_existed_on_delete.append(
db.query(Task).filter(Task.id == context.task_id).count() == 1
)
finally:
db.close()
self.events.append(("deleted", context.task_id))
def test_task_runtime_unknown_extension_error_does_not_disclose_registry(
test_db,
user1_headers,
):
response = client.post(
"/api/chat/task/create",
json={
"title": "unknown runtime",
"runtime_extensions": {"private-provider-name": {}},
},
headers=user1_headers,
)
assert response.status_code == 400
assert response.json()["detail"] == "Invalid task runtime extension request"
assert "private-provider-name" not in response.text
def test_task_runtime_extension_create_metadata_and_delete_lifecycle(
test_db,
user1_headers,
user2_headers,
monkeypatch,
):
import xagent.web.api.chat as chat_module
from xagent.web.services.task_runtime import (
register_task_extension,
unregister_task_extension,
)
release_count = 0
original_release = chat_module.release_db_connection_if_clean
def record_release(db):
nonlocal release_count
release_count += 1
return original_release(db)
monkeypatch.setattr(
chat_module,
"release_db_connection_if_clean",
record_release,
)
class _ReleaseAwareProvider(_TaskRuntimeProvider):
minimum_release_count = 1
async def on_task_created(self, context, configuration):
assert release_count >= self.minimum_release_count
await super().on_task_created(context, configuration)
async def public_metadata(self, context):
assert release_count >= self.minimum_release_count
return await super().public_metadata(context)
provider = _ReleaseAwareProvider()
register_task_extension("test_runtime", provider)
try:
response = client.post(
"/api/chat/task/create",
json={
"title": "runtime task",
"description": "inspect the selected target",
"runtime_extensions": {"test_runtime": {"target": "approved_browser"}},
},
headers=user1_headers,
)
assert response.status_code == 200, response.text
task_id = response.json()["task_id"]
assert response.json()["runtime_extensions"] == {
"test_runtime": {"target": "approved_browser"}
}
assert response.json()["runtime_extensions_status"] == "complete"
assert response.json()["runtime_extensions_omitted"] == []
provider.minimum_release_count = release_count + 1
metadata = client.get(
f"/api/chat/task/{task_id}/runtime-extensions",
headers=user1_headers,
)
assert metadata.status_code == 200
assert metadata.json()["runtime_extensions"] == {
"test_runtime": {"target": "approved_browser"}
}
assert metadata.json()["runtime_extensions_status"] == "complete"
assert metadata.json()["runtime_extensions_omitted"] == []
denied = client.get(
f"/api/chat/task/{task_id}/runtime-extensions",
headers=user2_headers,
)
assert denied.status_code == 404
deleted = client.delete(
f"/api/chat/task/{task_id}",
headers=user1_headers,
)
assert deleted.status_code == 200
assert provider.events == [
("created", task_id),
("deleted", task_id),
]
assert provider.task_existed_on_delete == [True]
finally:
unregister_task_extension("test_runtime")
@pytest.mark.parametrize(
("metadata_error", "expected_status", "expected_detail"),
[
(
TaskRuntimeClientError("target denied", status_code=403),
403,
"target denied",
),
(TaskRuntimeClientError("invalid metadata"), 400, "invalid metadata"),
(TypeError("provider implementation detail"), 500, "Internal server error"),
(RuntimeError("database unavailable"), 500, "Internal server error"),
],
)
def test_task_runtime_metadata_maps_provider_error_status(
test_db,
user1_headers,
metadata_error,
expected_status,
expected_detail,
):
from xagent.web.services.task_runtime import (
register_task_extension,
unregister_task_extension,
)
provider = _TaskRuntimeProvider(metadata_error=metadata_error)
register_task_extension("test_runtime", provider)
task_id = None
try:
response = client.post(
"/api/chat/task/create",
json={
"title": "runtime metadata error",
"runtime_extensions": {"test_runtime": {"target": "approved_browser"}},
},
headers=user1_headers,
)
assert response.status_code == 200, response.text
task_id = response.json()["task_id"]
assert response.json()["runtime_extensions_status"] == "failed"
assert response.json()["runtime_extensions_omitted"] == []
metadata = client.get(
f"/api/chat/task/{task_id}/runtime-extensions",
headers=user1_headers,
)
assert metadata.status_code == expected_status
assert metadata.json()["detail"] == expected_detail
finally:
if task_id is not None:
client.delete(
f"/api/chat/task/{task_id}",
headers=user1_headers,
)
unregister_task_extension("test_runtime")
def test_task_runtime_extension_create_failure_compensates_task(
test_db,
user1_headers,
):
from xagent.web.models.database import get_db
from xagent.web.models.task import Task
from xagent.web.services.task_runtime import (
register_task_extension,
unregister_task_extension,
)
provider = _TaskRuntimeProvider(fail_create=True)
register_task_extension("test_runtime", provider)
try:
response = client.post(
"/api/chat/task/create",
json={
"title": "invalid runtime task",
"description": "must be compensated",
"runtime_extensions": {"test_runtime": {"target": "missing"}},
},
headers=user1_headers,
)
assert response.status_code == 400
db = next(get_db())
try:
assert (
db.query(Task).filter(Task.title == "invalid runtime task").count() == 0
)
finally:
db.close()
assert [event for event, _task_id in provider.events] == [
"created",
"deleted",
]
finally:
unregister_task_extension("test_runtime")
def test_task_runtime_extension_create_server_error_is_sanitized(
test_db,
user1_headers,
):
from xagent.web.models.database import get_db
from xagent.web.models.task import Task
from xagent.web.services.task_runtime import (
register_task_extension,
unregister_task_extension,
)
provider = _TaskRuntimeProvider()
async def fail_create(context, configuration):
provider.events.append(("created", context.task_id))
raise RuntimeError("database password leaked")
provider.on_task_created = fail_create
register_task_extension("test_runtime", provider)
try:
response = client.post(
"/api/chat/task/create",
json={
"title": "unavailable runtime task",
"runtime_extensions": {"test_runtime": {"target": "missing"}},
},
headers=user1_headers,
)
assert response.status_code == 503
assert response.json()["detail"] == "Service unavailable"
assert "database password leaked" not in response.text
db = next(get_db())
try:
assert (
db.query(Task).filter(Task.title == "unavailable runtime task").count()
== 0
)
finally:
db.close()
finally:
unregister_task_extension("test_runtime")
def test_task_runtime_extension_compensation_failure_preserves_client_error(
test_db,
user1_headers,
monkeypatch,
):
import xagent.web.api.chat as chat_module
provider = _TaskRuntimeProvider(fail_create=True)
from xagent.web.services.task_runtime import (
register_task_extension,
unregister_task_extension,
)
def fail_compensation(db, *, task_id):
raise RuntimeError("compensation database unavailable")
monkeypatch.setattr(
chat_module,
"_compensate_failed_task_extension_create",
fail_compensation,
)
register_task_extension("test_runtime", provider)
try:
response = client.post(
"/api/chat/task/create",
json={
"title": "failed compensation task",
"runtime_extensions": {"test_runtime": {"target": "missing"}},
},
headers=user1_headers,
)
assert response.status_code == 400
assert response.json()["detail"] == "invalid target"
assert "compensation database unavailable" not in response.text
finally:
unregister_task_extension("test_runtime")
def test_create_task_records_runtime_extension_bindings_for_deletion(
test_db,
user1_headers,
):
"""End-to-end: create records the binding, delete dispatches on it.
Without a persisted binding record the delete path has no way to tell which
providers own state for this task, and would have to fall back to the whole
process-wide registry.
"""
from xagent.web.models.database import get_db
from xagent.web.models.task import Task
from xagent.web.services.task_runtime import (
register_task_extension,
task_extension_bindings_from_agent_config,
unregister_task_extension,
)
provider = _TaskRuntimeProvider()
register_task_extension("test_runtime", provider)
try:
created = client.post(
"/api/chat/task/create",
json={
"title": "bound task",
"runtime_extensions": {"test_runtime": {"target": "one"}},
},
headers=user1_headers,
)
assert created.status_code == 200, created.text
task_id = int(created.json()["task_id"])
db = next(get_db())
try:
task = db.query(Task).filter(Task.id == task_id).one()
assert task_extension_bindings_from_agent_config(task.agent_config) == (
"test_runtime",
)
finally:
db.close()
deleted = client.delete(f"/api/chat/task/{task_id}", headers=user1_headers)
assert deleted.status_code == 200, deleted.text
assert ("deleted", task_id) in provider.events
finally:
unregister_task_extension("test_runtime")
def test_delete_task_reports_concurrent_disappearance(
test_db,
user1_headers,
monkeypatch,
):
import xagent.web.services.task_delete as task_delete_module
from xagent.web.models.database import get_db
from xagent.web.models.task import Task
from xagent.web.models.user import User
db = next(get_db())
try:
user = db.query(User).filter(User.username == "user1").one()
task = Task(user_id=user.id, title="concurrent delete", description="")
db.add(task)
db.commit()
task_id = int(task.id)
finally:
db.close()
monkeypatch.setattr(
task_delete_module, "_delete_task_rows_sync", lambda **_kwargs: None
)
response = client.delete(f"/api/chat/task/{task_id}", headers=user1_headers)
assert response.status_code == 404
assert response.json()["detail"] == "Task no longer exists"
def test_delete_task_core_failure_is_retry_safe_for_idempotent_provider(
test_db,
user1_headers,
monkeypatch,
):
import xagent.web.services.task_delete as task_delete_module
from xagent.web.models.database import get_db
from xagent.web.models.task import Task
from xagent.web.models.user import User
from xagent.web.services.task_runtime import (
agent_config_with_task_extension_bindings,
register_task_extension,
unregister_task_extension,
)
provider = _TaskRuntimeProvider()
register_task_extension("test_runtime", provider)
db = next(get_db())
try:
user = db.query(User).filter(User.username == "user1").one()
# Cleanup dispatch is filtered by the task's binding record, so the
# task has to actually claim the provider for this retry to exercise it.
task = Task(
user_id=user.id,
title="retry delete",
description="",
agent_config=agent_config_with_task_extension_bindings(
{}, ["test_runtime"]
),
)
db.add(task)
db.commit()
task_id = int(task.id)
finally:
db.close()
original_delete = task_delete_module._delete_task_rows_sync
def fail_delete(**_kwargs):
raise RuntimeError("core delete unavailable")
try:
monkeypatch.setattr(task_delete_module, "_delete_task_rows_sync", fail_delete)
first = client.delete(f"/api/chat/task/{task_id}", headers=user1_headers)
assert first.status_code == 500
assert first.json()["detail"] == "Internal server error"
db = next(get_db())
try:
assert db.query(Task).filter(Task.id == task_id).count() == 1
finally:
db.close()
monkeypatch.setattr(
task_delete_module, "_delete_task_rows_sync", original_delete
)
second = client.delete(f"/api/chat/task/{task_id}", headers=user1_headers)
assert second.status_code == 200
assert [event for event, _task_id in provider.events] == [
"deleted",
"deleted",
]
finally:
unregister_task_extension("test_runtime")
def test_delete_task_runtime_cleanup_failure_preserves_task_for_retry(
test_db,
user1_headers,
):
from xagent.web.models.database import get_db
from xagent.web.models.task import Task
from xagent.web.models.user import User
from xagent.web.services.task_runtime import (
agent_config_with_task_extension_bindings,
register_task_extension,
unregister_task_extension,
)
class _FailingDeleteProvider(_TaskRuntimeProvider):
async def on_task_deleted(self, context):
await super().on_task_deleted(context)
raise RuntimeError("provider cleanup failed")
provider = _FailingDeleteProvider()
register_task_extension("failing_runtime", provider)
db = next(get_db())
try:
user = db.query(User).filter(User.username == "user1").one()
task = Task(
user_id=user.id,
title="preserve for retry",
description="",
agent_config=agent_config_with_task_extension_bindings(
{}, ["failing_runtime"]
),
)
db.add(task)
db.commit()
task_id = int(task.id)
finally:
db.close()
try:
response = client.delete(
f"/api/chat/task/{task_id}",
headers=user1_headers,
)
assert response.status_code == 503
assert response.json()["detail"] == (
"Runtime extension cleanup failed; the task was not deleted"
)
db = next(get_db())
try:
assert db.query(Task).filter(Task.id == task_id).count() == 1
finally:
db.close()
finally:
unregister_task_extension("failing_runtime")
def test_task_create_seeds_assistant_message(test_db, user1_headers):
"""`seed_assistant_message` should land as the task's first (and only)
chat history row, committed in the same request as task creation - the
AI Team Marketplace's "Hire" flow relies on this to let a persona speak
first without ever running the LLM."""
from xagent.web.models.chat_message import TaskChatMessage
resp = client.post(
"/api/chat/task/create",
json={
"title": "Hire Leo",
"seed_assistant_message": "Hi — I'm Leo, your Email Lead Response Agent.",
},
headers=user1_headers,
)
assert resp.status_code == 200
task_id = resp.json()["task_id"]
db = next(get_db())
try:
messages = (
db.query(TaskChatMessage)
.filter_by(task_id=task_id)
.order_by(TaskChatMessage.id)
.all()
)
assert len(messages) == 1
assert messages[0].role == "assistant"
assert messages[0].message_type == "assistant_response"
assert messages[0].content == "Hi — I'm Leo, your Email Lead Response Agent."
finally:
db.close()
@pytest.mark.parametrize("include_summary", [False, True])
def test_task_create_seeds_interactions_alongside_the_assistant_message(
test_db, user1_headers, include_summary
):
"""`seed_interactions` should ride along on the seeded assistant message's
row - the AI Team Marketplace's "connect your apps" card is delivered
this way, attached to the same seeded intro message."""
from xagent.web.models.chat_message import TaskChatMessage
from xagent.web.models.user import User
connect_apps_interaction = {
"type": "connect_apps",
"field": "connect_apps",
"label": "Connect your apps",
"apps": ["Gmail", "Google Calendar"],
}
interactions = [connect_apps_interaction]
if include_summary:
connect_apps_interaction["group_by_provider"] = True
interactions.insert(
0,
{
"type": "teammate_summary",
"field": "teammate_summary",
"label": "Email Lead Response Agent",
"description": "Draft replies to inbound leads.",
"placeholder": "What should we work on first?",
"apps": ["Gmail", "Google Calendar"],
},
)
resp = client.post(
"/api/chat/task/create",
json={
"title": "Hire Leo",
"seed_assistant_message": "Hi — I'm Leo.",
"seed_interactions": interactions,
},
headers=user1_headers,
)
assert resp.status_code == 200
task_id = resp.json()["task_id"]
db = next(get_db())
try:
message = db.query(TaskChatMessage).filter_by(task_id=task_id).one()
assert message.interactions == interactions
user1_id = db.query(User).filter_by(username="user1").one().id
finally:
db.close()
# The DB row alone doesn't prove a client ever actually sees the card
# again - assert what historical websocket replay (websocket.py) emits
# for it too, so a regression there (e.g. dropping metadata.interactions,
# or flipping expect_response back to True and re-opening a stale
# question) can't silently remove the card on reload without any test
# noticing.
from xagent.web.api import websocket as websocket_api
snapshot = websocket_api._load_historical_stream_snapshot_sync(
task_id, actor_user_id=user1_id, actor_is_admin=False
)
assert snapshot is not None
agent_events = [
event["data"]
for event in snapshot.events
if event.get("event_type") == "agent_message"
]
assert len(agent_events) == 1
replayed = agent_events[0]
assert replayed["source"] == "chat_history"
assert replayed["expect_response"] is False
assert replayed["metadata"] == {"interactions": interactions}
def test_task_create_ignores_seed_interactions_without_a_seed_message(
test_db, user1_headers
):
"""`seed_interactions` has no row to attach to without
`seed_assistant_message` - documented as a no-op, not a 400, since a
client omitting the message by mistake shouldn't fail task creation."""
from xagent.web.models.chat_message import TaskChatMessage
resp = client.post(
"/api/chat/task/create",
json={
"title": "No seed message",
"seed_interactions": [{"type": "connect_apps", "apps": ["Gmail"]}],
},
headers=user1_headers,
)
assert resp.status_code == 200
task_id = resp.json()["task_id"]
db = next(get_db())
try:
assert db.query(TaskChatMessage).filter_by(task_id=task_id).count() == 0
finally:
db.close()
def test_task_create_rejects_more_than_five_seed_interactions(test_db, user1_headers):
resp = client.post(
"/api/chat/task/create",
json={
"title": "Too many interactions",
"seed_assistant_message": "Hi.",
"seed_interactions": [{"type": "connect_apps"}]
* (MAX_SEED_INTERACTIONS + 1),
},
headers=user1_headers,
)
assert resp.status_code == 422
def test_task_create_without_seed_message_creates_no_chat_messages(
test_db, user1_headers
):
"""Omitting `seed_assistant_message` (the existing behavior for every
other task-creation caller) must not start writing empty history rows."""
from xagent.web.models.chat_message import TaskChatMessage
resp = client.post(
"/api/chat/task/create",
json={"title": "No seed"},
headers=user1_headers,
)
assert resp.status_code == 200
task_id = resp.json()["task_id"]
db = next(get_db())
try:
assert db.query(TaskChatMessage).filter_by(task_id=task_id).count() == 0
finally:
db.close()
def test_task_create_rejects_overlong_seed_assistant_message(test_db, user1_headers):
"""`seed_assistant_message` is bounded (max_length=8000) since it is a
public request field, not just internal marketplace-authored content."""
resp = client.post(
"/api/chat/task/create",
json={"title": "Too long", "seed_assistant_message": "x" * 8001},
headers=user1_headers,
)
assert resp.status_code == 422
def test_task_create_warns_when_seed_assistant_message_normalizes_to_empty(
test_db, user1_headers, caplog
):
"""A non-empty `seed_assistant_message` that `persist_assistant_message_no_commit`
drops (normalizes to whitespace-only) must leave a log trail - otherwise a
'speak first' flow silently produces zero chat history with no way to
tell why."""
from xagent.web.models.chat_message import TaskChatMessage
with caplog.at_level(logging.WARNING):
resp = client.post(
"/api/chat/task/create",
json={"title": "Blank seed", "seed_assistant_message": " "},
headers=user1_headers,
)
assert resp.status_code == 200
task_id = resp.json()["task_id"]
db = next(get_db())
try:
assert db.query(TaskChatMessage).filter_by(task_id=task_id).count() == 0
finally:
db.close()
assert any(
"normalized to" in record.message and str(task_id) in record.message
for record in caplog.records
)
def test_task_create_warns_for_a_plain_empty_seed_assistant_message_too(
test_db, user1_headers, caplog
):
"""A truthy check (`if request.seed_assistant_message:`) would drop a
literal "" with zero log output - only the whitespace-only case above
would reach the warning. Checking `is not None` instead covers both,
since both are the same "seeder passed a value that normalizes to
nothing" situation worth a log trail."""
from xagent.web.models.chat_message import TaskChatMessage
with caplog.at_level(logging.WARNING):
resp = client.post(
"/api/chat/task/create",
json={"title": "Empty seed", "seed_assistant_message": ""},
headers=user1_headers,
)
assert resp.status_code == 200
task_id = resp.json()["task_id"]
db = next(get_db())
try:
assert db.query(TaskChatMessage).filter_by(task_id=task_id).count() == 0
finally:
db.close()
assert any(
"normalized to" in record.message and str(task_id) in record.message
for record in caplog.records
)