Skip to content

JiuwenSwarm is an intelligent AI Agent built on openJiuwen. It extends the powerful capabilities of large language models directly to your fingertips through various communication apps you use daily.

Python
27.3 KB
Raw Blame
# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.

from __future__ import annotations

import json
import time
from pathlib import Path
from types import SimpleNamespace

import pytest

from jiuwenswarm.perf.accumulator import RequestMeta, RequestSummaryAccumulator
from jiuwenswarm.perf.collector import PerfCollector
from jiuwenswarm.perf.config import init_perf_summary_config
from jiuwenswarm.perf.events import LlmPerfEvent, TaskPerfEvent, ToolPerfEvent
from jiuwenswarm.perf.extract import tool_status_from_result
from jiuwenswarm.perf.stats import ms_to_s, percentile_s
from jiuwenswarm.perf.writer import append_request_summary, request_summaries_file


def test_perf_usage_snapshot_recovers_tokens_when_stream_usage_is_missing(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    from jiuwenswarm.perf import interface_hooks

    accumulator = SimpleNamespace(
        input_tokens=42_462,
        output_tokens=355,
        cache_read_tokens=1_024,
    )
    collector = SimpleNamespace(get_accumulator=lambda request_id: accumulator)
    monkeypatch.setattr(interface_hooks, "get_perf_collector", lambda: collector)

    snapshot = interface_hooks.snapshot_perf_summary_usage("req-interrupted")
    stream_usage = {
        "input_tokens": 0,
        "output_tokens": 0,
        "total_tokens": 0,
        "cache_tokens": 0,
    }

    recovered = interface_hooks.merge_perf_summary_usage_fallback(
        stream_usage,
        snapshot,
    )

    assert recovered is True
    assert stream_usage == {
        "input_tokens": 42_462,
        "output_tokens": 355,
        "total_tokens": 42_817,
        "cache_tokens": 1_024,
    }


def test_perf_usage_fallback_does_not_duplicate_complete_stream_usage() -> None:
    from jiuwenswarm.perf.interface_hooks import merge_perf_summary_usage_fallback

    stream_usage = {
        "input_tokens": 1_000,
        "output_tokens": 100,
        "total_tokens": 1_100,
        "cache_tokens": 200,
    }

    recovered = merge_perf_summary_usage_fallback(
        stream_usage,
        {
            "input_tokens": 1_000,
            "output_tokens": 100,
            "total_tokens": 1_100,
            "cache_tokens": 200,
        },
    )

    assert recovered is False
    assert stream_usage["total_tokens"] == 1_100


def test_external_token_usage_hook_routes_sdk_snapshot_to_collector(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    from jiuwenswarm.perf import interface_hooks

    calls: list[tuple[tuple, dict]] = []
    collector = SimpleNamespace(
        record_external_token_usage=lambda *args, **kwargs: calls.append((args, kwargs))
    )
    monkeypatch.setattr(interface_hooks, "get_perf_collector", lambda: collector)

    interface_hooks.record_deepresearch_sdk_token_usage(
        "request-1",
        "conversation-1",
        {"input_tokens": 500, "output_tokens": 80, "total_tokens": 580},
    )

    assert calls == [
        (
            ("request-1",),
            {
                "source": "deepresearch_sdk",
                "usage_id": "conversation-1",
                "input_tokens": 500,
                "output_tokens": 80,
                "total_tokens": 580,
            },
        )
    ]


def test_request_summary_rail_imports_required_symbols() -> None:
    """Regression: ensure request_summary_rail imports all runtime dependencies."""
    import ast

    src = Path(__file__).resolve().parents[3] / "jiuwenswarm" / "perf" / "request_summary_rail.py"
    tree = ast.parse(src.read_text(encoding="utf-8"))
    imported: set[str] = set()
    for node in ast.walk(tree):
        if isinstance(node, ast.ImportFrom) and node.module and node.module.startswith("jiuwenswarm.perf"):
            for alias in node.names:
                imported.add(alias.name)
    for required in ("get_perf_collector", "get_perf_summary_config"):
        assert required in imported, f"missing import: {required}"


def test_tool_status_uses_success_and_status_fields() -> None:
    assert tool_status_from_result({"success": True, "result": "done"}) == "ok"
    assert tool_status_from_result({"success": False, "error": "spawn failed"}) == "error"
    assert tool_status_from_result({"status": "ok", "note": "no error occurred"}) == "ok"
    assert tool_status_from_result({"message": "Successfully updated 2 task(s)"}) == "ok"
    assert tool_status_from_result("Successfully created 9 task(s)") == "ok"
    # Regression: Chinese skip text must stay valid UTF-8 success marker.
    assert tool_status_from_result("跳过大纲确认") == "ok"
    assert tool_status_from_result(
        "shell operation execution error, reason: execution timeout after 180 seconds"
    ) == "error"
    assert tool_status_from_result("Traceback (most recent call last):\nValueError") == "error"


def test_percentile_s_basic() -> None:
    assert percentile_s([10000, 20000, 30000, 40000, 100000], 0.90) == 100.0
    assert percentile_s([5000], 0.99) == 5.0
    assert ms_to_s(1500) == 1.5


def test_bottleneck_top_n_zero_disables_tracking(monkeypatch: pytest.MonkeyPatch) -> None:
    monkeypatch.setattr(
        "jiuwenswarm.common.config.get_config",
        lambda: {"perf": {"summary": {"bottleneck_top_n": 0}}},
    )
    from jiuwenswarm.perf.config import load_perf_summary_config

    cfg = load_perf_summary_config()
    assert cfg.bottleneck_top_n == 0


def test_accumulator_finalize_schema() -> None:
    acc = RequestSummaryAccumulator(
        meta=RequestMeta(
            session_id="sess-1",
            request_id="req-1",
            channel_id="web",
            mode="plan",
            trace_id=None,
            started_at=1000.0,
        ),
        _bottleneck_top_n=3,
    )
    acc.record_llm(
        LlmPerfEvent(
            llm_call_id="llm-1",
            duration_ms=1000.0,
            model="deepseek-chat",
            iteration=1,
            input_tokens=100,
            output_tokens=50,
            status="ok",
            agent_id="main_agent",
            task_id="todo:1",
        )
    )
    acc.record_tool(
        ToolPerfEvent(
            tool_call_id="tool-1",
            name="WebSearch",
            duration_ms=500.0,
            status="ok",
            agent_id="main_agent",
            task_id="todo:1",
            iteration=1,
        )
    )
    summary = acc.finalize(status="ok", ended_at=1002.5)

    assert summary["schema_version"] == 1
    assert summary["meta"]["request_id"] == "req-1"
    assert summary["summary"]["total_s"] == 2.5
    assert summary["summary"]["stats"]["llm"]["count"] == 1
    assert summary["summary"]["stats"]["llm"]["p90_duration_s"] == 1.0
    assert summary["summary"]["stats"]["tool"]["max_s"] == 0.5
    assert summary["summary"]["stats"]["tool"]["list"] == [{"name": "WebSearch", "count": 1}]
    assert "subagent" not in summary["summary"]["stats"]
    assert "by_agent" not in summary["summary"]["stats"]
    assert summary["summary"]["first_answer_latency_s"] == 0.0
    assert "llm_call_id" not in summary["bottleneck"]["llm"][0]
    assert summary["bottleneck"]["tool"][0]["name"] == "WebSearch"
    assert "errors" not in summary


def test_accumulator_adds_external_token_usage_once_without_fake_llm_call() -> None:
    acc = RequestSummaryAccumulator(
        meta=RequestMeta(
            session_id="sess-1",
            request_id="req-1",
            channel_id="web",
            mode="plan",
            trace_id=None,
            started_at=1000.0,
        )
    )
    acc.record_llm(
        LlmPerfEvent(
            llm_call_id="llm-1",
            duration_ms=1000.0,
            model="deepseek-chat",
            iteration=1,
            input_tokens=100,
            output_tokens=50,
            status="ok",
        )
    )

    assert acc.record_external_token_usage(
        source="deepresearch_sdk",
        usage_id="conversation-1",
        input_tokens=500,
        output_tokens=80,
        total_tokens=580,
    ) is True
    assert acc.record_external_token_usage(
        source="deepresearch_sdk",
        usage_id="conversation-1",
        input_tokens=500,
        output_tokens=80,
        total_tokens=580,
    ) is False

    summary = acc.finalize(status="ok", ended_at=1002.0)
    assert summary["summary"]["tokens"] == {
        "input": 600,
        "output": 130,
        "total": 730,
        "cache_read": 0,
        "reasoning": 0,
    }
    assert summary["summary"]["stats"]["llm"]["count"] == 1


def test_accumulator_sums_reasoning_tokens_into_summary_and_bottleneck() -> None:
    acc = RequestSummaryAccumulator(
        meta=RequestMeta(
            session_id="sess-1",
            request_id="req-1",
            channel_id="web",
            mode="plan",
            trace_id=None,
            started_at=1000.0,
        )
    )
    acc.record_llm(
        LlmPerfEvent(
            llm_call_id="llm-1",
            duration_ms=1000.0,
            model="glm-5.2",
            iteration=1,
            input_tokens=100,
            output_tokens=80,
            status="ok",
            reasoning_tokens=55,
        )
    )
    acc.record_llm(
        LlmPerfEvent(
            llm_call_id="llm-2",
            duration_ms=500.0,
            model="glm-5.2",
            iteration=2,
            input_tokens=120,
            output_tokens=40,
            status="ok",
            reasoning_tokens=12,
        )
    )
    acc.cache_read_tokens = 64

    summary = acc.finalize(status="ok", ended_at=1002.0)
    assert summary["summary"]["tokens"] == {
        "input": 220,
        "output": 120,
        "total": 340,
        "cache_read": 64,
        "reasoning": 67,
    }
    assert summary["bottleneck"]["llm"][0]["reasoning_tokens"] == 55


def test_extract_usage_tokens_reads_reasoning_from_usage_metadata() -> None:
    from jiuwenswarm.perf.extract import extract_usage_tokens

    direct = extract_usage_tokens(
        {
            "usage_metadata": {
                "input_tokens": 10,
                "output_tokens": 20,
                "cache_read_tokens": 4,
                "reasoning_tokens": 7,
            }
        }
    )
    nested = extract_usage_tokens(
        SimpleNamespace(
            usage_metadata=SimpleNamespace(
                input_tokens=1,
                output_tokens=2,
                cache_read_input_tokens=0,
                cache_read_tokens=0,
                completion_tokens_details=SimpleNamespace(reasoning_tokens=9),
                reasoning_tokens=0,
            )
        )
    )

    assert direct == (10, 20, 4, 7)
    assert nested == (1, 2, 0, 9)
    acc = RequestSummaryAccumulator(
        meta=RequestMeta(
            session_id="sess-1",
            request_id="req-1",
            channel_id="web",
            mode="plan",
            trace_id=None,
            started_at=1000.0,
        ),
        _include_by_agent=True,
    )
    acc.record_llm(
        LlmPerfEvent(
            llm_call_id="llm-1",
            duration_ms=1000.0,
            model="deepseek-chat",
            iteration=1,
            input_tokens=100,
            output_tokens=50,
            status="ok",
            agent_id="main_agent",
            task_id="todo:1",
        )
    )
    summary = acc.finalize(status="ok", ended_at=1001.0)
    assert summary["summary"]["stats"]["by_agent"]["main_agent"]["llm"]["count"] == 1


def test_accumulator_omits_errors_when_disabled() -> None:
    acc = RequestSummaryAccumulator(
        meta=RequestMeta(
            session_id="sess-1",
            request_id="req-1",
            channel_id="web",
            mode="plan",
            trace_id=None,
            started_at=1000.0,
        ),
        _include_errors=False,
    )
    acc.record_tool(
        ToolPerfEvent(
            tool_call_id="call-err",
            name="bash",
            duration_ms=100.0,
            status="error",
            error_message="command failed",
        )
    )

    summary = acc.finalize(status="ok", ended_at=1001.0)

    assert "errors" not in summary
    assert summary["summary"]["stats"]["tool"]["fail_count"] == 1


def test_accumulator_merges_subagent_into_total_stats() -> None:
    acc = RequestSummaryAccumulator(
        meta=RequestMeta(
            session_id="sess-1",
            request_id="req-1",
            channel_id="web",
            mode="plan",
            trace_id=None,
            started_at=1000.0,
        ),
        _include_errors=True,
    )
    iteration = 3
    acc.record_tool(
        ToolPerfEvent(
            tool_call_id="call-a",
            name="web_search",
            duration_ms=100.0,
            status="ok",
            iteration=iteration,
        )
    )
    acc.record_tool(
        ToolPerfEvent(
            tool_call_id="call-b",
            name="bash",
            duration_ms=200.0,
            status="error",
            iteration=iteration,
            error_message="command failed",
            agent_id="subagent_abc",
        )
    )
    acc.record_llm(
        LlmPerfEvent(
            llm_call_id="llm-err",
            duration_ms=50.0,
            model="glm",
            iteration=2,
            input_tokens=1,
            output_tokens=0,
            status="error",
            error_message="rate limited",
            agent_id="subagent_abc",
        )
    )

    summary = acc.finalize(status="ok", ended_at=1002.0)
    tool_stats = summary["summary"]["stats"]["tool"]
    llm_stats = summary["summary"]["stats"]["llm"]

    assert "subagent" not in summary["summary"]["stats"]
    assert tool_stats["count"] == 2
    assert tool_stats["round_count"] == 1
    assert tool_stats["list"] == [{"name": "bash", "count": 1}, {"name": "web_search", "count": 1}]
    assert llm_stats["count"] == 1
    assert len(summary["errors"]) == 2
    assert all(err["status"] == "error" for err in summary["errors"])
    assert "call_id" not in summary["errors"][1]
    assert summary["errors"][0]["duration_s"] == 0.2


def test_parallel_tool_timing_dict() -> None:
    from jiuwenswarm.perf.context import pop_tool_start, set_tool_start

    set_tool_start("call-1", "tool_a", 10.0)
    set_tool_start("call-2", "tool_b", 20.0)
    first = pop_tool_start("call-1")
    second = pop_tool_start("call-2")
    assert first == ("tool_a", 10.0)
    assert second == ("tool_b", 20.0)


def test_parallel_tool_timing_no_false_anon_match() -> None:
    from jiuwenswarm.perf.context import pop_tool_start, set_tool_start

    set_tool_start("", "bash", 10.0)
    set_tool_start("", "bash", 20.0)
    assert pop_tool_start("", "bash") is None

    set_tool_start("call-1", "tool_a", 10.0)
    set_tool_start("call-2", "tool_b", 20.0)
    assert pop_tool_start("", "tool_a") is None


def test_request_summary_rail_supports_record_only() -> None:
    """DeepAdapter rail wiring is deferred; package API must support record_only."""
    from jiuwenswarm.perf.request_summary_rail import RequestSummaryRail

    rail = RequestSummaryRail(record_only=True)
    assert rail._record_only is True


def test_extract_react_iteration_from_inputs() -> None:
    from types import SimpleNamespace

    from jiuwenswarm.perf.context import increment_react_iteration, reset_react_iteration
    from jiuwenswarm.perf.extract import extract_react_iteration

    reset_react_iteration()
    increment_react_iteration()
    increment_react_iteration()
    assert extract_react_iteration(SimpleNamespace(inputs=None)) == 2

    reset_react_iteration()
    ctx = SimpleNamespace(inputs=SimpleNamespace(iteration=3))
    assert extract_react_iteration(ctx) == 3
    assert extract_react_iteration(SimpleNamespace(inputs={"step": 5})) == 5


def test_extract_agent_id_prefers_subagent_and_card() -> None:
    from types import SimpleNamespace

    from jiuwenswarm.perf.extract import extract_agent_id

    card = SimpleNamespace(id="spawn_researcher", name="spawn_researcher")
    deep = SimpleNamespace(card=card)
    inner = SimpleNamespace(id="262923614bdb45709ece791ffb3d3409", card=None)

    assert extract_agent_id(inner, deep_agent=deep) == "spawn_researcher"
    assert extract_agent_id(inner, deep_agent=None) == ""


def test_extract_agent_id_prefers_deep_agent_over_contextvar(monkeypatch: pytest.MonkeyPatch) -> None:
    from types import SimpleNamespace

    from jiuwenswarm.perf.extract import extract_agent_id

    monkeypatch.setattr(
        "jiuwenswarm.perf.extract.resolve_subagent_id",
        lambda: "general-purpose",
    )
    parent = SimpleNamespace(card=SimpleNamespace(id="jiuwenswarm", name="jiuwenswarm"))
    assert extract_agent_id(None, deep_agent=parent) == "jiuwenswarm"


def test_get_request_context_returns_none_without_binding() -> None:
    from jiuwenswarm.perf.context import clear_request_context, get_request_context

    clear_request_context()
    assert get_request_context() is None


def test_accumulator_record_task_with_attributed_stats() -> None:
    acc = RequestSummaryAccumulator(
        meta=RequestMeta(
            session_id="sess-1",
            request_id="req-1",
            channel_id="web",
            mode="plan",
            trace_id=None,
            started_at=1000.0,
        ),
    )
    task_id = "todo:abc"
    acc.record_llm(
        LlmPerfEvent(
            llm_call_id="llm-1",
            duration_ms=100.0,
            model="glm",
            iteration=1,
            input_tokens=10,
            output_tokens=5,
            status="ok",
            task_id=task_id,
        )
    )
    acc.record_tool(
        ToolPerfEvent(
            tool_call_id="call-1",
            name="web_search",
            duration_ms=50.0,
            status="ok",
            task_id=task_id,
        )
    )
    acc.record_task(
        TaskPerfEvent(
            task_id=task_id,
            task_content="Stage 1",
            source="todo",
            started_at=1000.0,
            ended_at=1001.0,
            duration_ms=1000.0,
            status="succeeded",
        )
    )

    summary = acc.finalize(status="ok", ended_at=1002.0)
    assert summary["summary"]["stats"]["task"]["count"] == 1
    assert summary["summary"]["stats"]["unattributed_s"] == 0.0
    assert summary["tasks"][0]["stats"]["llm"]["count"] == 1
    assert summary["tasks"][0]["duration_s"] == 1.0


def test_collector_restores_accumulator_on_write_failure(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    init_perf_summary_config()
    collector = PerfCollector()
    collector.begin_request(
        session_id="sess-z",
        request_id="req-z",
        channel_id="web",
        mode="agent.plan",
        started_at=1000.0,
    )

    write_attempts = {"count": 0}

    def _append_once_fail(*_args, **_kwargs) -> None:
        write_attempts["count"] += 1
        if write_attempts["count"] == 1:
            raise OSError("disk full")

    monkeypatch.setattr("jiuwenswarm.perf.collector.append_request_summary", _append_once_fail)
    monkeypatch.setattr("jiuwenswarm.perf.guard.logger.warning", lambda *_a, **_k: None)
    collector.finalize_request("req-z", status="ok", ended_at=1001.0)

    restored = collector.get_accumulator("req-z")
    assert restored is not None
    assert restored.flushed is False

    collector.finalize_request("req-z", status="ok", ended_at=1001.0)
    assert write_attempts["count"] == 2
    assert collector.get_accumulator("req-z") is None


def test_collector_does_not_prune_active_long_running_request() -> None:
    init_perf_summary_config()
    collector = PerfCollector()
    stale_started_at = time.time() - PerfCollector._STALE_ORPHAN_AGE_S - 60.0

    collector.begin_request(
        session_id="sess-long",
        request_id="req-long",
        channel_id="web",
        mode="agent.plan",
        started_at=stale_started_at,
    )
    collector.record_llm(
        "req-long",
        LlmPerfEvent(
            llm_call_id="llm-long",
            duration_ms=100.0,
            model="gpt-4",
            iteration=1,
            input_tokens=1,
            output_tokens=1,
            status="ok",
        ),
    )

    collector.begin_request(
        session_id="sess-other",
        request_id="req-other",
        channel_id="web",
        mode="agent.plan",
    )

    assert collector.get_accumulator("req-long") is not None
    assert "req-long" in collector._active_request_ids

    summary = collector.get_accumulator("req-long").finalize(status="ok")
    assert summary["summary"]["stats"]["llm"]["count"] == 1


def test_collector_prunes_inactive_orphan_accumulator(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    init_perf_summary_config()
    collector = PerfCollector()
    stale_started_at = time.time() - PerfCollector._STALE_ORPHAN_AGE_S - 60.0
    monkeypatch.setattr("jiuwenswarm.perf.collector.logger.warning", lambda *_a, **_k: None)

    collector.begin_request(
        session_id="sess-orphan",
        request_id="req-orphan",
        channel_id="web",
        mode="agent.plan",
        started_at=stale_started_at,
    )
    collector._active_request_ids.discard("req-orphan")

    collector.begin_request(
        session_id="sess-trigger",
        request_id="req-trigger",
        channel_id="web",
        mode="agent.plan",
    )

    assert collector.get_accumulator("req-orphan") is None
    assert collector.get_accumulator("req-trigger") is not None


def test_collector_finalize_writes_jsonl(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
    init_perf_summary_config()
    monkeypatch.setattr(
        "jiuwenswarm.perf.writer.get_agent_sessions_dir",
        lambda: tmp_path,
    )

    collector = PerfCollector()
    collector.begin_request(
        session_id="sess-x",
        request_id="req-x",
        channel_id="web",
        mode="agent.plan",
        started_at=1000.0,
    )
    collector.record_llm(
        "req-x",
        LlmPerfEvent(
            llm_call_id="llm-x",
            duration_ms=800.0,
            model="gpt-4",
            iteration=1,
            input_tokens=10,
            output_tokens=5,
            status="ok",
        ),
    )
    collector.finalize_request("req-x", status="ok", ended_at=1001.0)
    from jiuwenswarm.perf.writer import flush_request_summary_writer

    flush_request_summary_writer()

    out_path = request_summaries_file("sess-x", str(tmp_path))
    assert out_path.exists()
    payload = json.loads(out_path.read_text(encoding="utf-8").strip())
    assert payload["schema_version"] == 1
    assert payload["summary"]["stats"]["llm"]["total_s"] == 0.8


def test_collector_finalize_writes_tenant_jsonl(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
    init_perf_summary_config()
    monkeypatch.setattr(
        "jiuwenswarm.perf.writer.get_agent_sessions_dir",
        lambda: tmp_path,
    )

    collector = PerfCollector()
    collector.begin_request(
        session_id="sess-office",
        request_id="req-office",
        channel_id="officeclaw",
        mode="agent.plan",
        started_at=1000.0,
        service_id="default",
        agent_id="office",
    )
    collector.finalize_request("req-office", status="ok", ended_at=1001.0)
    from jiuwenswarm.perf.writer import flush_request_summary_writer

    flush_request_summary_writer()

    out_path = tmp_path / "sess-office" / "request_summaries.jsonl"
    assert out_path.exists()
    payload = json.loads(out_path.read_text(encoding="utf-8").strip())
    assert payload["meta"]["request_id"] == "req-office"


def test_append_request_summary_sync_fallback(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
    monkeypatch.setattr(
        "jiuwenswarm.perf.writer.get_agent_sessions_dir",
        lambda: tmp_path,
    )
    append_request_summary("sess-y", {"schema_version": 5, "meta": {"request_id": "req-y"}})
    from jiuwenswarm.perf.writer import flush_request_summary_writer

    flush_request_summary_writer()
    out_path = request_summaries_file("sess-y", str(tmp_path))
    assert "req-y" in out_path.read_text(encoding="utf-8")


def test_set_perf_summary_context_works_without_rail() -> None:
    """Rail build failure must not skip begin_request / ContextVar bind."""
    from jiuwenswarm.perf.collector import get_perf_collector
    from jiuwenswarm.perf.context import clear_request_context, get_request_context
    from jiuwenswarm.perf.interface_hooks import (
        clear_perf_summary_context,
        finalize_perf_summary_request,
        set_perf_summary_context,
    )

    clear_request_context()
    set_perf_summary_context(
        None,
        channel_id="web",
        session_id="sess-rail-none",
        request_id="req-rail-none",
        mode="agent",
    )
    assert get_request_context() is not None
    assert get_perf_collector().get_accumulator("req-rail-none") is not None
    finalize_perf_summary_request("req-rail-none", status="ok")
    clear_perf_summary_context()
    assert get_request_context() is None


def test_maybe_mark_first_byte_and_first_answer() -> None:
    from jiuwenswarm.perf.collector import get_perf_collector
    from jiuwenswarm.perf.context import clear_request_context, set_request_context
    from jiuwenswarm.perf.interface_hooks import maybe_mark_answer_first_byte

    clear_request_context()
    set_request_context(
        session_id="sess-fb",
        request_id="req-fb",
        channel_id="web",
        mode="agent",
    )
    acc = get_perf_collector().get_accumulator("req-fb")
    assert acc is not None

    maybe_mark_answer_first_byte({"event_type": "chat.tool_call", "tool_call": {}})
    assert acc.first_byte_latency_ms is not None
    assert acc.first_answer_latency_ms is None

    maybe_mark_answer_first_byte({"event_type": "chat.delta", "content": "hi"})
    assert acc.first_answer_latency_ms is not None
    clear_request_context()


def test_load_perf_summary_config_defaults_enabled(monkeypatch: pytest.MonkeyPatch) -> None:
    monkeypatch.delenv("PERF_SUMMARY_ENABLED", raising=False)
    monkeypatch.setattr("jiuwenswarm.common.config.get_config", lambda: {})
    from jiuwenswarm.perf import config as perf_config

    perf_config._CONFIG = None
    cfg = perf_config.load_perf_summary_config()
    assert cfg.enabled is True


def test_request_context_survives_without_contextvar() -> None:
    """Interaction-round Tasks do not inherit stream-handler ContextVar."""
    from contextvars import Context

    from jiuwenswarm.perf.context import (
        clear_request_context,
        get_request_context,
        normalize_session_key,
        set_request_context,
    )
    from jiuwenswarm.perf.request_summary_rail import RequestSummaryRail

    clear_request_context()
    set_request_context(
        session_id="web_parent",
        request_id="req-cross-task",
        channel_id="web",
        mode="agent",
    )
    rail = RequestSummaryRail(record_only=True)
    rail.bind_request_context(get_request_context())

    class _Session:
        def get_session_id(self) -> str:
            return "web_parent_sub_explore_abcd"

    class _Cb:
        session = _Session()

    def _via_rail_bind() -> str | None:
        # Empty Context: no task-local ContextVar.
        assert get_request_context() is None
        ctx = rail._active_request_context(_Cb())
        assert ctx is not None
        return str(ctx["request_id"])

    def _via_session_registry() -> str | None:
        assert get_request_context() is None
        unbound = RequestSummaryRail(record_only=True)
        ctx = unbound._active_request_context(_Cb())
        assert ctx is not None
        assert normalize_session_key("web_parent_sub_explore_abcd") == "web_parent"
        return str(ctx["request_id"])

    assert Context().run(_via_rail_bind) == "req-cross-task"
    assert Context().run(_via_session_registry) == "req-cross-task"
    clear_request_context(session_id="web_parent", request_id="req-cross-task")
    rail.clear_bound_request_context()
    assert get_request_context(session_id="web_parent") is None