Skip to content

Enterprise agent platform for building, deploying, and operating AI teammates.

15.5 KB
Raw Blame
from unittest.mock import AsyncMock, patch

import pytest
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

from xagent.core.agent.trace import (
    ACTION_END_TOOL,
    ACTION_START_TOOL,
    TraceAction,
    TraceCategory,
    TraceEvent,
    TraceEventType,
    TraceScope,
)
from xagent.web.channels.telegram import handler as telegram_handler
from xagent.web.channels.telegram.bot import TelegramBotInstance
from xagent.web.channels.telegram.handler import TelegramTraceHandler
from xagent.web.channels.telegram.utils import (
    TelegramFileRef,
    TelegramImageRef,
    markdown_to_tg_html,
    persist_telegram_assistant_turn,
    restore_telegram_task_context,
    strip_telegram_file_refs,
    strip_telegram_image_refs,
)
from xagent.web.models.database import Base
from xagent.web.models.task import Task, TaskStatus
from xagent.web.models.user import User
from xagent.web.services.chat_history_service import (
    TranscriptWindow,
    load_task_transcript,
)


def test_strip_telegram_image_refs_extracts_file_refs() -> None:
    text = (
        "Here is the result:\n\n![generated_image.jpg](file:abc-123)\nKeep this text."
    )

    cleaned, refs = strip_telegram_image_refs(text)

    assert cleaned == "Here is the result:\n\nKeep this text."
    assert [(ref.file_id, ref.alt_text) for ref in refs] == [
        ("abc-123", "generated_image.jpg")
    ]


def test_strip_telegram_image_refs_supports_file_urls_and_api_urls() -> None:
    cleaned, refs = strip_telegram_image_refs(
        "![a](file://abc%201) "
        "![b](/api/files/preview/def%202) "
        "![c](https://example.com/api/files/download/ghi%203?token=ignored)"
    )

    assert cleaned == ""
    assert [ref.file_id for ref in refs] == ["abc 1", "def 2", "ghi 3"]


def test_strip_telegram_file_refs_extracts_local_file_links() -> None:
    text = (
        "Generated files:\n"
        "- [report.csv](file://file-1)\n"
        "- [poster](https://example.com/poster.html)\n"
        "![preview](file://image-1)"
    )

    cleaned, refs = strip_telegram_file_refs(text)

    assert cleaned == (
        "Generated files:\n"
        "- [poster](https://example.com/poster.html)\n"
        "![preview](file://image-1)"
    )
    assert [(ref.file_id, ref.label) for ref in refs] == [("file-1", "report.csv")]


def test_strip_telegram_file_refs_supports_api_download_urls() -> None:
    cleaned, refs = strip_telegram_file_refs(
        "[a](/api/files/download/abc%201) "
        "[b](https://example.com/api/files/preview/def%202?token=ignored)"
    )

    assert cleaned == ""
    assert [ref.file_id for ref in refs] == ["abc 1", "def 2"]


def test_telegram_trace_handler_uses_plural_image_placeholder() -> None:
    handler = TelegramTraceHandler(
        task_id=421,
        bot=object(),
        chat_id=123,
        message_id=456,  # type: ignore[arg-type]
    )

    assert handler._image_placeholder_text(1) == "Image generated."
    assert handler._image_placeholder_text(2) == "Images generated."


@pytest.mark.asyncio
async def test_send_output_files_uploads_documents(tmp_path) -> None:
    output_path = tmp_path / "report.csv"
    output_path.write_text("a,b\n1,2\n")

    class FakeRecord:
        file_id = "file-1"
        storage_path = str(output_path)
        filename = "report.csv"

    class FakeReply:
        def __init__(self) -> None:
            self.documents = []

        async def answer_document(self, document, caption=None):
            self.documents.append((document, caption))

    bot = object.__new__(TelegramBotInstance)
    reply = FakeReply()

    with patch(
        "xagent.web.channels.telegram.bot.load_channel_output_files",
        new=AsyncMock(return_value=(FakeRecord(),)),
    ) as load_files:
        failed_refs = await bot._send_output_files(
            file_refs=[TelegramFileRef(file_id="file-1", label="report.csv")],
            user_id=7,
            task_id=423,
            reply_to=reply,  # type: ignore[arg-type]
            is_cancelled=lambda: False,
        )

    assert failed_refs == []
    load_files.assert_awaited_once_with(
        file_ids=["file-1"],
        user_id=7,
        task_id=423,
    )
    assert len(reply.documents) == 1
    assert reply.documents[0][1] == "report.csv"


def test_extract_telegram_output_refs_uses_final_answer_links_only() -> None:
    bot = object.__new__(TelegramBotInstance)

    assert bot._extract_telegram_output_refs(None) == ("", [], [])
    assert bot._extract_telegram_output_refs("") == ("", [], [])

    cleaned, image_refs, file_refs = bot._extract_telegram_output_refs(
        "Final files:\n"
        "- [report.csv](file:file-1)\n"
        "- [draft.csv](https://example.com/draft.csv)\n"
        "![plot.png](file:image-1)"
    )

    assert cleaned == "Final files:\n- [draft.csv](https://example.com/draft.csv)"
    assert [(ref.file_id, ref.alt_text) for ref in image_refs] == [
        ("image-1", "plot.png")
    ]
    assert [(ref.file_id, ref.label) for ref in file_refs] == [("file-1", "report.csv")]


def test_dedupe_telegram_output_refs_prefers_images_over_documents() -> None:
    bot = object.__new__(TelegramBotInstance)

    image_refs, file_refs = bot._dedupe_telegram_output_refs(
        [
            TelegramImageRef(file_id="image-1", alt_text="inline image"),
            TelegramImageRef(file_id="image-1", alt_text="structured image"),
        ],
        [
            TelegramFileRef(file_id="image-1", label="plot.png"),
            TelegramFileRef(file_id="file-1", label="report.csv"),
            TelegramFileRef(file_id="file-1", label="report duplicate.csv"),
        ],
    )

    assert [(ref.file_id, ref.alt_text) for ref in image_refs] == [
        ("image-1", "inline image")
    ]
    assert [(ref.file_id, ref.label) for ref in file_refs] == [("file-1", "report.csv")]


@pytest.mark.asyncio
async def test_telegram_trace_handler_ignores_events_for_other_tasks() -> None:
    sent_texts: list[str] = []

    class CapturingTelegramTraceHandler(TelegramTraceHandler):
        async def _update_message(self, text: str, final: bool = False) -> None:
            sent_texts.append(text)

    handler = CapturingTelegramTraceHandler(
        task_id=421,
        bot=object(),
        chat_id=123,
        message_id=456,  # type: ignore[arg-type]
    )

    await handler.handle_event(
        TraceEvent(
            ACTION_START_TOOL,
            task_id="422",
            step_id="step-1",
            data={"tool_name": "browser_navigate"},
        )
    )

    assert sent_texts == []


@pytest.mark.asyncio
async def test_cancelled_telegram_trace_handler_never_resumes_updates() -> None:
    sent_texts: list[str] = []

    class CapturingTelegramTraceHandler(TelegramTraceHandler):
        async def _update_message(self, text: str, final: bool = False) -> None:
            sent_texts.append(text)

    handler = CapturingTelegramTraceHandler(
        task_id=421,
        bot=object(),
        chat_id=123,
        message_id=456,  # type: ignore[arg-type]
    )
    handler.cancel()

    await handler.handle_event(
        TraceEvent(
            ACTION_START_TOOL,
            task_id="421",
            step_id="step-1",
            data={"tool_name": "browser_navigate"},
        )
    )

    assert handler.cancelled is True
    assert sent_texts == []


def test_markdown_to_tg_html_renders_tables_as_wrapped_lists() -> None:
    html = markdown_to_tg_html(
        "| 特性 | 说明 |\n"
        "|---|---|\n"
        "| 统一可观测引擎 | 指标、日志、链路、宽事件统一在一个数据库中。 |\n"
        "| 对象存储优先 | 成本最高降低 50 倍。 |\n"
    )

    assert "<pre>" not in html
    assert (
        "• <b>统一可观测引擎</b>: 指标、日志、链路、宽事件统一在一个数据库中。" in html
    )
    assert "• <b>对象存储优先</b>: 成本最高降低 50 倍。" in html


def test_markdown_to_tg_html_renders_multi_column_tables_as_field_lists() -> None:
    html = markdown_to_tg_html(
        "| Tool | Status | Notes |\n"
        "|---|---|---|\n"
        "| web_search | done | Found product page |\n"
    )

    assert "<pre>" not in html
    assert "• <b>web_search</b>" in html
    assert "  Status: done" in html
    assert "  Notes: Found product page" in html


def test_markdown_to_tg_html_accepts_single_hyphen_table_delimiters() -> None:
    html = markdown_to_tg_html(
        "| Feature | Detail |\n| - | - |\n| Storage | Object storage first |\n"
    )

    assert "<pre>" not in html
    assert "• <b>Storage</b>: Object storage first" in html


@pytest.mark.parametrize(
    "event_watermark",
    [None, {"scope_id": "root", "event_id": "telegram-history", "sequence": 7}],
)
@pytest.mark.asyncio
async def test_restore_telegram_task_context_loads_transcript_and_recovery_state(
    monkeypatch: pytest.MonkeyPatch,
    event_watermark,
) -> None:
    from xagent.core.agent.context.execution import MODEL_CONTEXT_WATERMARK_METADATA_KEY
    from xagent.core.agent.service import AgentService
    from xagent.web.services import chat_history_service, task_execution_context_service

    db = object()
    transcript = [{"role": "user", "content": "Generate a Spirited Away image"}]
    recovery_state = {
        "messages": [{"role": "tool", "content": "image generated"}],
        "skill_context": {"style": "ghibli"},
    }

    class FakeAgentService:
        def __init__(self) -> None:
            self.execution_metadata = {}
            self._execution_adapter = None
            self.conversation_history = None
            self.execution_context_messages = None
            self.recovered_skill_context = None

        def set_conversation_history(
            self, messages, *, watermark=None, event_watermark=None
        ):
            AgentService.set_conversation_history(
                self, messages, watermark=watermark, event_watermark=event_watermark
            )
            self.conversation_history = messages

        def set_execution_context_messages(self, messages):
            self.execution_context_messages = messages

        def set_recovered_skill_context(self, context):
            self.recovered_skill_context = context

    async def fake_load_recovery_state(received_db, received_task_id: int):
        assert received_db is db
        assert received_task_id == 423
        return recovery_state

    monkeypatch.setattr(
        chat_history_service,
        "load_task_transcript_window",
        lambda received_db, received_task_id: TranscriptWindow(
            messages=transcript, watermark=None, event_watermark=event_watermark
        ),
    )
    monkeypatch.setattr(
        task_execution_context_service,
        "load_task_execution_recovery_state",
        fake_load_recovery_state,
    )

    agent_service = FakeAgentService()

    await restore_telegram_task_context(agent_service, db, 423)  # type: ignore[arg-type]

    assert (
        agent_service.execution_metadata.get(MODEL_CONTEXT_WATERMARK_METADATA_KEY)
        == event_watermark
    )
    assert agent_service.conversation_history == transcript
    assert agent_service.execution_context_messages == recovery_state["messages"]
    assert agent_service.recovered_skill_context == recovery_state["skill_context"]


def test_telegram_turn_without_provenance_fails_closed_on_transcript_load() -> None:
    engine = create_engine("sqlite:///:memory:")
    Base.metadata.create_all(bind=engine)
    db = sessionmaker(autocommit=False, autoflush=False, bind=engine)()
    try:
        user = User(username="telegram-history", password_hash="hash")
        db.add(user)
        db.flush()
        task = Task(
            user_id=int(user.id),
            title="Telegram history",
            description="Telegram history",
            status=TaskStatus.FAILED,
        )
        db.add(task)
        db.commit()

        raw_content = "Telegram provider token=secret"
        persist_telegram_assistant_turn(
            db=db,
            task_id=int(task.id),
            user_id=int(user.id),
            content=raw_content,
            interactions=[],
        )

        assert load_task_transcript(db, int(task.id)) == [
            {"role": "assistant", "content": "Task execution failed."}
        ]
    finally:
        db.close()


def test_persist_telegram_assistant_turn_stores_interactions_as_question(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    from xagent.web.services import chat_history_service

    persisted = []
    interactions = [{"type": "text_input", "label": "Destination"}]

    def fake_persist_assistant_message(**kwargs):
        persisted.append(kwargs)

    monkeypatch.setattr(
        chat_history_service,
        "persist_assistant_message",
        fake_persist_assistant_message,
    )

    persist_telegram_assistant_turn(
        db=object(),  # type: ignore[arg-type]
        task_id=423,
        user_id=7,
        content="",
        interactions=interactions,
        message_type="question",
    )

    assert persisted == [
        {
            "db": persisted[0]["db"],
            "task_id": 423,
            "user_id": 7,
            "content": "",
            "interactions": interactions,
            "message_type": "question",
        }
    ]


@pytest.mark.asyncio
async def test_telegram_trace_handler_throttles_tool_status_updates(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    sent_texts: list[str] = []

    class CapturingTelegramTraceHandler(TelegramTraceHandler):
        async def _update_message(self, text: str, final: bool = False) -> None:
            sent_texts.append(text)

    now = 10.0
    monkeypatch.setattr(telegram_handler.time, "monotonic", lambda: now)

    handler = CapturingTelegramTraceHandler(
        task_id=421,
        bot=object(),
        chat_id=123,
        message_id=456,  # type: ignore[arg-type]
    )

    await handler.handle_event(
        TraceEvent(
            ACTION_START_TOOL,
            task_id="421",
            step_id="step-1",
            data={"tool_name": "web_search"},
        )
    )
    await handler.handle_event(
        TraceEvent(
            ACTION_END_TOOL,
            task_id="421",
            step_id="step-1",
            data={"tool_name": "web_search"},
        )
    )

    assert len(sent_texts) == 1
    assert "I'm still working on this and making progress." in sent_texts[0]
    assert "I'm checking with web search" in sent_texts[0]


@pytest.mark.asyncio
async def test_telegram_trace_handler_updates_after_throttle_window(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    sent_texts: list[str] = []
    current_time = {"value": 10.0}

    class CapturingTelegramTraceHandler(TelegramTraceHandler):
        async def _update_message(self, text: str, final: bool = False) -> None:
            sent_texts.append(text)

    monkeypatch.setattr(
        telegram_handler.time, "monotonic", lambda: current_time["value"]
    )

    handler = CapturingTelegramTraceHandler(
        task_id=421,
        bot=object(),
        chat_id=123,
        message_id=456,  # type: ignore[arg-type]
    )

    await handler.handle_event(
        TraceEvent(
            ACTION_START_TOOL,
            task_id="421",
            step_id="step-1",
            data={"tool_name": "web_search"},
        )
    )
    current_time["value"] += handler.MIN_STATUS_UPDATE_INTERVAL_SECONDS + 0.1
    await handler.handle_event(
        TraceEvent(
            TraceEventType(TraceScope.ACTION, TraceAction.ERROR, TraceCategory.TOOL),
            task_id="421",
            step_id="step-1",
            data={"tool_name": "web_search"},
        )
    )

    assert len(sent_texts) == 2
    assert "web search didn't work" in sent_texts[1]
    assert "Started web search" in sent_texts[1]
    assert "web search did not work" in sent_texts[1]