Skip to content

~95% on SimpleQA (e.g. Qwen3.6-27B on a 3090). Supports all local and cloud LLMs (llama.cpp, Ollama, Google, ...). 10+ search engines - arXiv, PubMed, your private documents. Everything Local & Encrypted.

4.5 KB
Raw Blame
"""Gate output and linear work; measure the real raw-context construction."""

import pytest

from local_deep_research.chat.context import ChatContextManager


def history(count, kind, steps=False):
    messages, findings = [], []
    for number in range(count):
        prefix = f"Finding {number}: "
        if kind == "short":
            body = prefix + "Evidence. " * 8
            expected = body
        else:
            marker = (
                "[[7]](https://example.test/paper)"
                if kind == "citations"
                else ""
            )
            body = prefix + marker + "x" * 450 + "\n\n" + "Support. " * 60
            expected = prefix + "x" * 450 + "..."
        messages.extend(
            [
                dict(role="user", content=f"User [9] {number}"),
                dict(
                    role="assistant",
                    research_id=f"research-{number}",
                    content=body,
                ),
            ]
        )
        if steps:
            messages.append(
                dict(
                    message_type="step",
                    role="assistant",
                    research_id="progress",
                    content="Excluded progress",
                )
            )
        findings.append(expected)
    return messages, findings


@pytest.mark.parametrize("kind", ["short", "long", "citations"])
@pytest.mark.parametrize("steps", [False, True], ids=["turns", "with_steps"])
def test_history_growth_preserves_recent_findings_and_bounds_work(
    chat_workload, kind, steps
):
    for size in (
        chat_workload.settings["size"],
        chat_workload.settings["size"] * 2,
    ):
        messages, findings = history(size, kind, steps)
        expected = "\n\n---\n\n".join(findings[-5:])

        def prepare():
            manager = ChatContextManager("performance-session", messages)
            manager.MAX_FINDINGS_TO_INCLUDE = 5
            actual = manager._strip_citation_markers
            calls = []

            def counted(text):
                calls.append(len(text))
                return actual(text)

            manager._strip_citation_markers = counted
            return manager, calls

        def verify(state, output):
            manager, calls = state
            try:
                assert output == {
                    "session_id": "performance-session",
                    "original_query": "User [9] 0",
                    "accumulated_findings": expected,
                    "past_findings": expected,
                    "key_entities": [],
                    "topics": [],
                    "is_multi_turn": True,
                    "turn_count": size * 2,
                }
                # Allows future window-first processing while rejecting repeated
                # processing beyond one pass through qualifying messages.
                assert len(calls) <= size
                return dict(
                    history_findings=size,
                    retained_findings=min(5, size),
                    stripping_calls=len(calls),
                    stripped_input_chars=sum(calls),
                    output_chars=len(expected),
                )
            finally:
                del manager._strip_citation_markers

        chat_workload.measure(
            f"raw_{kind}_{'steps' if steps else 'turns'}",
            size,
            prepare,
            lambda state: state[0].build_research_context(),
            verify,
            units=size,
            unit="history_finding",
            parameters=dict(
                kind=kind,
                retained_findings=5,
                progress_steps=steps,
                instrumented_work_count=True,
                constructor_timed=False,
            ),
        )


@pytest.mark.parametrize("limit", [0, -1, 1, 5, 20])
def test_findings_window_boundaries_keep_existing_selection_semantics(limit):
    messages, expected = history(8, "long", steps=True)
    manager = ChatContextManager("boundaries", messages)
    manager.MAX_FINDINGS_TO_INCLUDE = limit
    assert manager._extract_findings_from_history() == "\n\n---\n\n".join(
        expected[-limit:]
    )


def test_changed_latest_response_is_observed_on_next_build():
    messages, _ = history(8, "short")
    manager = ChatContextManager("freshness", messages)
    first = manager.build_research_context()["past_findings"]
    manager.messages[-1]["content"] = "Updated latest finding"
    second = manager.build_research_context()["past_findings"]
    assert first != second and second.endswith("Updated latest finding")