Skip to content

Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)

Python
115 KB
Raw Blame
"""Tests for streaming error handling in providers/nvidia_nim/client.py."""

import asyncio
import json
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock, patch

import httpx
import httpx2
import openai
import pytest

from free_claude_code.config.nim import NimSettings
from free_claude_code.core.anthropic.stream_contracts import (
    assert_anthropic_stream_contract,
    parse_sse_text,
)
from free_claude_code.core.anthropic.streaming import (
    make_response_recovery_body,
    make_text_recovery_body,
    tool_schemas_by_name,
)
from free_claude_code.core.failures import ExecutionFailure, FailureKind
from free_claude_code.core.openai_responses import OpenAIResponsesRequest
from free_claude_code.core.openai_tool_names import OpenAIToolNameCodec
from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicy
from free_claude_code.providers.admission import (
    UPSTREAM_TRANSIENT_TOTAL_ATTEMPTS,
    ProviderOperationKind,
)
from free_claude_code.providers.nvidia_nim import NvidiaNimProvider
from free_claude_code.providers.openai_chat.stream_output import (
    AnthropicChatStreamOutput,
)
from free_claude_code.providers.openai_chat.tool_calls import (
    OpenAIToolCallAssembler,
    OpenAIToolCallCollector,
)
from free_claude_code.providers.openai_chat.transport import (
    _OpenAIChatStreamRunner,
    _reserved_anthropic_tool_ids,
)
from free_claude_code.providers.request_recovery import RequestRecovery
from free_claude_code.providers.stream_recovery import TruncatedProviderStreamError
from tests.providers.request_factory import make_messages_request
from tests.providers.support import (
    REASONING_OFF,
    SDKStreamDouble,
    immediate_admission,
    make_provider_config,
    profiled_provider,
)
from tests.providers.test_history_transports import _events_for, _harness, _saved_reply
from tests.providers.test_nvidia_nim import (
    _alias_events,
    _alias_provider,
    _alias_request,
)


class AsyncStreamMock(SDKStreamDouble):
    """Async iterable mock that yields chunks then optionally raises."""

    def __init__(self, chunks, error=None):
        self._chunks = chunks
        self._error = error
        super().__init__(self._aiter())

    async def _aiter(self):
        for chunk in self._chunks:
            yield chunk
        if self._error:
            raise self._error


def _recovery_output(
    text: str = "",
    thinking: str = "",
    tool_calls: tuple[dict, ...] = (),
) -> SimpleNamespace:
    return SimpleNamespace(text=text, thinking=thinking, tool_calls=tool_calls)


class ClosableAsyncStreamMock(AsyncStreamMock):
    """Async stream mock that records cleanup."""

    def __init__(self, chunks, error=None, *, close_error=None):
        super().__init__(chunks, error=error)
        self.closed = False
        self.close_calls = 0
        self._close_error = close_error

    async def aclose(self):
        self.close_calls += 1
        self.closed = True
        if self._close_error is not None:
            raise self._close_error

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


class BlockingClosableAsyncStreamMock(SDKStreamDouble):
    """Async stream that blocks until its consumer is cancelled."""

    def __init__(self, *, close_error=None):
        self.entered = asyncio.Event()
        self.close_calls = 0
        self._close_error = close_error
        super().__init__(self._aiter(), close=self.aclose)

    async def _aiter(self):
        self.entered.set()
        await asyncio.Event().wait()
        yield

    async def aclose(self):
        self.close_calls += 1
        if self._close_error is not None:
            raise self._close_error


def _make_provider():
    """Create a provider instance for testing."""
    config = make_provider_config(
        api_key="test_key",
        base_url="https://test.api.nvidia.com/v1",
    )
    return NvidiaNimProvider(
        config,
        nim_settings=NimSettings(),
        admission=immediate_admission(),
    )


def _make_tool_assembler(
    provider: NvidiaNimProvider, *, request=None
) -> OpenAIToolCallAssembler:
    concrete_request = request or _make_request()
    return OpenAIToolCallAssembler(
        reserved_tool_ids=_reserved_anthropic_tool_ids(concrete_request),
        record_extra_content=provider._behavior.record_tool_call_extra_content,
    )


def _make_anthropic_output() -> AnthropicChatStreamOutput:
    return AnthropicChatStreamOutput(
        message_id="msg_test",
        model="test-model",
        input_tokens=0,
    )


def _make_request(model: str = "test-model", stream: bool = True, **overrides: object):
    """Create a concrete request matching the original streaming-test defaults."""
    request_overrides: dict[str, object] = {
        "messages": [],
        "max_tokens": 4096,
        "temperature": None,
        "top_p": None,
        "system": None,
        "tools": None,
        "extra_body": None,
        "thinking": None,
        "stream": stream,
    }
    request_overrides.update(overrides)
    return make_messages_request(model, **request_overrides)


def _make_stream_runner(
    provider: NvidiaNimProvider,
    *,
    request=None,
    request_id: str | None = None,
) -> _OpenAIChatStreamRunner:
    concrete_request = request or _make_request()
    return _OpenAIChatStreamRunner(
        provider._chat,
        body=provider._chat._build_request_body(concrete_request),
        tool_names=OpenAIToolNameCodec.from_request(concrete_request),
        tool_schemas=tool_schemas_by_name(concrete_request),
        reserved_tool_ids=_reserved_anthropic_tool_ids(concrete_request),
        output_factory=_make_anthropic_output,
        input_tokens=0,
        request_id=request_id,
        response_model=concrete_request.model,
        reasoning=DEFAULT_REASONING_POLICY,
    )


def _make_chunk(
    content=None, finish_reason=None, tool_calls=None, reasoning_content=None
):
    """Create a mock streaming chunk."""
    delta = MagicMock()
    delta.content = content
    delta.tool_calls = tool_calls
    delta.reasoning_content = reasoning_content

    choice = MagicMock()
    choice.delta = delta
    choice.finish_reason = finish_reason

    chunk = MagicMock()
    chunk.choices = [choice]
    chunk.usage = None
    return chunk


def _make_context_length_bad_request() -> openai.BadRequestError:
    response = httpx2.Response(
        status_code=400,
        request=httpx2.Request(
            "POST", "https://test.api.nvidia.com/v1/chat/completions"
        ),
    )
    return openai.BadRequestError(
        "maximum context reached",
        response=response,
        body={"error": {"code": "context_length_exceeded"}},
    )


def _make_usage_chunk(*, prompt_tokens: int, completion_tokens: int):
    chunk = MagicMock()
    chunk.choices = []
    chunk.usage = SimpleNamespace(
        prompt_tokens=prompt_tokens,
        completion_tokens=completion_tokens,
    )
    return chunk


def _make_tool_calls_chunk(
    *, name: str | None, arguments: str, tool_id: str | None, index: int = 0
):
    """Single OpenAI-style tool_calls delta (starts a native streamed tool block)."""
    tc = MagicMock()
    tc.index = index
    tc.id = tool_id
    fn = MagicMock()
    fn.name = name
    fn.arguments = arguments
    tc.function = fn
    return _make_chunk(tool_calls=[tc])


async def _collect_stream(
    provider,
    request,
    *,
    reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
):
    """Collect all SSE events from a stream."""
    return [e async for e in provider.stream_messages(request, reasoning=reasoning)]


async def _collect_stream_error(provider, request, **kwargs) -> ExecutionFailure:
    with pytest.raises(ExecutionFailure) as exc_info:
        [e async for e in provider.stream_messages(request, **kwargs)]
    return exc_info.value


async def _collect_stream_and_error(
    provider, request, **kwargs
) -> tuple[list[str], ExecutionFailure]:
    events: list[str] = []
    with pytest.raises(ExecutionFailure) as exc_info:
        async for event in provider.stream_messages(request, **kwargs):
            events.extend((event,))
    return events, exc_info.value


def _tool_use_starts(events: list[str]) -> list[dict]:
    return [
        event.data["content_block"]
        for event in parse_sse_text("".join(events))
        if event.event == "content_block_start"
        and event.data.get("content_block", {}).get("type") == "tool_use"
    ]


def _assert_no_content_deltas_after_error_text(
    events: list[str], error_substr: str
) -> None:
    """After the error text delta, only block close + message tail events may follow."""
    parsed = parse_sse_text("".join(events))
    first_error_idx = None
    for i, ev in enumerate(parsed):
        if ev.event != "content_block_delta":
            continue
        delta = ev.data.get("delta", {})
        if delta.get("type") == "text_delta" and error_substr in str(
            delta.get("text", "")
        ):
            first_error_idx = i
            break
    assert first_error_idx is not None, (error_substr, "".join(events))
    for ev in parsed[first_error_idx + 1 :]:
        assert ev.event in ("content_block_stop", "message_delta", "message_stop"), (
            ev.event,
            ev.data,
        )


def _assert_error_not_in_text_deltas_after_tool(
    events: list[str], error_substr: str
) -> None:
    """Transport errors after a native tool call must not use assistant text_delta (issue #206)."""
    blob = "".join(events)
    for ev in parse_sse_text(blob):
        if ev.event != "content_block_delta":
            continue
        delta = ev.data.get("delta", {})
        if delta.get("type") == "text_delta" and error_substr in str(
            delta.get("text", "")
        ):
            raise AssertionError(
                f"error leaked as text_delta after tool_use: {ev.data!r} full={blob!r}"
            )


class TestStreamingExceptionHandling:
    @pytest.mark.asyncio
    async def test_stream_normalization_failure_closes_raw_stream(self):
        provider = _make_provider()
        stream = ClosableAsyncStreamMock([])
        execution = provider._admission.start_execution()

        with (
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                return_value=stream,
            ),
            patch.object(
                provider._behavior,
                "normalize_stream",
                side_effect=ValueError("invalid stream wrapper"),
            ),
            pytest.raises(ValueError, match="invalid stream wrapper"),
        ):
            await provider._chat._create_stream(
                {"model": "test-model", "messages": []},
                RequestRecovery(execution),
                ProviderOperationKind.GENERATION,
            )

        assert stream.closed

    """Tests for error paths during stream_messages."""

    @pytest.mark.asyncio
    async def test_pre_start_api_error_raises_provider_error(self):
        """Before holdback commit, provider failures raise for API-level non-200."""
        provider = _make_provider()
        request = _make_request()

        with (
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                side_effect=RuntimeError("API failed"),
            ),
        ):
            error = await _collect_stream_error(provider, request)

        assert "API failed" in error.message

    @pytest.mark.asyncio
    @pytest.mark.parametrize("wire_api", ["messages", "responses"])
    async def test_context_finish_reason_is_terminal_before_output(
        self,
        wire_api: str,
    ) -> None:
        provider = _make_provider()
        stream = AsyncStreamMock(
            [_make_chunk(finish_reason=" Model_Context_Window_Exceeded ")]
        )

        with (
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                return_value=stream,
            ) as create,
            pytest.raises(ExecutionFailure) as exc_info,
        ):
            if wire_api == "messages":
                await _collect_stream(provider, _make_request())
            else:
                [
                    event
                    async for event in provider.stream_responses(
                        OpenAIResponsesRequest(model="test-model", input="hello"),
                        request_id="req_context",
                        response_model="public-model",
                    )
                ]

        assert create.await_count == 1
        assert exc_info.value.kind is FailureKind.CONTEXT_WINDOW_EXCEEDED
        assert exc_info.value.retryable is False

    @pytest.mark.asyncio
    async def test_read_timeout_with_empty_message_raises_fallback(self):
        """ReadTimeout(TimeoutError()) should raise a non-empty timeout message."""
        provider = _make_provider()
        request = _make_request()

        with (
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                side_effect=httpx.ReadTimeout(""),
            ),
            patch("asyncio.sleep", new_callable=AsyncMock),
        ):
            error = await _collect_stream_error(
                provider,
                request,
                request_id="req_timeout123",
            )

        assert "timed out after" in error.message
        assert "Request ID: req_timeout123" in error.message

    @pytest.mark.asyncio
    async def test_error_after_precommit_partial_content_raises(self):
        """Precommit partial text is discarded so the API can return non-200."""
        provider = _make_provider()
        request = _make_request()

        chunk1 = _make_chunk(content="Hello ")
        stream_mock = AsyncStreamMock([chunk1], error=RuntimeError("Connection lost"))

        with (
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                return_value=stream_mock,
            ),
        ):
            error = await _collect_stream_error(provider, request)

        assert "Connection lost" in error.message

    @pytest.mark.asyncio
    async def test_error_after_native_tool_call_keeps_tool_incomplete_and_raises(self):
        """A failure never marks an unfinished tool complete for the API."""
        provider = _make_provider()
        request = _make_request()
        tool_chunk = _make_tool_calls_chunk(
            name="echo_smoke", arguments="{}", tool_id="call_206", index=0
        )
        stream_mock = AsyncStreamMock(
            [tool_chunk], error=RuntimeError("Connection lost after tool")
        )
        with (
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                return_value=stream_mock,
            ),
        ):
            events, error = await _collect_stream_and_error(provider, request)
        event_text = "".join(events)
        parsed = parse_sse_text(event_text)
        assert "tool_use" in event_text
        assert not any(event.event == "content_block_stop" for event in parsed)
        assert "Connection lost after tool" in error.message
        assert "Connection lost after tool" not in event_text
        assert "event: error\n" not in event_text
        assert "message_stop" not in event_text
        _assert_error_not_in_text_deltas_after_tool(
            events, "Connection lost after tool"
        )

    @pytest.mark.asyncio
    async def test_empty_response_gets_space(self):
        """Empty response with no text/tools gets a single space text block."""
        provider = _make_provider()
        request = _make_request()

        empty_chunk = _make_chunk(finish_reason="stop")
        stream_mock = AsyncStreamMock([empty_chunk])

        with (
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                return_value=stream_mock,
            ),
        ):
            events = await _collect_stream(provider, request)

        event_text = "".join(events)
        assert '"text_delta"' in event_text
        assert "message_stop" in event_text

    @pytest.mark.asyncio
    async def test_upstream_completion_tokens_null_emits_int_usage(self):
        """NIM/GLM may send usage.completion_tokens=null; final SSE must not use JSON null."""
        provider = _make_provider()
        request = _make_request()

        delta = SimpleNamespace(
            content="hello",
            tool_calls=None,
            reasoning_content=None,
        )
        choice = SimpleNamespace(delta=delta, finish_reason="stop")
        usage = SimpleNamespace(completion_tokens=None, prompt_tokens=None)
        chunk = SimpleNamespace(choices=[choice], usage=usage)
        stream_mock = AsyncStreamMock([chunk])

        with (
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                return_value=stream_mock,
            ),
        ):
            events = await _collect_stream(provider, request)

        parsed = parse_sse_text("".join(events))
        delta_events = [e for e in parsed if e.event == "message_delta"]
        assert len(delta_events) == 1
        usage_out = delta_events[0].data.get("usage", {})
        assert isinstance(usage_out.get("output_tokens"), int)
        assert usage_out["output_tokens"] is not None
        assert '"output_tokens": null' not in "".join(events)

    @pytest.mark.asyncio
    async def test_reasoning_only_stream_emits_placeholder_text(self):
        """When the model streams only ``reasoning_content`` (no ``content``), add text block.

        NIM / some templates may emit no main ``content``; a minimal text block matches
        the empty-body placeholder and helps clients that expect a text segment.
        """
        provider = _make_provider()
        request = _make_request()
        chunk1 = _make_chunk(reasoning_content="reasoning only from provider")
        chunk2 = _make_chunk(finish_reason="stop")
        stream_mock = AsyncStreamMock([chunk1, chunk2])
        with (
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                return_value=stream_mock,
            ),
        ):
            events = await _collect_stream(provider, request)
        event_text = "".join(events)
        assert "thinking_delta" in event_text
        assert '"text_delta"' in event_text
        assert "message_stop" in event_text

    @pytest.mark.asyncio
    async def test_stream_with_thinking_content(self):
        """Thinking content via think tags is emitted as thinking blocks."""
        provider = _make_provider()
        request = _make_request()

        chunk1 = _make_chunk(content="<think>reasoning</think>answer")
        chunk2 = _make_chunk(finish_reason="stop")
        stream_mock = AsyncStreamMock([chunk1, chunk2])

        with (
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                return_value=stream_mock,
            ),
        ):
            events = await _collect_stream(provider, request)

        event_text = "".join(events)
        assert "thinking" in event_text
        assert "reasoning" in event_text
        assert "answer" in event_text

    @pytest.mark.asyncio
    async def test_stream_with_reasoning_content_field(self):
        """reasoning_content delta field is emitted as thinking block."""
        provider = _make_provider()
        request = _make_request()

        chunk1 = _make_chunk(reasoning_content="I think...")
        chunk2 = _make_chunk(content="The answer")
        chunk3 = _make_chunk(finish_reason="stop")
        stream_mock = AsyncStreamMock([chunk1, chunk2, chunk3])

        with (
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                return_value=stream_mock,
            ),
        ):
            events = await _collect_stream(provider, request)

        event_text = "".join(events)
        assert "thinking_delta" in event_text
        assert "I think..." in event_text
        assert "The answer" in event_text

    @pytest.mark.asyncio
    async def test_stream_with_empty_reasoning_content_creates_no_thinking_block(self):
        """Empty reasoning_content is stateful but must not emit visible thinking text."""
        provider = _make_provider()
        request = _make_request()

        chunk1 = _make_chunk(reasoning_content="")
        chunk2 = _make_chunk(finish_reason="stop")
        stream_mock = AsyncStreamMock([chunk1, chunk2])

        with (
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                return_value=stream_mock,
            ),
        ):
            events = await _collect_stream(provider, request)

        parsed = parse_sse_text("".join(events))
        thinking_starts = [
            event
            for event in parsed
            if event.event == "content_block_start"
            and event.data["content_block"]["type"] == "thinking"
        ]
        thinking_deltas = [
            event
            for event in parsed
            if event.event == "content_block_delta"
            and event.data["delta"]["type"] == "thinking_delta"
        ]
        assert thinking_starts == []
        assert thinking_deltas == []
        assert parsed[-1].event == "message_stop"

    @pytest.mark.asyncio
    @pytest.mark.parametrize("wire", ["messages", "responses"])
    @pytest.mark.parametrize(
        ("deltas", "expected"),
        [
            pytest.param(
                [("plan", ""), ("", "The quick"), ("", " brown fox"), ("", "")],
                [("reasoning", "plan"), ("text", "The quick brown fox")],
                id="empty-placeholders-after-reasoning",
            ),
            pytest.param(
                [("", "The quick"), ("", " brown fox"), ("", "")],
                [("text", "The quick brown fox")],
                id="first-empty-reasoning-is-ignored",
            ),
            pytest.param(
                [(None, "The quick"), (None, " brown fox")],
                [("text", "The quick brown fox")],
                id="no-reasoning-is-invented",
            ),
            pytest.param(
                [("", None), ("", "first"), ("more", None), ("", "second")],
                [
                    ("text", "first"),
                    ("reasoning", "more"),
                    ("text", "second"),
                ],
                id="nonempty-reasoning-can-resume",
            ),
        ],
    )
    async def test_empty_reasoning_placeholders_preserve_content_blocks(
        self, wire, deltas, expected
    ):
        provider = profiled_provider(
            "qwencloud",
            make_provider_config(api_key="test", base_url="https://provider.invalid"),
        )
        chunks = [
            _make_chunk(reasoning_content=reasoning, content=content)
            for reasoning, content in deltas
        ] + [_make_chunk(finish_reason="stop")]
        try:
            with patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                side_effect=lambda **kwargs: AsyncStreamMock(chunks),
            ):
                # Empty placeholders do not create output items on either request.
                for _ in range(2):
                    if wire == "messages":
                        stream = provider.stream_messages(_make_request())
                    else:
                        stream = provider.stream_responses(
                            OpenAIResponsesRequest(model="test-model", input="Hello")
                        )
                    events = parse_sse_text("".join([frame async for frame in stream]))
                    if wire == "messages":
                        assert_anthropic_stream_contract(events)
                        actual = [
                            (
                                "reasoning"
                                if start.data["content_block"]["type"] == "thinking"
                                else start.data["content_block"]["type"],
                                "".join(
                                    event.data["delta"].get(
                                        "thinking", event.data["delta"].get("text", "")
                                    )
                                    for event in events
                                    if event.event == "content_block_delta"
                                    and event.data["index"] == start.data["index"]
                                ),
                            )
                            for start in events
                            if start.event == "content_block_start"
                        ]
                    else:
                        assert events[-1].event == "response.completed"
                        actual = [
                            (
                                "text" if item["type"] == "message" else item["type"],
                                "".join(part["text"] for part in item["content"]),
                            )
                            for item in events[-1].data["response"]["output"]
                        ]
                    assert actual == expected
        finally:
            await provider.cleanup()

    @pytest.mark.asyncio
    async def test_stream_with_reasoning_content_suppressed_when_disabled(self):
        """reasoning deltas are stripped while normal text still streams."""
        provider = _make_provider()
        request = _make_request()

        chunk1 = _make_chunk(reasoning_content="I think...")
        chunk2 = _make_chunk(content="<think>secret</think>The answer")
        chunk3 = _make_chunk(finish_reason="stop")
        stream_mock = AsyncStreamMock([chunk1, chunk2, chunk3])

        with (
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                return_value=stream_mock,
            ),
        ):
            events = await _collect_stream(provider, request, reasoning=REASONING_OFF)

        event_text = "".join(events)
        assert "thinking_delta" not in event_text
        assert "I think..." not in event_text
        assert "secret" not in event_text
        assert "The answer" in event_text

    @pytest.mark.asyncio
    async def test_stream_with_upstream_405_mentions_provider_name(self):
        """HTTP 405s are surfaced as upstream method/endpoint rejections."""
        provider = _make_provider()
        request = _make_request()

        response = httpx.Response(
            status_code=405,
            request=httpx.Request("POST", "https://example.com/v1/chat/completions"),
        )
        error = httpx.HTTPStatusError(
            "Method Not Allowed",
            request=response.request,
            response=response,
        )

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            side_effect=error,
        ):
            stream_error = await _collect_stream_error(
                provider,
                request,
                request_id="REQ405",
            )

        assert (
            "Upstream provider NIM rejected the request method or endpoint (HTTP 405)."
            in stream_error.message
        )
        assert "Request ID: REQ405" in stream_error.message

    @pytest.mark.asyncio
    async def test_stream_with_openai_bad_request_surfaces_upstream_body(self):
        """OpenAI SDK bodies should be raised so users can copy exact provider errors."""
        provider = _make_provider()
        request = _make_request()
        response = httpx2.Response(
            status_code=400,
            request=httpx2.Request("POST", "https://example.com/v1/chat/completions"),
        )
        body = {
            "error": {
                "type": "BadRequest",
                "message": "Thinking mode does not support this tool_choice",
            }
        }
        error = openai.BadRequestError("Bad Request", response=response, body=body)

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            side_effect=error,
        ):
            stream_error = await _collect_stream_error(
                provider,
                request,
                request_id="REQ_BODY",
            )

        assert "Upstream provider NIM returned HTTP 400." in stream_error.message
        assert "Category: BadRequest" in stream_error.message
        assert "Thinking mode does not support this tool_choice" in stream_error.message
        assert (
            '{"error":{"type":"BadRequest","message":"Thinking mode does not support this tool_choice"}}'
            in stream_error.message
        )
        assert "Request ID: REQ_BODY" in stream_error.message

    @pytest.mark.asyncio
    async def test_error_after_native_tool_call_failure_includes_body(self):
        """Detailed failure data survives without completing an unfinished tool."""
        provider = _make_provider()
        request = _make_request()
        tool_chunk = _make_tool_calls_chunk(
            name="echo_smoke", arguments="{}", tool_id="call_body", index=0
        )
        response = httpx2.Response(
            status_code=400,
            request=httpx2.Request("POST", "https://example.com/v1/chat/completions"),
        )
        body = {"error": {"message": "bad after tool"}}
        error = openai.BadRequestError("Bad Request", response=response, body=body)
        stream_mock = AsyncStreamMock([tool_chunk], error=error)

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            return_value=stream_mock,
        ):
            events, stream_error = await _collect_stream_and_error(
                provider,
                request,
                request_id="REQ_TOOL_BODY",
            )

        event_text = "".join(events)
        parsed = parse_sse_text(event_text)
        assert "tool_use" in event_text
        assert not any(event.event == "content_block_stop" for event in parsed)
        assert "event: error\n" not in event_text
        assert "bad after tool" not in event_text
        assert "Request ID: REQ_TOOL_BODY" not in event_text
        assert "message_stop" not in event_text
        assert "bad after tool" in stream_error.message
        assert "Request ID: REQ_TOOL_BODY" in stream_error.message
        _assert_error_not_in_text_deltas_after_tool(events, "bad after tool")

    @pytest.mark.asyncio
    async def test_clean_eof_after_complete_tool_call_salvages_tool_use(self):
        """A complete tool JSON payload missing finish_reason is committed as tool_use."""
        provider = _make_provider()
        request = _make_request()
        tool_chunk = _make_tool_calls_chunk(
            name="echo_smoke", arguments='{"message":"ok"}', tool_id="call_eof"
        )
        stream_mock = AsyncStreamMock([tool_chunk])

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            return_value=stream_mock,
        ):
            events = await _collect_stream(provider, request)

        parsed = parse_sse_text("".join(events))
        assert parsed[-1].event == "message_stop"
        assert any(
            event.event == "message_delta"
            and event.data.get("delta", {}).get("stop_reason") == "tool_use"
            for event in parsed
        )
        assert not any(event.event == "error" for event in parsed)

    @pytest.mark.asyncio
    @pytest.mark.parametrize("finish_reason", ["tool_calls", "stop"])
    async def test_legacy_tool_markup_remains_visible_text(self, finish_reason):
        """Legacy markup cannot manufacture executable tool calls."""
        provider = _make_provider()
        request = _make_request()
        heuristic_tool = (
            "● <function=Read><parameter=path>test.py</parameter>"
            "<parameter=limit>10</parameter>"
        )
        stream_mock = AsyncStreamMock(
            [
                _make_chunk(content=heuristic_tool),
                _make_chunk(finish_reason=finish_reason),
            ]
        )

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            return_value=stream_mock,
        ):
            events = await _collect_stream(provider, request)

        parsed = parse_sse_text("".join(events))
        assert not any(
            event.event == "content_block_start"
            and event.data.get("content_block", {}).get("type") == "tool_use"
            for event in parsed
        )
        assert not any(
            event.event == "content_block_delta"
            and event.data.get("delta", {}).get("type") == "text_delta"
            and event.data.get("delta", {}).get("text") == " "
            for event in parsed
        )
        assert any(
            event.event == "message_delta"
            and event.data.get("delta", {}).get("stop_reason") == "end_turn"
            for event in parsed
        )

        assert (
            "".join(event.data.get("delta", {}).get("text", "") for event in parsed)
            == heuristic_tool
        )

    @pytest.mark.asyncio
    async def test_function_tag_markup_remains_text_beside_reasoning(self):
        """Function-looking text stays visible after reasoning parsing."""
        provider = _make_provider()
        request = _make_request(
            tools=[
                {
                    "name": "Bash",
                    "input_schema": {
                        "type": "object",
                        "properties": {"command": {"type": "string"}},
                        "required": ["command"],
                        "additionalProperties": False,
                    },
                }
            ]
        )
        raw_call = (
            "<think>Use the requested command.</think>"
            "I will invoke Bash now.\n"
            "<tool_call>\n<function=Bash>\n<parameter=command>\n"
            "printf FCC_STEP_TOOL\n</parameter>\n</function>\n</tool_call>"
        )
        stream_mock = AsyncStreamMock(
            [
                _make_chunk(content=raw_call[:43]),
                _make_chunk(content=raw_call[43:]),
                _make_chunk(finish_reason="stop"),
            ]
        )

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            return_value=stream_mock,
        ):
            events = await _collect_stream(provider, request)

        parsed = parse_sse_text("".join(events))
        starts = [
            event.data["content_block"]
            for event in parsed
            if event.event == "content_block_start"
        ]
        tool_starts = [block for block in starts if block["type"] == "tool_use"]
        input_json = "".join(
            event.data.get("delta", {}).get("partial_json", "")
            for event in parsed
            if event.event == "content_block_delta"
            and event.data.get("delta", {}).get("type") == "input_json_delta"
        )
        visible_text = "".join(
            event.data.get("delta", {}).get("text", "")
            for event in parsed
            if event.event == "content_block_delta"
            and event.data.get("delta", {}).get("type") == "text_delta"
        )

        assert tool_starts == []
        assert input_json == ""
        assert visible_text == raw_call.split("</think>", 1)[1]
        assert any(
            event.event == "content_block_delta"
            and event.data.get("delta", {}).get("type") == "thinking_delta"
            for event in parsed
        )
        assert any(
            event.event == "message_delta"
            and event.data.get("delta", {}).get("stop_reason") == "end_turn"
            for event in parsed
        )

    @pytest.mark.asyncio
    async def test_native_tool_call_disables_function_tag_recovery(self):
        """Native structured calls win and release earlier candidate text in order."""
        provider = _make_provider()
        request = _make_request(
            tools=[
                {
                    "name": "Bash",
                    "input_schema": {
                        "type": "object",
                        "properties": {"command": {"type": "string"}},
                    },
                }
            ]
        )
        held_text = "<tool_call>\n<function=Bash>"
        stream_mock = AsyncStreamMock(
            [
                _make_chunk(content=held_text),
                _make_tool_calls_chunk(
                    name="Bash",
                    arguments='{"command":"printf native"}',
                    tool_id="call_native",
                ),
                _make_chunk(finish_reason="tool_calls"),
            ]
        )

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            return_value=stream_mock,
        ):
            events = await _collect_stream(provider, request)

        parsed = parse_sse_text("".join(events))
        visible_text = "".join(
            event.data.get("delta", {}).get("text", "")
            for event in parsed
            if event.event == "content_block_delta"
            and event.data.get("delta", {}).get("type") == "text_delta"
        )
        tool_starts = [
            event.data["content_block"]
            for event in parsed
            if event.event == "content_block_start"
            and event.data.get("content_block", {}).get("type") == "tool_use"
        ]

        assert visible_text == held_text
        assert [block["id"] for block in tool_starts] == ["call_native"]

    @pytest.mark.asyncio
    async def test_rejected_function_tag_candidate_bypasses_legacy_heuristics(self):
        """Rejected reserved text is preserved without a second permissive parse."""
        provider = _make_provider()
        request = _make_request(
            tools=[
                {
                    "name": "Bash",
                    "input_schema": {
                        "type": "object",
                        "properties": {"command": {"type": "string"}},
                    },
                }
            ]
        )
        raw = (
            "<tool_call><function=Unknown></function></tool_call>"
            "● <function=Bash><parameter=command>printf unsafe</parameter>"
        )
        stream_mock = AsyncStreamMock(
            [_make_chunk(content=raw), _make_chunk(finish_reason="stop")]
        )

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            return_value=stream_mock,
        ):
            events = await _collect_stream(provider, request)

        parsed = parse_sse_text("".join(events))
        visible_text = "".join(
            event.data.get("delta", {}).get("text", "")
            for event in parsed
            if event.event == "content_block_delta"
            and event.data.get("delta", {}).get("type") == "text_delta"
        )
        tool_starts = [
            event
            for event in parsed
            if event.event == "content_block_start"
            and event.data.get("content_block", {}).get("type") == "tool_use"
        ]

        assert visible_text == raw
        assert tool_starts == []

    @pytest.mark.asyncio
    @pytest.mark.parametrize("committed", [False, True])
    async def test_literal_markup_respects_connection_commit_boundary(self, committed):
        """Literal markup follows ordinary retry and continuation boundaries."""
        provider = _make_provider()
        request = _make_request(
            tools=[
                {
                    "name": "Bash",
                    "input_schema": {
                        "type": "object",
                        "properties": {"command": {"type": "string"}},
                        "required": ["command"],
                    },
                }
            ]
        )
        abandoned = "<tool_call>\n<function=Bash>"
        if committed:
            abandoned += "x" * 66000
        complete = (
            "<tool_call>\n<function=Bash>\n<parameter=command>\n"
            "printf retry\n</parameter>\n</function>\n</tool_call>"
        )
        first_stream = AsyncStreamMock(
            [_make_chunk(content=abandoned)],
            error=httpx.ReadError("early cutoff"),
        )
        second_stream = AsyncStreamMock(
            [_make_chunk(content=complete), _make_chunk(finish_reason="stop")]
        )

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            side_effect=[first_stream, second_stream],
        ) as mock_create:
            events = await _collect_stream(provider, request)

        parsed = parse_sse_text("".join(events))
        visible_text = "".join(
            event.data.get("delta", {}).get("text", "")
            for event in parsed
            if event.event == "content_block_delta"
            and event.data.get("delta", {}).get("type") == "text_delta"
        )
        tool_starts = [
            event.data["content_block"]
            for event in parsed
            if event.event == "content_block_start"
            and event.data.get("content_block", {}).get("type") == "tool_use"
        ]

        assert mock_create.await_count == 2
        assert visible_text == (abandoned + complete if committed else complete)
        assert tool_starts == []

        assert ("tools" not in mock_create.call_args_list[1].kwargs) == committed

    @pytest.mark.asyncio
    async def test_precommit_retry_discards_abandoned_tool_id_candidate(self):
        """An ID observed only by an invisible attempt cannot leak into its replay."""
        provider = _make_provider()
        request = _make_request()
        first_stream = AsyncStreamMock(
            [
                _make_tool_calls_chunk(
                    name=None,
                    arguments="",
                    tool_id="call_abandoned",
                )
            ],
            error=httpx.ReadError("early cutoff"),
        )
        second_stream = AsyncStreamMock(
            [
                _make_tool_calls_chunk(
                    name="Bash",
                    arguments="{}",
                    tool_id=None,
                ),
                _make_chunk(finish_reason="tool_calls"),
            ]
        )

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            side_effect=[first_stream, second_stream],
        ) as mock_create:
            events = await _collect_stream(provider, request)

        parsed = parse_sse_text("".join(events))
        [start] = _tool_use_starts(events)
        assert mock_create.await_count == 2
        assert start["id"].startswith("tool_")
        assert start["id"] != "call_abandoned"
        assert sum(event.event == "message_start" for event in parsed) == 1
        assert sum(event.event == "content_block_start" for event in parsed) == 1
        assert sum(event.event == "message_delta" for event in parsed) == 1
        assert sum(event.event == "message_stop" for event in parsed) == 1

    @pytest.mark.asyncio
    async def test_colliding_tool_id_round_trips_as_distinct_matched_pair(self):
        """A repaired public ID stays paired when Claude replays the next turn."""
        provider = _make_provider()
        first_pair = [
            {"role": "user", "content": "Run it once."},
            {
                "role": "assistant",
                "content": [
                    {
                        "type": "tool_use",
                        "id": "Bash:0",
                        "name": "Bash",
                        "input": {"command": "printf first"},
                    }
                ],
            },
            {
                "role": "user",
                "content": [
                    {
                        "type": "tool_result",
                        "tool_use_id": "Bash:0",
                        "content": "first",
                    }
                ],
            },
        ]
        request = _make_request(
            messages=[*first_pair, {"role": "user", "content": "Run it again."}]
        )
        stream = AsyncStreamMock(
            [
                _make_tool_calls_chunk(
                    name="Bash",
                    arguments='{"command":"printf second"}',
                    tool_id="Bash:0",
                ),
                _make_chunk(finish_reason="tool_calls"),
            ]
        )

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            return_value=stream,
        ):
            events = await _collect_stream(provider, request)

        [start] = _tool_use_starts(events)
        public_id = start["id"]
        assert public_id != "Bash:0"

        replay = _make_request(
            messages=[
                *request.messages,
                {
                    "role": "assistant",
                    "content": [
                        {
                            "type": "tool_use",
                            "id": public_id,
                            "name": "Bash",
                            "input": {"command": "printf second"},
                        }
                    ],
                },
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": public_id,
                            "content": "second",
                        }
                    ],
                },
            ]
        )
        body = provider._chat._build_request_body(
            replay,
            reasoning=DEFAULT_REASONING_POLICY,
        )
        assistant_ids = [
            message["tool_calls"][0]["id"]
            for message in body["messages"]
            if message.get("role") == "assistant" and message.get("tool_calls")
        ]
        result_ids = [
            message["tool_call_id"]
            for message in body["messages"]
            if message.get("role") == "tool"
        ]
        assert assistant_ids == ["Bash:0", public_id]
        assert result_ids == ["Bash:0", public_id]

    @pytest.mark.asyncio
    async def test_precommit_retry_emits_one_unduplicated_downstream_lifecycle(self):
        """An abandoned attempt contributes no frame to the successful replay."""
        provider = _make_provider()
        request = _make_request()
        first_stream = AsyncStreamMock(
            [_make_chunk(content="hidden")],
            error=httpx.ReadError("early cutoff"),
        )
        second_stream = AsyncStreamMock(
            [
                _make_chunk(content="visible"),
                _make_chunk(finish_reason="stop"),
            ]
        )

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            side_effect=[first_stream, second_stream],
        ) as mock_create:
            events = await _collect_stream(provider, request)

        event_text = "".join(events)
        assert mock_create.await_count == 2
        assert "hidden" not in event_text
        parsed = parse_sse_text(event_text)
        text_deltas = [
            event.data.get("delta", {}).get("text", "")
            for event in parsed
            if event.event == "content_block_delta"
        ]
        assert text_deltas == ["visible"]
        assert sum(event.event == "message_start" for event in parsed) == 1
        assert sum(event.event == "content_block_start" for event in parsed) == 1
        assert sum(event.event == "content_block_stop" for event in parsed) == 1
        assert sum(event.event == "message_delta" for event in parsed) == 1
        assert sum(event.event == "message_stop" for event in parsed) == 1
        assert parsed[0].event == "message_start"
        assert parsed[-1].event == "message_stop"

    @pytest.mark.asyncio
    async def test_responses_precommit_retry_emits_one_unduplicated_lifecycle(self):
        """Responses output also discards every frame from an abandoned attempt."""
        provider = _make_provider()
        request = OpenAIResponsesRequest(model="test-model", input="hello")
        first_stream = AsyncStreamMock(
            [_make_chunk(content="hidden")],
            error=httpx.ReadError("early cutoff"),
        )
        second_stream = AsyncStreamMock(
            [
                _make_chunk(content="visible"),
                _make_chunk(finish_reason="stop"),
            ]
        )

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            side_effect=[first_stream, second_stream],
        ) as create:
            events = [
                event
                async for event in provider.stream_responses(
                    request,
                    request_id="req_responses_retry",
                    response_model="public-model",
                )
            ]

        event_text = "".join(events)
        parsed = parse_sse_text(event_text)
        event_names = [event.event for event in parsed]
        assert create.await_count == 2
        assert "hidden" not in event_text
        assert "visible" in event_text
        assert event_names.count("response.created") == 1
        assert event_names.count("response.completed") == 1
        assert "response.failed" not in event_names

    @pytest.mark.asyncio
    async def test_responses_cancellation_closes_upstream_without_retry(self):
        provider = _make_provider()
        request = OpenAIResponsesRequest(model="test-model", input="hello")
        stream = BlockingClosableAsyncStreamMock()

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            return_value=stream,
        ) as create:
            task = asyncio.create_task(
                anext(
                    provider.stream_responses(
                        request,
                        request_id="req_responses_cancel",
                        response_model="public-model",
                    )
                )
            )
            await asyncio.wait_for(stream.entered.wait(), timeout=1)
            task.cancel()
            with pytest.raises(asyncio.CancelledError):
                await task

        assert create.await_count == 1
        assert stream.close_calls == 1

    @pytest.mark.asyncio
    async def test_precommit_retry_discards_abandoned_parser_and_usage_state(self):
        """A replay owns fresh parsers and terminal usage metadata."""
        provider = _make_provider()
        request = _make_request()
        first_stream = AsyncStreamMock(
            [
                _make_usage_chunk(prompt_tokens=111, completion_tokens=222),
                _make_chunk(content="<thi"),
            ],
            error=httpx.ReadError("early cutoff"),
        )
        second_stream = AsyncStreamMock(
            [
                _make_chunk(content="visible"),
                _make_chunk(finish_reason="stop"),
                _make_usage_chunk(prompt_tokens=7, completion_tokens=3),
            ]
        )

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            side_effect=[first_stream, second_stream],
        ) as create:
            events = await _collect_stream(provider, request)

        parsed = parse_sse_text("".join(events))
        visible_text = "".join(
            event.data.get("delta", {}).get("text", "")
            for event in parsed
            if event.event == "content_block_delta"
            and event.data.get("delta", {}).get("type") == "text_delta"
        )
        final_usage = next(
            event.data["usage"] for event in parsed if event.event == "message_delta"
        )

        assert create.await_count == 2
        assert visible_text == "visible"
        assert final_usage == {"input_tokens": 7, "output_tokens": 3}
        assert sum(event.event == "message_start" for event in parsed) == 1
        assert sum(event.event == "message_delta" for event in parsed) == 1
        assert sum(event.event == "message_stop" for event in parsed) == 1

    @pytest.mark.asyncio
    async def test_create_correction_survives_later_precommit_retry(self):
        """A corrected request body outlives the replay-local stream state."""
        provider = _make_provider()
        request = _make_request()
        response = httpx2.Response(
            status_code=400,
            request=httpx2.Request("POST", "https://example.com/v1/chat/completions"),
        )
        usage_rejection = openai.BadRequestError(
            "stream_options is unsupported",
            response=response,
            body={"error": {"message": "stream_options is unsupported"}},
        )
        first_stream = AsyncStreamMock(
            [_make_chunk(content="hidden")],
            error=httpx.ReadError("early cutoff"),
        )
        second_stream = AsyncStreamMock(
            [_make_chunk(content="visible"), _make_chunk(finish_reason="stop")]
        )

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            side_effect=[usage_rejection, first_stream, second_stream],
        ) as create:
            events = await _collect_stream(provider, request)

        parsed = parse_sse_text("".join(events))
        text_deltas = [
            event.data.get("delta", {}).get("text", "")
            for event in parsed
            if event.event == "content_block_delta"
            and event.data.get("delta", {}).get("type") == "text_delta"
        ]

        assert create.await_count == 3
        assert create.await_args_list[0].kwargs["stream_options"] == {
            "include_usage": True
        }
        assert "stream_options" not in create.await_args_list[1].kwargs
        assert "stream_options" not in create.await_args_list[2].kwargs
        assert text_deltas == ["visible"]
        assert sum(event.event == "message_start" for event in parsed) == 1
        assert sum(event.event == "message_stop" for event in parsed) == 1

    @pytest.mark.asyncio
    async def test_precommit_retry_discards_abandoned_tool_name_fragment(self):
        """A retried alias fragment cannot prefix or duplicate the successful call."""
        provider = _make_provider()
        original = "mcp__retry_tool_name__" + "x" * 70
        request = _make_request(
            tools=[{"name": original, "input_schema": {"type": "object"}}]
        )
        alias = OpenAIToolNameCodec.from_request(request).encode(original)
        first_stream = AsyncStreamMock(
            [
                _make_tool_calls_chunk(
                    name=alias[:20],
                    arguments="",
                    tool_id="call_abandoned",
                ),
                _make_chunk(finish_reason="tool_calls"),
            ]
        )
        second_stream = AsyncStreamMock(
            [
                _make_tool_calls_chunk(
                    name=alias,
                    arguments="{}",
                    tool_id="call_success",
                ),
                _make_chunk(finish_reason="tool_calls"),
            ]
        )

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            side_effect=[first_stream, second_stream],
        ) as create:
            events = await _collect_stream(provider, request)

        event_text = "".join(events)
        parsed = parse_sse_text(event_text)
        tool_starts = [
            event.data["content_block"]
            for event in parsed
            if event.event == "content_block_start"
            and event.data.get("content_block", {}).get("type") == "tool_use"
        ]
        assert create.await_count == 2
        assert tool_starts == [
            {
                "type": "tool_use",
                "id": "call_success",
                "name": original,
                "input": {},
            }
        ]
        assert alias not in event_text
        assert "call_abandoned" not in event_text
        assert sum(event.event == "message_start" for event in parsed) == 1
        assert sum(event.event == "message_stop" for event in parsed) == 1

    @pytest.mark.asyncio
    async def test_primary_replay_and_continuation_share_five_attempts(self):
        """Four replays plus continuation emit one unduplicated response."""
        provider = _make_provider()
        request = _make_request()
        primary_streams = [
            AsyncStreamMock([_make_chunk(content="hello")]) for _ in range(4)
        ]
        continuation = AsyncStreamMock(
            [
                _make_chunk(content="hello world"),
                _make_chunk(finish_reason="stop"),
            ]
        )

        with (
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                side_effect=[*primary_streams, continuation],
            ) as create,
            patch("free_claude_code.providers.admission.trace_event") as attempt_trace,
        ):
            events = await _collect_stream(provider, request)

        assert create.await_count == UPSTREAM_TRANSIENT_TOTAL_ATTEMPTS
        assert all(
            call.kwargs["messages"] == create.await_args_list[0].kwargs["messages"]
            for call in create.await_args_list[:4]
        )
        assert (
            create.await_args_list[4].kwargs["messages"]
            != (create.await_args_list[0].kwargs["messages"])
        )
        parsed = parse_sse_text("".join(events))
        text = "".join(
            event.data.get("delta", {}).get("text", "")
            for event in parsed
            if event.event == "content_block_delta"
        )
        assert text == "hello world"
        assert sum(event.event == "message_start" for event in parsed) == 1
        assert sum(event.event == "message_delta" for event in parsed) == 1
        assert sum(event.event == "message_stop" for event in parsed) == 1
        starts = [
            call.kwargs
            for call in attempt_trace.call_args_list
            if call.kwargs.get("event") == "provider.attempt.started"
        ]
        assert [row["operation_kind"] for row in starts] == [
            ProviderOperationKind.GENERATION.value,
            ProviderOperationKind.GENERATION.value,
            ProviderOperationKind.GENERATION.value,
            ProviderOperationKind.GENERATION.value,
            ProviderOperationKind.CONTINUATION.value,
        ]
        assert len({row["execution_id"] for row in starts}) == 1

    @pytest.mark.asyncio
    async def test_clean_eof_after_text_continues_with_overlap_trim(self):
        """A truncated text stream is continued and duplicate overlap is trimmed."""
        provider = _make_provider()
        request = _make_request()
        with (
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                side_effect=lambda **kwargs: AsyncStreamMock(
                    [_make_chunk(content="hello wor")]
                ),
            ),
            patch.object(
                _OpenAIChatStreamRunner,
                "_collect_recovery_output",
                new_callable=AsyncMock,
                return_value=_recovery_output(text="world"),
            ),
        ):
            events = await _collect_stream(provider, request)

        parsed = parse_sse_text("".join(events))
        text_deltas = [
            event.data.get("delta", {}).get("text", "")
            for event in parsed
            if event.event == "content_block_delta"
        ]
        assert text_deltas == ["hello wor", "ld"]
        assert "".join(text_deltas) == "hello world"
        assert sum(event.event == "message_start" for event in parsed) == 1
        assert sum(event.event == "content_block_start" for event in parsed) == 1
        assert sum(event.event == "content_block_stop" for event in parsed) == 1
        assert sum(event.event == "message_delta" for event in parsed) == 1
        assert sum(event.event == "message_stop" for event in parsed) == 1
        assert any(
            event.event == "message_delta"
            and event.data.get("delta", {}).get("stop_reason") == "end_turn"
            for event in parsed
        )
        assert not any(event.event == "error" for event in parsed)

    @pytest.mark.asyncio
    async def test_disabled_thinking_recovery_discards_reasoning(self):
        provider = _make_provider()
        request = _make_request()
        initial_stream = AsyncStreamMock([_make_chunk(content="hello")])
        recovery_stream = AsyncStreamMock(
            [
                _make_chunk(reasoning_content="hidden reasoning"),
                _make_chunk(content="hello world"),
                _make_chunk(finish_reason="stop"),
            ]
        )

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            side_effect=[initial_stream, recovery_stream],
        ):
            events = await _collect_stream(provider, request, reasoning=REASONING_OFF)

        parsed = parse_sse_text("".join(events))
        text = "".join(
            event.data.get("delta", {}).get("text", "")
            for event in parsed
            if event.event == "content_block_delta"
        )
        assert text == "hello world"
        assert "hidden reasoning" not in "".join(events)
        assert not any(
            event.data.get("delta", {}).get("type") == "thinking_delta"
            for event in parsed
        )

    @pytest.mark.asyncio
    async def test_recovery_collect_text_requires_finish_reason(self):
        """Recovery collectors reject truncated OpenAI-chat continuation streams."""
        streams = [
            ClosableAsyncStreamMock([_make_chunk(content=f"world {index}")])
            for index in range(UPSTREAM_TRANSIENT_TOTAL_ATTEMPTS)
        ]
        provider = _make_provider()
        runner = _make_stream_runner(provider)
        execution = provider._admission.start_execution()

        with (
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                side_effect=streams,
            ) as create,
            pytest.raises(TruncatedProviderStreamError),
        ):
            await runner._collect_recovery_output(
                {"model": "test-model", "messages": []},
                include_reasoning=True,
                request_recovery=RequestRecovery(execution),
                operation_kind=ProviderOperationKind.CONTINUATION,
            )

        assert create.await_count == UPSTREAM_TRANSIENT_TOTAL_ATTEMPTS
        assert all(stream.closed for stream in streams)

    @pytest.mark.asyncio
    async def test_recovery_collect_text_closes_retryable_failed_streams(self):
        """Recovery collectors close failed stream attempts before retrying."""
        streams = [
            ClosableAsyncStreamMock(
                [_make_chunk(content=f"partial {index}")],
                error=TimeoutError("recovery cutoff"),
            )
            for index in range(UPSTREAM_TRANSIENT_TOTAL_ATTEMPTS)
        ]
        provider = _make_provider()
        runner = _make_stream_runner(provider)
        execution = provider._admission.start_execution()

        with (
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                side_effect=streams,
            ) as create,
            pytest.raises(TimeoutError),
        ):
            await runner._collect_recovery_output(
                {"model": "test-model", "messages": []},
                include_reasoning=True,
                request_recovery=RequestRecovery(execution),
                operation_kind=ProviderOperationKind.CONTINUATION,
            )

        assert create.await_count == UPSTREAM_TRANSIENT_TOTAL_ATTEMPTS
        assert all(stream.closed for stream in streams)

    @pytest.mark.asyncio
    async def test_recovery_stream_reopen_retains_accepted_corrected_body(self):
        """Reopening one derived request reuses its accepted correction."""
        provider = _make_provider()
        runner = _make_stream_runner(provider)
        execution = provider._admission.start_execution()
        response = httpx2.Response(
            status_code=400,
            request=httpx2.Request("POST", "https://example.com/v1/chat/completions"),
        )
        usage_rejection = openai.BadRequestError(
            "stream_options is unsupported",
            response=response,
            body={"error": {"message": "stream_options is unsupported"}},
        )
        failed_stream = ClosableAsyncStreamMock(
            [_make_chunk(content="discarded")],
            error=httpx.ReadError("recovery cutoff"),
        )
        successful_stream = ClosableAsyncStreamMock(
            [_make_chunk(content="visible"), _make_chunk(finish_reason="stop")]
        )
        body = {
            "model": "test-model",
            "messages": [],
            "stream_options": {"include_usage": True},
        }

        with (
            patch.object(
                provider._chat,
                "_create_stream",
                new_callable=AsyncMock,
                wraps=provider._chat._create_stream,
            ) as create_stream,
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                side_effect=[usage_rejection, failed_stream, successful_stream],
            ) as create,
        ):
            recovered = await runner._collect_recovery_output(
                body,
                include_reasoning=True,
                request_recovery=RequestRecovery(execution),
                operation_kind=ProviderOperationKind.CONTINUATION,
            )

        assert create.await_count == 3
        assert create.await_args_list[0].kwargs["stream_options"] == {
            "include_usage": True
        }
        assert "stream_options" not in create.await_args_list[1].kwargs
        assert "stream_options" not in create.await_args_list[2].kwargs
        assert create_stream.await_count == 2
        assert (
            create_stream.await_args_list[0].kwargs["corrections"]
            is create_stream.await_args_list[1].kwargs["corrections"]
        )
        assert recovered.text == "visible"
        assert failed_stream.closed
        assert successful_stream.closed

    @pytest.mark.asyncio
    async def test_tool_repair_iterations_reuse_accepted_corrected_body(self):
        """Schema-repair retries reuse corrections accepted for that repair body."""
        provider = _make_provider()
        request = _make_request(
            tools=[
                {
                    "name": "echo_smoke",
                    "description": "Echo one message",
                    "input_schema": {
                        "type": "object",
                        "properties": {"message": {"type": "string"}},
                        "required": ["message"],
                        "additionalProperties": False,
                    },
                }
            ]
        )
        runner = _make_stream_runner(provider, request=request)
        assembler = runner._new_stream_assembler(output_reasoning=False)
        tuple(assembler.start_events())
        tuple(
            assembler.feed(
                _make_tool_calls_chunk(
                    name="echo_smoke",
                    arguments='{"message":',
                    tool_id="call_repair",
                )
            )
        )
        body = provider._chat._build_request_body(request)
        body["stream_options"] = {"include_usage": True}
        response = httpx2.Response(
            status_code=400,
            request=httpx2.Request("POST", "https://example.com/v1/chat/completions"),
        )
        usage_rejection = openai.BadRequestError(
            "stream_options is unsupported",
            response=response,
            body={"error": {"message": "stream_options is unsupported"}},
        )
        invalid_repair = ClosableAsyncStreamMock(
            [_make_chunk(content="123}"), _make_chunk(finish_reason="stop")]
        )
        valid_repair = ClosableAsyncStreamMock(
            [_make_chunk(content='"ok"}'), _make_chunk(finish_reason="stop")]
        )
        execution = provider._admission.start_execution()

        with (
            patch.object(
                provider._chat,
                "_create_stream",
                new_callable=AsyncMock,
                wraps=provider._chat._create_stream,
            ) as create_stream,
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                side_effect=[usage_rejection, invalid_repair, valid_repair],
            ) as create,
        ):
            events = await runner._repair_tool_args(
                body=body,
                output=assembler.output,
                tool_argument_alias_buffers=assembler.tool_argument_alias_buffers,
                request_recovery=RequestRecovery(execution),
            )

        assert events is not None
        assert create.await_count == 3
        assert create.await_args_list[0].kwargs["stream_options"] == {
            "include_usage": True
        }
        assert "stream_options" not in create.await_args_list[1].kwargs
        assert "stream_options" not in create.await_args_list[2].kwargs
        assert create_stream.await_count == 2
        assert (
            create_stream.await_args_list[0].kwargs["corrections"]
            is create_stream.await_args_list[1].kwargs["corrections"]
        )
        assert invalid_repair.closed
        assert valid_repair.closed

    @pytest.mark.asyncio
    async def test_recovery_collect_text_accepts_finish_reason(self):
        """Recovery collectors return text only after the upstream terminal marker."""
        stream = ClosableAsyncStreamMock(
            [
                _make_chunk(content="world"),
                _make_chunk(finish_reason="stop"),
            ]
        )
        provider = _make_provider()
        runner = _make_stream_runner(provider)
        execution = provider._admission.start_execution()

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            return_value=stream,
        ):
            result = await runner._collect_recovery_output(
                {"model": "test-model", "messages": []},
                include_reasoning=True,
                request_recovery=RequestRecovery(execution),
                operation_kind=ProviderOperationKind.CONTINUATION,
            )

        assert result.text == "world"
        assert result.thinking == ""
        assert result.tool_calls == ()
        assert stream.closed is True

    @pytest.mark.asyncio
    async def test_context_exhaustion_during_recovery_remains_terminal(self):
        """A recovery request cannot turn context exhaustion into success."""
        original = ClosableAsyncStreamMock(
            [_make_chunk(content="partial" + ("x" * 70_000))]
        )
        recovery = ClosableAsyncStreamMock(
            [
                _make_chunk(content="continued"),
                _make_chunk(finish_reason="model_context_window_exceeded"),
            ]
        )
        provider = _make_provider()

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            side_effect=[original, recovery],
        ):
            events, failure = await _collect_stream_and_error(
                provider,
                _make_request(),
            )

        assert failure.kind is FailureKind.CONTEXT_WINDOW_EXCEEDED
        assert failure.retryable is False
        assert not any(
            event.event == "message_stop" for event in parse_sse_text("".join(events))
        )
        assert original.closed is True
        assert recovery.closed is True

    @pytest.mark.asyncio
    async def test_context_error_opening_continuation_remains_terminal(self):
        """A derived continuation's SDK context error replaces the cutoff."""
        original = ClosableAsyncStreamMock(
            [_make_chunk(content="partial" + ("x" * 70_000))]
        )
        provider = _make_provider()

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            side_effect=[original, _make_context_length_bad_request()],
        ) as create:
            events, failure = await _collect_stream_and_error(
                provider,
                _make_request(),
            )

        assert create.await_count == 2
        assert failure.kind is FailureKind.CONTEXT_WINDOW_EXCEEDED
        assert failure.retryable is False
        assert not any(
            event.event == "message_stop" for event in parse_sse_text("".join(events))
        )
        assert original.closed is True

    @pytest.mark.asyncio
    async def test_context_error_opening_tool_repair_remains_terminal(self):
        """A derived tool repair's SDK context error replaces the truncation."""
        provider = _make_provider()
        request = _make_request(
            tools=[
                {
                    "name": "echo_smoke",
                    "description": "Echo",
                    "input_schema": {
                        "type": "object",
                        "properties": {"message": {"type": "string"}},
                        "required": ["message"],
                        "additionalProperties": False,
                    },
                }
            ]
        )
        original = ClosableAsyncStreamMock(
            [
                _make_tool_calls_chunk(
                    name="echo_smoke",
                    arguments='{"message":"' + ("x" * 70_000),
                    tool_id="call_repair",
                )
            ],
            error=httpx.ReadError("tool stream cutoff"),
        )

        with (
            patch.object(
                provider._chat,
                "_create_stream",
                new_callable=AsyncMock,
                wraps=provider._chat._create_stream,
            ) as create_stream,
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                side_effect=[original, _make_context_length_bad_request()],
            ) as create,
        ):
            events, failure = await _collect_stream_and_error(provider, request)

        assert create.await_count == 2
        assert [call.args[2] for call in create_stream.await_args_list] == [
            ProviderOperationKind.GENERATION,
            ProviderOperationKind.TOOL_REPAIR,
        ]
        assert failure.kind is FailureKind.CONTEXT_WINDOW_EXCEEDED
        assert failure.retryable is False
        assert not any(
            event.event == "message_stop" for event in parse_sse_text("".join(events))
        )
        assert original.closed is True

    @pytest.mark.asyncio
    async def test_recovery_close_failure_preserves_completed_output(self):
        """A failed stream close cannot replace completed recovery output."""
        stream = ClosableAsyncStreamMock(
            [
                _make_chunk(content="world"),
                _make_chunk(finish_reason="stop"),
            ],
            close_error=RuntimeError("cleanup failed"),
        )
        provider = _make_provider()
        runner = _make_stream_runner(provider, request_id="req_recovery_success")
        execution = provider._admission.start_execution(
            request_id="req_recovery_success"
        )

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            return_value=stream,
        ):
            result = await runner._collect_recovery_output(
                {"model": "test-model", "messages": []},
                include_reasoning=True,
                request_recovery=RequestRecovery(execution),
                operation_kind=ProviderOperationKind.CONTINUATION,
            )

        replacement = await execution.open_attempt(ProviderOperationKind.CONTINUATION)
        await replacement.aclose()
        assert result.text == "world"
        assert stream.close_calls == 1

    @pytest.mark.asyncio
    async def test_recovery_close_failure_does_not_block_retry(self):
        """Cleanup failure cannot replace a retryable recovery failure."""
        failed = ClosableAsyncStreamMock(
            [],
            error=TimeoutError("original retryable failure"),
            close_error=RuntimeError("cleanup failed"),
        )
        recovered = ClosableAsyncStreamMock(
            [
                _make_chunk(content="world"),
                _make_chunk(finish_reason="stop"),
            ]
        )
        provider = _make_provider()
        runner = _make_stream_runner(provider)
        execution = provider._admission.start_execution()

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            side_effect=[failed, recovered],
        ) as create:
            result = await runner._collect_recovery_output(
                {"model": "test-model", "messages": []},
                include_reasoning=True,
                request_recovery=RequestRecovery(execution),
                operation_kind=ProviderOperationKind.CONTINUATION,
            )

        assert result.text == "world"
        assert create.await_count == 2
        assert failed.close_calls == 1
        assert recovered.close_calls == 1

    @pytest.mark.asyncio
    async def test_recovery_close_failure_preserves_terminal_failure(self):
        """Cleanup failure cannot mask a non-retryable recovery failure."""
        stream = ClosableAsyncStreamMock(
            [],
            error=ValueError("original terminal failure"),
            close_error=RuntimeError("cleanup failed"),
        )
        provider = _make_provider()
        runner = _make_stream_runner(provider)
        execution = provider._admission.start_execution()

        with (
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                return_value=stream,
            ),
            pytest.raises(ValueError, match="original terminal failure"),
        ):
            await runner._collect_recovery_output(
                {"model": "test-model", "messages": []},
                include_reasoning=True,
                request_recovery=RequestRecovery(execution),
                operation_kind=ProviderOperationKind.CONTINUATION,
            )

        assert stream.close_calls == 1

    @pytest.mark.asyncio
    async def test_recovery_close_failure_preserves_cancellation(self):
        """Cleanup failure cannot turn caller cancellation into a provider error."""
        stream = BlockingClosableAsyncStreamMock(
            close_error=RuntimeError("cleanup failed")
        )
        provider = _make_provider()
        runner = _make_stream_runner(provider)
        execution = provider._admission.start_execution()

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            return_value=stream,
        ):
            task = asyncio.create_task(
                runner._collect_recovery_output(
                    {"model": "test-model", "messages": []},
                    include_reasoning=True,
                    request_recovery=RequestRecovery(execution),
                    operation_kind=ProviderOperationKind.CONTINUATION,
                )
            )
            await asyncio.wait_for(stream.entered.wait(), timeout=1)
            task.cancel()
            with pytest.raises(asyncio.CancelledError):
                await task

        replacement = await execution.open_attempt(ProviderOperationKind.CONTINUATION)
        await replacement.aclose()
        assert stream.close_calls == 1

    @pytest.mark.asyncio
    async def test_recovery_collect_text_honors_provider_retry_classification(self):
        """Provider semantics apply before the first recovery chunk as well."""
        provider = _make_provider()
        runner = _make_stream_runner(provider)
        execution = provider._admission.start_execution()
        request = httpx2.Request(
            "POST", "https://test.api.nvidia.com/v1/chat/completions"
        )
        degraded = openai.BadRequestError(
            "Bad Request",
            response=httpx2.Response(400, request=request),
            body={
                "status": 400,
                "detail": (
                    "Function id 'test-function': DEGRADED function cannot be invoked"
                ),
            },
        )
        rejected = ClosableAsyncStreamMock([], error=degraded)
        recovered = ClosableAsyncStreamMock(
            [
                _make_chunk(content="world"),
                _make_chunk(finish_reason="stop"),
            ]
        )

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            side_effect=[rejected, recovered],
        ) as create:
            result = await runner._collect_recovery_output(
                {"model": "test-model", "messages": []},
                include_reasoning=True,
                request_recovery=RequestRecovery(execution),
                operation_kind=ProviderOperationKind.CONTINUATION,
            )

        assert result.text == "world"
        assert result.thinking == ""
        assert result.tool_calls == ()
        assert create.await_count == 2
        assert rejected.closed
        assert recovered.closed

    def test_text_recovery_body_preserves_thinking_context(self):
        """Continuation prompts include emitted thinking without provider-specific fields."""
        body = {
            "messages": [{"role": "user", "content": "hello"}],
            "tools": [{"name": "Read"}],
            "tool_choice": {"type": "auto"},
        }

        recovery_body = make_text_recovery_body(
            body,
            partial_text="visible answer",
            partial_thinking="hidden reasoning",
        )

        assert "tools" not in recovery_body
        assert "tool_choice" not in recovery_body
        assert "stream" not in recovery_body
        assert recovery_body["messages"][-2] == {
            "role": "assistant",
            "content": "visible answer",
        }
        recovery_prompt = recovery_body["messages"][-1]
        assert recovery_prompt["role"] == "user"
        assert "hidden reasoning" in recovery_prompt["content"]
        assert "reasoning_content" not in recovery_prompt

    def test_tool_protocol_recovery_body_retains_tool_contract(self):
        body = {
            "messages": [{"role": "user", "content": "hello"}],
            "tools": [{"type": "function", "function": {"name": "Read"}}],
            "tool_choice": {"type": "function", "function": {"name": "Read"}},
        }

        recovery_body = make_response_recovery_body(body, "visible answer")

        assert recovery_body["tools"] == body["tools"]
        assert recovery_body["tool_choice"] == body["tool_choice"]
        assert recovery_body["messages"][-2] == {
            "role": "assistant",
            "content": "visible answer",
        }

    @pytest.mark.asyncio
    async def test_openai_text_recovery_passes_thinking_context(self):
        """OpenAI-chat recovery call sites seed emitted thinking in the prompt."""
        runner = _make_stream_runner(
            _make_provider(), request=_make_request(), request_id="req_recovery"
        )
        assembler = runner._new_stream_assembler(output_reasoning=True)
        output = assembler.output
        output.ensure_reasoning_block()
        output.emit_reasoning_delta("hidden reasoning")
        output.ensure_text_block()
        output.emit_text_delta("visible answer")

        with patch.object(
            runner,
            "_collect_recovery_output",
            new_callable=AsyncMock,
            return_value=_recovery_output(
                text="visible answer done",
                thinking="hidden reasoning more",
            ),
        ) as mock_collect:
            execution = runner._transport._admission.start_execution()
            events = await runner._recovery_events(
                body={"messages": [{"role": "user", "content": "hello"}]},
                assembler=assembler,
                error=TimeoutError("cutoff"),
                tool_argument_alias_buffers={},
                output_reasoning=True,
                request_recovery=RequestRecovery(execution),
            )

        assert events is not None
        assert mock_collect.await_args is not None
        recovery_body = mock_collect.await_args.args[0]
        assert "hidden reasoning" in recovery_body["messages"][-1]["content"]
        assert mock_collect.await_args.kwargs["include_reasoning"] is True

    @pytest.mark.asyncio
    async def test_primary_stream_closes_when_iteration_fails(self):
        """OpenAI-chat main streams close after iterator failures."""
        provider = _make_provider()
        request = _make_request()
        stream = ClosableAsyncStreamMock(
            [_make_chunk(content="partial")],
            error=ValueError("provider stream failed"),
        )

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            return_value=stream,
        ):
            error = await _collect_stream_error(provider, request)

        assert stream.closed is True
        assert "provider stream failed" in error.message.lower()

    @pytest.mark.asyncio
    async def test_truncated_recovery_stream_closes_block_then_raises(self):
        """Partial recovery bytes never become success or provider-owned wire errors."""
        provider = _make_provider()
        request = _make_request()
        original_text = "hello wor" + ("x" * 70_000)
        original_stream = AsyncStreamMock([_make_chunk(content=original_text)])

        with (
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                return_value=original_stream,
            ) as mock_create,
            patch.object(
                _OpenAIChatStreamRunner,
                "_collect_recovery_output",
                new_callable=AsyncMock,
                side_effect=TruncatedProviderStreamError(
                    "Recovery stream ended without finish_reason."
                ),
            ) as mock_collect,
        ):
            events, error = await _collect_stream_and_error(provider, request)

        event_text = "".join(events)
        assert mock_create.await_count == 1
        assert mock_collect.await_count == 1
        assert original_text in event_text
        assert "world" not in event_text
        assert "Provider stream ended without finish_reason." in error.message
        assert "Provider stream ended without finish_reason." not in event_text
        parsed = parse_sse_text(event_text)
        assert parsed[-1].event == "content_block_stop"
        assert not any(event.event == "error" for event in parsed)
        assert not any(event.event == "message_stop" for event in parsed)
        assert not any(
            event.event == "content_block_delta"
            and event.data.get("delta", {}).get("text") == "ld"
            for event in parse_sse_text(event_text)
        )

    @pytest.mark.asyncio
    @pytest.mark.parametrize("tool_name", ["echo_smoke", "Task"])
    async def test_incomplete_tool_call_repair_appends_schema_valid_suffix(
        self, tool_name
    ):
        """A truncated tool JSON prefix is repaired append-only before tool_use tail."""
        provider = _make_provider()
        request = _make_request(
            tools=[
                {
                    "name": tool_name,
                    "description": "Echo",
                    "input_schema": {
                        "type": "object",
                        "properties": {
                            "message": {"type": "string"},
                            "run_in_background": {"type": "boolean"},
                        },
                        "required": ["message"],
                        "additionalProperties": False,
                    },
                }
            ]
        )
        tool_chunk = _make_tool_calls_chunk(
            name=tool_name,
            arguments='{"run_in_background":true,"message":',
            tool_id="call_repair",
        )
        with (
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                side_effect=lambda **kwargs: AsyncStreamMock([tool_chunk]),
            ),
            patch.object(
                _OpenAIChatStreamRunner,
                "_collect_recovery_output",
                new_callable=AsyncMock,
                return_value=_recovery_output(text='"ok"}'),
            ),
        ):
            events = await _collect_stream(provider, request)

        event_text = "".join(events)
        parsed = parse_sse_text(event_text)
        assert '"partial_json": "\\"ok\\"}"' in event_text
        assert any(
            event.event == "message_delta"
            and event.data.get("delta", {}).get("stop_reason") == "tool_use"
            for event in parsed
        )
        assert not any(event.event == "error" for event in parsed)
        arguments = [
            event.data["delta"]["partial_json"]
            for event in parsed
            if event.data.get("delta", {}).get("type") == "input_json_delta"
        ]
        assert arguments == ['{"run_in_background":true,"message":', '"ok"}']

    @pytest.mark.asyncio
    async def test_stream_rate_limit_uses_the_execution_retry_session(self):
        """A create-time 429 consumes one attempt before a successful retry."""
        provider = _make_provider()
        request = _make_request()

        chunk1 = _make_chunk(content="Response")
        chunk2 = _make_chunk(finish_reason="stop")
        stream_mock = AsyncStreamMock([chunk1, chunk2])

        response = httpx.Response(
            429,
            request=httpx.Request(
                "POST", "https://test.api.nvidia.com/v1/chat/completions"
            ),
        )
        error = httpx.HTTPStatusError(
            "rate limited",
            request=response.request,
            response=response,
        )

        with patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            side_effect=[error, stream_mock],
        ) as create:
            events = await _collect_stream(provider, request)

        event_text = "".join(events)
        assert create.await_count == 2
        assert "Response" in event_text


class TestProcessToolCall:
    """Tests for OpenAI tool-call assembly."""

    def test_tool_call_with_id(self):
        """Tool call with id starts a tool block."""
        provider = _make_provider()
        sse = _make_anthropic_output()
        tc = {
            "index": 0,
            "id": "call_123",
            "function": {"name": "search", "arguments": '{"q": "test"}'},
        }
        events = list(_make_tool_assembler(provider).process_tool_call(tc, sse))
        assert _tool_use_starts(events) == [
            {
                "type": "tool_use",
                "id": "call_123",
                "name": "search",
                "input": {},
            }
        ]

    @pytest.mark.parametrize("missing_id", [None, "", "   "])
    def test_missing_or_blank_tool_call_id_generates_public_id(self, missing_id):
        """An absent identity never escapes as an empty Anthropic tool-use ID."""
        provider = _make_provider()
        sse = _make_anthropic_output()

        events = list(
            _make_tool_assembler(provider).process_tool_call(
                {
                    "index": 0,
                    "id": missing_id,
                    "function": {"name": "Bash", "arguments": "{}"},
                },
                sse,
            )
        )

        [start] = _tool_use_starts(events)
        assert start["id"].startswith("tool_")

    def test_historical_tool_call_id_collision_is_remapped(self):
        """A later turn cannot reuse a tool identity already visible in history."""
        provider = _make_provider()
        request = _make_request(
            messages=[
                {"role": "user", "content": "Run it once."},
                {
                    "role": "assistant",
                    "content": [
                        {
                            "type": "tool_use",
                            "id": "Bash:0",
                            "name": "Bash",
                            "input": {"command": "printf first"},
                        }
                    ],
                },
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": "Bash:0",
                            "content": "first",
                        }
                    ],
                },
            ]
        )
        sse = _make_anthropic_output()

        events = list(
            _make_tool_assembler(provider, request=request).process_tool_call(
                {
                    "index": 0,
                    "id": "Bash:0",
                    "function": {
                        "name": "Bash",
                        "arguments": '{"command":"printf second"}',
                    },
                },
                sse,
            )
        )

        [start] = _tool_use_starts(events)
        assert start["id"].startswith("tool_")
        assert start["id"] != "Bash:0"

    def test_current_response_tool_call_id_collision_is_remapped(self):
        """Two simultaneous calls cannot expose the same public identity."""
        provider = _make_provider()
        sse = _make_anthropic_output()
        assembler = _make_tool_assembler(provider)

        first = list(
            assembler.process_tool_call(
                {
                    "index": 0,
                    "id": "Bash:0",
                    "function": {"name": "Bash", "arguments": "{}"},
                },
                sse,
            )
        )
        second = list(
            assembler.process_tool_call(
                {
                    "index": 1,
                    "id": "Bash:0",
                    "function": {"name": "Bash", "arguments": "{}"},
                },
                sse,
            )
        )

        starts = _tool_use_starts(first + second)
        assert starts[0]["id"] == "Bash:0"
        assert starts[1]["id"].startswith("tool_")
        assert starts[1]["id"] != starts[0]["id"]

    def test_structured_tool_call_restores_portable_wire_alias(self):
        """A wire alias never escapes in the Anthropic tool block."""
        provider = _make_provider()
        original = "mcp__portable_output__" + "x" * 70
        request = _make_request(
            tools=[{"name": original, "input_schema": {"type": "object"}}]
        )
        codec = OpenAIToolNameCodec.from_request(request)
        alias = codec.encode(original)
        sse = _make_anthropic_output()

        events = list(
            _make_tool_assembler(provider).process_tool_call(
                {
                    "index": 0,
                    "id": "call_alias",
                    "function": {"name": alias, "arguments": "{}"},
                },
                sse,
                tool_names=codec,
                tool_name_buffers={},
            )
        )

        event_text = "".join(events)
        assert original in event_text
        assert alias not in event_text
        assert (
            sum(
                event.event == "content_block_start"
                for event in parse_sse_text(event_text)
            )
            == 1
        )

    def test_tool_name_restores_before_nim_argument_alias_lookup(self):
        """Generic name decoding composes with original-name NIM arg metadata."""
        provider = _make_provider()
        original = "mcp__nim_argument_composition__" + "x" * 70
        request = _make_request(
            tools=[
                {
                    "name": original,
                    "input_schema": {
                        "type": "object",
                        "properties": {"type": {"type": "string"}},
                        "required": ["type"],
                    },
                }
            ]
        )
        codec = OpenAIToolNameCodec.from_request(request)
        sse = _make_anthropic_output()

        events = list(
            _make_tool_assembler(provider).process_tool_call(
                {
                    "index": 0,
                    "id": "call_composed",
                    "function": {
                        "name": codec.encode(original),
                        "arguments": '{"_fcc_arg_type":"file"}',
                    },
                },
                sse,
                tool_names=codec,
                tool_name_buffers={},
                tool_argument_aliases={original: {"_fcc_arg_type": "type"}},
                tool_argument_alias_buffers={},
            )
        )

        parsed = parse_sse_text("".join(events))
        start = next(
            event.data["content_block"]
            for event in parsed
            if event.event == "content_block_start"
        )
        argument_delta = next(
            event.data["delta"]["partial_json"]
            for event in parsed
            if event.event == "content_block_delta"
        )
        assert start["name"] == original
        assert json.loads(argument_delta) == {"type": "file"}

    def test_fragmented_wire_alias_starts_one_original_tool_block(self):
        """A split alias is held until the exact request alias is complete."""
        provider = _make_provider()
        original = "mcp__fragmented_output__" + "x" * 70
        request = _make_request(
            tools=[{"name": original, "input_schema": {"type": "object"}}]
        )
        codec = OpenAIToolNameCodec.from_request(request)
        alias = codec.encode(original)
        split = len(alias) // 2
        buffers: dict[int, str] = {}
        sse = _make_anthropic_output()
        assembler = _make_tool_assembler(provider)

        first = list(
            assembler.process_tool_call(
                {
                    "index": 0,
                    "id": "call_split_alias",
                    "function": {"name": alias[:split], "arguments": ""},
                },
                sse,
                tool_names=codec,
                tool_name_buffers=buffers,
            )
        )
        second = list(
            assembler.process_tool_call(
                {
                    "index": 0,
                    "id": None,
                    "function": {"name": alias[split:], "arguments": "{}"},
                },
                sse,
                tool_names=codec,
                tool_name_buffers=buffers,
            )
        )

        assert first == []
        event_text = "".join(second)
        assert original in event_text
        assert alias not in event_text
        assert (
            sum(
                event.event == "content_block_start"
                for event in parse_sse_text(event_text)
            )
            == 1
        )
        assert buffers == {}

    def test_valid_name_that_prefixes_alias_is_resolved_on_flush(self):
        """An ambiguous valid name is delayed, not mistaken for an alias fragment."""
        provider = _make_provider()
        original = "tool"
        long_name = "tool." + "x" * 70
        request = _make_request(
            tools=[
                {"name": original, "input_schema": {"type": "object"}},
                {"name": long_name, "input_schema": {"type": "object"}},
            ]
        )
        codec = OpenAIToolNameCodec.from_request(request)
        assert codec.is_alias_prefix(original)
        buffers: dict[int, str] = {}
        sse = _make_anthropic_output()
        assembler = _make_tool_assembler(provider)

        initial = list(
            assembler.process_tool_call(
                {
                    "index": 0,
                    "id": "call_valid",
                    "function": {"name": original, "arguments": "{}"},
                },
                sse,
                tool_names=codec,
                tool_name_buffers=buffers,
            )
        )
        flushed = list(
            assembler.flush_tool_name_buffers(
                sse,
                tool_names=codec,
                tool_name_buffers=buffers,
                tool_argument_aliases={},
                tool_argument_alias_buffers={},
            )
        )

        assert initial == []
        assert original in "".join(flushed)
        assert buffers == {}

    def test_buffered_collector_decodes_before_schema_validation(self):
        """Recovery validates the original tool identity, not its wire alias."""
        original = "mcp__recovery_output__" + "x" * 70
        request = _make_request(
            tools=[{"name": original, "input_schema": {"type": "object"}}]
        )
        codec = OpenAIToolNameCodec.from_request(request)
        collector = OpenAIToolCallCollector()
        collector.add(
            SimpleNamespace(
                index=0,
                id="call_recovered",
                function=SimpleNamespace(name=codec.encode(original), arguments="{}"),
            )
        )

        calls = collector.completed_calls(
            tool_schemas_by_name(request), tool_names=codec
        )

        assert calls is not None
        assert calls[0]["function"]["name"] == original

    def test_tool_call_id_arrives_before_name_still_emits_id_and_name(self):
        """Split-stream tool: id (no name) then name then args; id preserved on start."""
        provider = _make_provider()
        sse = _make_anthropic_output()
        t1 = {
            "index": 0,
            "id": "call_split",
            "function": {"name": None, "arguments": ""},
        }
        t2 = {
            "index": 0,
            "id": "call_split",
            "function": {"name": "Grep", "arguments": ""},
        }
        t3 = {
            "index": 0,
            "id": "call_split",
            "function": {"name": None, "arguments": "{}"},
        }
        assembler = _make_tool_assembler(provider)
        b1 = "".join(assembler.process_tool_call(t1, sse))
        b2 = "".join(assembler.process_tool_call(t2, sse))
        b3 = "".join(assembler.process_tool_call(t3, sse))
        combined = b1 + b2 + b3
        assert "call_split" in combined
        assert "Grep" in combined
        assert b1 == ""

    def test_tool_call_arguments_buffered_until_name(self):
        """Argument deltas before tool name are emitted after the block starts."""
        provider = _make_provider()
        sse = _make_anthropic_output()
        t1 = {
            "index": 0,
            "id": "call_buf",
            "function": {"name": None, "arguments": '{"x":'},
        }
        t2 = {
            "index": 0,
            "id": "call_buf",
            "function": {"name": "Read", "arguments": "1}"},
        }
        assembler = _make_tool_assembler(provider)
        b1 = "".join(assembler.process_tool_call(t1, sse))
        b2 = "".join(assembler.process_tool_call(t2, sse))
        assert b1 == ""
        combined = b2
        assert "Read" in combined
        assert "call_buf" in combined
        assert '{"x":' in combined or "partial_json" in combined

    def test_late_upstream_id_cannot_overwrite_started_public_id(self):
        """The identity emitted at block start stays authoritative."""
        provider = _make_provider()
        sse = _make_anthropic_output()
        assembler = _make_tool_assembler(provider)

        initial = list(
            assembler.process_tool_call(
                {
                    "index": 0,
                    "id": None,
                    "function": {"name": "Bash", "arguments": "{}"},
                },
                sse,
            )
        )
        [start] = _tool_use_starts(initial)
        generated_id = start["id"]

        later = list(
            assembler.process_tool_call(
                {
                    "index": 0,
                    "id": "late_upstream_id",
                    "function": {"name": None, "arguments": ""},
                },
                sse,
            )
        )

        assert later == []
        assert sse.tool_states[0].tool_id == generated_id

    def test_task_tool_preserves_background_true(self):
        """Task tool preserves run_in_background=true."""
        provider = _make_provider()
        sse = _make_anthropic_output()
        args = json.dumps({"run_in_background": True, "prompt": "test"})
        tc = {
            "index": 0,
            "id": "call_task",
            "function": {"name": "Task", "arguments": args},
        }
        events = list(_make_tool_assembler(provider).process_tool_call(tc, sse))
        event_text = "".join(events)
        assert sse.tool_states[0].content == args
        assert "true" in event_text.lower()

    def test_task_tool_streams_chunked_args(self):
        """Chunked Task args stream without changing the requested execution mode."""
        provider = _make_provider()
        sse = _make_anthropic_output()
        tc1 = {
            "index": 0,
            "id": "call_task_chunked",
            "function": {"name": "Task", "arguments": '{"run_in_background": true,'},
        }
        tc2 = {
            "index": 0,
            "id": "call_task_chunked",
            "function": {"name": None, "arguments": ' "prompt": "test"}'},
        }

        assembler = _make_tool_assembler(provider)
        events1 = list(assembler.process_tool_call(tc1, sse))
        assert len(events1) > 0
        assert sse.tool_states[0].content == tc1["function"]["arguments"]

        events2 = list(assembler.process_tool_call(tc2, sse))
        event_text = "".join(events1 + events2)
        assert "true" in event_text.lower()
        assert json.loads(sse.tool_states[0].content) == {
            "run_in_background": True,
            "prompt": "test",
        }

    def test_task_tool_invalid_json_is_not_replaced(self):
        """Invalid Task arguments remain available to generic validation and repair."""
        provider = _make_provider()
        sse = _make_anthropic_output()
        tc = {
            "index": 0,
            "id": "call_task2",
            "function": {"name": "Task", "arguments": "not json"},
        }
        assembler = _make_tool_assembler(provider)
        events = list(assembler.process_tool_call(tc, sse))
        assert len(events) > 0

        assert sse.tool_states[0].content == "not json"

    def test_negative_tool_index_fallback(self):
        """tc_index < 0 uses len(tool_indices) as fallback."""
        provider = _make_provider()
        sse = _make_anthropic_output()
        tc = {
            "index": -1,
            "id": "call_neg",
            "function": {"name": "test", "arguments": "{}"},
        }
        events = list(_make_tool_assembler(provider).process_tool_call(tc, sse))
        # Should not crash, should still emit events
        assert len(events) > 0

    def test_none_tool_index_defaults_to_zero(self):
        """Gemini may stream tool_call deltas with a null index."""
        provider = _make_provider()
        sse = _make_anthropic_output()
        tc = {
            "index": None,
            "id": "call_none",
            "function": {"name": "test", "arguments": "{}"},
        }
        events = list(_make_tool_assembler(provider).process_tool_call(tc, sse))
        event_text = "".join(events)

        assert "tool_use" in event_text
        assert "call_none" in event_text

    def test_tool_args_emitted_as_delta(self):
        """Arguments are emitted as input_json_delta events."""
        provider = _make_provider()
        sse = _make_anthropic_output()
        tc = {
            "index": 0,
            "id": "call_args",
            "function": {"name": "grep", "arguments": '{"pattern": "test"}'},
        }
        events = list(_make_tool_assembler(provider).process_tool_call(tc, sse))
        event_text = "".join(events)
        assert "input_json_delta" in event_text


class TestStreamChunkEdgeCases:
    """Tests for edge cases in stream chunk handling."""

    @pytest.mark.asyncio
    async def test_stream_chunk_with_empty_choices_skipped(self):
        """Chunk with choices=[] is skipped without crashing."""
        provider = _make_provider()
        request = _make_request()

        empty_choices_chunk = MagicMock()
        empty_choices_chunk.choices = []
        empty_choices_chunk.usage = None

        finish_chunk = _make_chunk(finish_reason="stop")
        stream_mock = AsyncStreamMock([empty_choices_chunk, finish_chunk])

        with (
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                return_value=stream_mock,
            ),
        ):
            events = await _collect_stream(provider, request)

        event_text = "".join(events)
        assert "message_start" in event_text
        assert "message_stop" in event_text

    @pytest.mark.asyncio
    async def test_stream_chunk_with_none_delta_handled(self):
        """Chunk with choice.delta=None is handled defensively."""
        provider = _make_provider()
        request = _make_request()

        none_delta_chunk = MagicMock()
        none_delta_chunk.usage = None
        choice = MagicMock()
        choice.delta = None
        choice.finish_reason = None
        none_delta_chunk.choices = [choice]

        finish_chunk = _make_chunk(finish_reason="stop")
        stream_mock = AsyncStreamMock([none_delta_chunk, finish_chunk])

        with (
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                return_value=stream_mock,
            ),
        ):
            events = await _collect_stream(provider, request)

        event_text = "".join(events)
        assert "message_start" in event_text
        assert "message_stop" in event_text

    @pytest.mark.asyncio
    async def test_stream_generator_cleanup_on_exception(self):
        """When stream raises mid-iteration, message_stop still emitted."""
        provider = _make_provider()
        request = _make_request()

        chunk1 = _make_chunk(content="Partial")
        stream_mock = AsyncStreamMock(
            [chunk1], error=ConnectionResetError("Connection reset")
        )

        with (
            patch.object(
                provider._client.chat.completions,
                "create",
                new_callable=AsyncMock,
                return_value=stream_mock,
            ),
        ):
            error = await _collect_stream_error(provider, request)

        assert "Connection reset" in error.message

    def test_stream_malformed_tool_args_chunked(self):
        """Malformed chunks are retained without a Task-specific fallback."""
        provider = _make_provider()
        sse = _make_anthropic_output()
        tc1 = {
            "index": 0,
            "id": "call_malformed",
            "function": {"name": "Task", "arguments": '{"broken":'},
        }
        tc2 = {
            "index": 0,
            "id": "call_malformed",
            "function": {"name": None, "arguments": " never valid }"},
        }

        assembler = _make_tool_assembler(provider)
        events1 = list(assembler.process_tool_call(tc1, sse))
        events2 = list(assembler.process_tool_call(tc2, sse))
        event_text = "".join(events1 + events2)
        assert "tool_use" in event_text
        assert sse.tool_states[0].content == '{"broken": never valid }'


@pytest.mark.asyncio
async def test_openai_compat_stream_ends_with_contract_when_tool_name_never_arrives() -> (
    None
):
    """Nameless / incomplete tool-call buffer must not break Anthropic stream contract."""
    provider = _make_provider()
    request = _make_request()
    tc0 = SimpleNamespace(
        index=0,
        id="call_inc",
        function=SimpleNamespace(name=None, arguments="{}"),
    )
    stream_mock = AsyncStreamMock([_make_chunk(tool_calls=[tc0])])
    with (
        patch.object(
            provider._client.chat.completions,
            "create",
            new_callable=AsyncMock,
            return_value=stream_mock,
        ),
    ):
        error = await _collect_stream_error(provider, request)

    assert "Provider stream ended without finish_reason." in error.message


@pytest.mark.asyncio
@pytest.mark.parametrize("collector", [False, True])
async def test_tool_argument_mapping_survives_correction_then_stream_reopen(collector):
    request = _alias_request()

    def responder(bodies):
        if len(bodies) == 1:
            return 400, {"message": "chat_template is unsupported"}
        if len(bodies) == 2:
            template = _events_for("chat")[0]
            return 200, [
                {
                    **template,
                    "choices": [
                        {
                            "index": 0,
                            "delta": {"content": "discarded"},
                            "finish_reason": None,
                        }
                    ],
                }
            ]
        return 200, _alias_events()

    async with _harness("chat", responder, chat_provider_factory=_alias_provider) as (
        _,
        bodies,
        provider,
    ):
        if collector:
            runner = _make_stream_runner(provider, request=request)
            execution = provider._admission.start_execution()
            try:
                recovered = await runner._collect_recovery_output(
                    runner._body,
                    include_reasoning=False,
                    request_recovery=RequestRecovery(execution),
                    operation_kind=ProviderOperationKind.CONTINUATION,
                )
                arguments = json.loads(recovered.tool_calls[0]["function"]["arguments"])
            finally:
                execution.abandon()
        else:
            saved = await _saved_reply(provider.stream_messages(request), "messages")
            call = next(
                block for block in saved[0]["content"] if block["type"] == "tool_use"
            )
            arguments = call["input"]
        assert arguments == {"pattern": "needle", "type": "py"}
        assert len(bodies) == 3
        assert all("chat_template" not in body for body in bodies[1:])
        assert all("_fcc_nim_tool_argument_aliases" not in body for body in bodies)