@@ -31,6 +31,7 @@
 from pydantic_ai import UnexpectedModelBehavior
 from pydantic_ai._run_context import RunContext
 from pydantic_ai._utils import PeekableAsyncStream, Unset, number_to_datetime
+from pydantic_ai.exceptions import ModelHTTPError
 from pydantic_ai.messages import ModelMessage, ModelResponse
 from pydantic_ai.models import (
     ModelRequestParameters,
@@ -150,12 +151,27 @@ def __aiter__(self) -> AsyncIterator[responses.ResponseStreamEvent]:
     async def _filtered_iter(
         self,
     ) -> AsyncIterator[responses.ResponseStreamEvent]:
-        """Yield events, buffering early argument deltas until their item is announced."""
+        """Yield events, buffering early argument deltas until their item is announced.
+
+        Raises:
+            ModelHTTPError: When OGX reports the request as failed.
+        """
         async for event in self._source:
             if self._on_completed is not None and isinstance(
                 event, responses.ResponseCompletedEvent
             ):
                 self._on_completed(event.response)
+            if isinstance(event, responses.ResponseFailedEvent):
+                # OGX reports a provider failure of a streamed request in-band
+                # (HTTP 200); the non-streamed call raises an HTTP error with
+                # the same message. Raise here too, or pydantic-ai takes the
+                # empty response for a missing answer and asks the model again.
+                error = event.response.error
+                raise ModelHTTPError(
+                    status_code=500,
+                    model_name=event.response.model,
+                    body=error.model_dump() if error is not None else None,
+                )
             if isinstance(event, responses.ResponseOutputItemAddedEvent):
                 if (
                     isinstance(event.item, responses.ResponseFunctionToolCall)
 
@@ -1,6 +1,6 @@
 """Unit tests for pydantic_ai_lightspeed.ogx._model module."""
 
-# pylint: disable=protected-access,too-few-public-methods
+# pylint: disable=protected-access,too-few-public-methods,too-many-lines
 
 from collections.abc import AsyncIterator
 from typing import Any
@@ -11,7 +11,8 @@
     OpenAIResponseReasoning,
 )
 from openai.types import responses
-from pydantic_ai import ModelMessage, UnexpectedModelBehavior
+from pydantic_ai import Agent, ModelMessage, UnexpectedModelBehavior
+from pydantic_ai.exceptions import ModelHTTPError
 from pydantic_ai.messages import ModelResponse
 from pydantic_ai.models.openai import (
     OpenAIResponsesModel,
@@ -21,13 +22,16 @@
 from pydantic_ai.settings import ModelSettings
 from pytest_mock import MockerFixture
 
+from models.api.responses.error import PromptTooLongResponse
 from models.common.responses.responses_api_params import ResponsesApiParams
+from pydantic_ai_lightspeed.ogx import OgxProvider
 from pydantic_ai_lightspeed.ogx._model import (
     _LLS_RESPONSES_EXTRA_FIELDS,
     OgxResponsesModel,
     _FilteredResponseStream,
     _model_settings_from_responses_params,
 )
+from utils.agents.error_handler import map_agent_inference_error
 
 _REQUIRED_PARAMS = {
     "input": "hello",
@@ -37,6 +41,12 @@
     "stream": True,
 }
 
+# What OpenAI answers a prompt that is too long with; OGX passes the message on.
+_CONTEXT_LENGTH_MESSAGE = (
+    "This model's maximum context length is 128000 tokens. However, your "
+    "messages resulted in 153021 tokens. Please reduce the length of the messages."
+)
+
 
 def _make_params(**overrides: object) -> ResponsesApiParams:
     """Build a ``ResponsesApiParams`` with required fields plus overrides."""
@@ -550,6 +560,20 @@ def _make_response_created_event() -> responses.ResponseCreatedEvent:
     )
 
 
+def _make_response_failed_event(message: str) -> responses.ResponseFailedEvent:
+    """Build the event OGX ends a streamed request with when the provider fails."""
+    return responses.ResponseFailedEvent(
+        response=_make_response_created_event().response.model_copy(
+            update={
+                "status": "failed",
+                "error": responses.ResponseError(code="server_error", message=message),
+            }
+        ),
+        sequence_number=1,
+        type="response.failed",
+    )
+
+
 class TestRequestStream:
     """Tests for OgxResponsesModel.request_stream."""
 
@@ -670,6 +694,75 @@ async def test_happy_path_yields_streamed_response(
         async with model.request_stream([mocker.Mock()], {}, mocker.Mock()) as streamed:
             assert isinstance(streamed, OpenAIResponsesStreamedResponse)
 
+    @pytest.mark.asyncio
+    async def test_failed_response_raises_the_provider_error(
+        self, model: OgxResponsesModel, mocker: MockerFixture
+    ) -> None:
+        """Test that a request OGX reports as failed in the stream is a model error.
+
+        OGX answers a streamed request with HTTP 200 and reports a provider
+        failure as a ``response.failed`` event. Passed on, pydantic-ai takes
+        the empty response for a missing answer and asks the model again.
+        """
+        events = [
+            _make_response_created_event(),
+            _make_response_failed_event(_CONTEXT_LENGTH_MESSAGE),
+        ]
+        model._responses_create = mocker.AsyncMock(
+            return_value=_make_mock_response_stream(mocker, events)
+        )
+
+        with pytest.raises(ModelHTTPError, match="maximum context length") as exc_info:
+            async with model.request_stream(
+                [mocker.Mock()], {}, mocker.Mock()
+            ) as streamed:
+                async for _ in streamed:
+                    pass
+
+        assert exc_info.value.status_code == 500
+
+
+class TestAgentRunOverFailedStream:
+    """Tests for an agent run whose streamed model request OGX reports as failed."""
+
+    @pytest.mark.asyncio
+    async def test_run_ends_after_one_request_as_prompt_too_long(
+        self, mocker: MockerFixture
+    ) -> None:
+        """Test that the run ends with the provider error, without a retry.
+
+        Without the error pydantic-ai sends a second request that carries a
+        retry prompt, and its reply is streamed as the answer (LCORE-4070).
+        A context-length failure maps to 413.
+        """
+        model = OgxResponsesModel(
+            "test-model", provider=OgxProvider(base_url="http://localhost:8321/v1")
+        )
+        responses_create = mocker.patch.object(
+            model,
+            "_responses_create",
+            new_callable=mocker.AsyncMock,
+            side_effect=lambda *_: _make_mock_response_stream(
+                mocker,
+                [
+                    _make_response_created_event(),
+                    _make_response_failed_event(_CONTEXT_LENGTH_MESSAGE),
+                ],
+            ),
+        )
+        agent = Agent(model, defer_model_check=True)
+
+        with pytest.raises(ModelHTTPError) as exc_info:
+            async with agent.run_stream_events("question") as stream:
+                async for _ in stream:
+                    pass
+
+        assert responses_create.await_count == 1
+        assert isinstance(
+            map_agent_inference_error(exc_info.value, "openai/test-model"),
+            PromptTooLongResponse,
+        )
+
 
 class TestLlsResponsesExtraFields:
     """Tests for the _LLS_RESPONSES_EXTRA_FIELDS constant."""