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.

6.5 KB
Raw Blame
"""Stream failure diagnostics must preserve provider and cleanup contracts."""

import asyncio
from types import SimpleNamespace

from loguru import logger
import pytest

from local_deep_research.config.llm_config import ProcessingLLMWrapper


class UnrenderableProviderError(Exception):
    def __str__(self):
        raise AssertionError("Provider error text must not be rendered")


class ProbeStream:
    def __init__(self, *, error=None, after_chunk=False, close_error=False):
        self.error = error
        self.after_chunk = after_chunk
        self.close_error = close_error
        self.chunk = object()
        self.yielded = False
        self.closed = 0

    def __iter__(self):
        return self

    def __next__(self):
        if not self.yielded and (self.error is None or self.after_chunk):
            self.yielded = True
            return self.chunk
        if self.error is not None:
            raise self.error
        raise StopIteration

    def __aiter__(self):
        return self

    async def __anext__(self):
        try:
            return next(self)
        except StopIteration:
            raise StopAsyncIteration from None

    def close(self):
        self.closed += 1
        if self.close_error:
            raise RuntimeError("cleanup detail sentinel")

    async def aclose(self):
        self.close()


@pytest.fixture
def stream_events(loguru_caplog_full):
    events = []
    sink = logger.add(
        events.append,
        level="DEBUG",
        format="{message}\n{exception}",
        filter=lambda record: (
            record["name"] == "local_deep_research.config.llm_config"
        ),
    )
    try:
        yield events
    finally:
        logger.remove(sink)


def make_wrapper(probe, *, construction_error=None):
    calls = []

    def start(*args, **kwargs):
        calls.append((args, kwargs))
        if construction_error is not None:
            raise construction_error
        return probe

    return ProcessingLLMWrapper(
        SimpleNamespace(stream=start, astream=start)
    ), calls


async def consume(wrapper, mode, chunks, config):
    if mode == "sync":
        for chunk in wrapper.stream("prompt", config=config):
            chunks.append(chunk)
    else:
        async for chunk in wrapper.astream("prompt", config=config):
            chunks.append(chunk)


@pytest.mark.asyncio
@pytest.mark.parametrize("mode", ["sync", "async"])
@pytest.mark.parametrize(
    "phase", ["construction", "before_chunk", "after_chunk"]
)
@pytest.mark.parametrize("diagnose", ["0", "1"])
async def test_failure_logs_type_and_preserves_original_error(
    mode, phase, diagnose, monkeypatch, stream_events
):
    monkeypatch.setenv("LDR_APP_DEBUG", diagnose)
    monkeypatch.setenv("LDR_LOGURU_DIAGNOSE", diagnose)
    error = UnrenderableProviderError("provider detail sentinel")
    error.response = SimpleNamespace(status_code=429)
    error.add_note("provider note sentinel")
    error.__cause__ = RuntimeError("provider cause sentinel")
    probe = ProbeStream(error=error, after_chunk=phase == "after_chunk")
    wrapper, calls = make_wrapper(
        probe, construction_error=error if phase == "construction" else None
    )
    chunks = []
    config = {"tags": ["caller-tag"]}

    with pytest.raises(UnrenderableProviderError) as caught:
        await consume(wrapper, mode, chunks, config)

    assert caught.value is error
    assert caught.value.response.status_code == 429
    assert chunks == ([probe.chunk] if phase == "after_chunk" else [])
    assert probe.closed == (0 if phase == "construction" else 1)
    assert calls == [(("prompt",), {"config": config})]
    assert calls[0][1]["config"] is config
    assert len(stream_events) == 1
    record = stream_events[0].record
    assert record["level"].name == "ERROR"
    assert record["function"] == ("stream" if mode == "sync" else "astream")
    assert "LLM Request - Failed with error" in record["message"]
    assert "UnrenderableProviderError" in record["message"]
    assert "sentinel" not in str(stream_events[0])
    assert record["exception"] is None
    assert all(value is not error for value in record["extra"].values())


@pytest.mark.asyncio
@pytest.mark.parametrize("mode", ["sync", "async"])
async def test_cleanup_failure_does_not_replace_provider_failure(
    mode, stream_events
):
    error = UnrenderableProviderError("provider detail sentinel")
    probe = ProbeStream(error=error, after_chunk=True, close_error=True)
    wrapper, _ = make_wrapper(probe)
    chunks = []

    with pytest.raises(UnrenderableProviderError) as caught:
        await consume(wrapper, mode, chunks, {})

    assert caught.value is error
    assert chunks == [probe.chunk]
    assert probe.closed == 1
    failures = [e for e in stream_events if e.record["level"].name == "ERROR"]
    assert len(failures) == 1
    assert all(e.record["exception"] is None for e in stream_events)
    assert all("sentinel" not in str(e) for e in stream_events)


@pytest.mark.asyncio
@pytest.mark.parametrize("mode", ["sync", "async"])
@pytest.mark.parametrize("abort_type", [GeneratorExit, asyncio.CancelledError])
async def test_abort_propagates_and_closes_without_failure_event(
    mode, abort_type, stream_events
):
    abort = abort_type("abort detail sentinel")
    probe = ProbeStream(error=abort, after_chunk=True)
    wrapper, _ = make_wrapper(probe)
    chunks = []

    with pytest.raises(abort_type) as caught:
        await consume(wrapper, mode, chunks, {})

    assert caught.value is abort
    assert chunks == [probe.chunk]
    assert probe.closed == 1
    assert stream_events == []


@pytest.mark.asyncio
@pytest.mark.parametrize("mode", ["sync", "async"])
async def test_success_forwards_chunks_and_closes_without_failure_event(
    mode, stream_events
):
    probe = ProbeStream()
    wrapper, _ = make_wrapper(probe)
    chunks = []

    await consume(wrapper, mode, chunks, {})

    assert chunks == [probe.chunk]
    assert probe.closed == 1
    assert stream_events == []


@pytest.mark.asyncio
@pytest.mark.parametrize("mode", ["sync", "async"])
async def test_consumer_close_cleans_up_without_failure_event(
    mode, stream_events
):
    probe = ProbeStream(error=UnrenderableProviderError(), after_chunk=True)
    wrapper, _ = make_wrapper(probe)

    if mode == "sync":
        stream = wrapper.stream("prompt")
        assert next(stream) is probe.chunk
        stream.close()
    else:
        stream = wrapper.astream("prompt")
        assert await anext(stream) is probe.chunk
        await stream.aclose()

    assert probe.closed == 1
    assert stream_events == []