LCORE-2917: regenerate OpenAPI schema and add multimodal image tests

Regenerate docs/openapi.json to reflect Attachment model changes
(image type, content_type examples, description updates).

Add tests for image attachment validation, prepare_responses_params
image extraction, and multimodal prompt construction in both blocking
and streaming agent runners.

Signed-off-by: Lucas <lyoon@redhat.com>

Author: JslYoon

docs/openapi.json

@@ -11487,23 +11487,26 @@
                     "attachment_type": {
                         "type": "string",
                         "title": "Attachment Type",
-                        "description": "The attachment type, like 'log', 'configuration' etc.",
+                        "description": "The attachment type, like 'log', 'configuration', 'image' etc.",
                         "examples": [
-                            "log"
+                            "log",
+                            "image"
                         ]
                     },
                     "content_type": {
                         "type": "string",
                         "title": "Content Type",
                         "description": "The content type as defined in MIME standard",
                         "examples": [
-                            "text/plain"
+                            "text/plain",
+                            "image/jpeg",
+                            "image/png"
                         ]
                     },
                     "content": {
                         "type": "string",
                         "title": "Content",
-                        "description": "The actual attachment content",
+                        "description": "The actual attachment content (text or base64-encoded image data)",
                         "examples": [
                             "warning: quota exceeded"
                         ]
@@ -11517,7 +11520,7 @@
                     "content"
                 ],
                 "title": "Attachment",
-                "description": "Model representing an attachment that can be sent from the UI as part of query.\n\nA list of attachments can be an optional part of 'query' request.\n\nAttributes:\n    attachment_type: The attachment type, like \"log\", \"configuration\" etc.\n    content_type: The content type as defined in MIME standard\n    content: The actual attachment content",
+                "description": "Model representing an attachment that can be sent from the UI as part of query.\n\nA list of attachments can be an optional part of 'query' request.\n\nAttributes:\n    attachment_type: The attachment type, like \"log\", \"configuration\", \"image\" etc.\n    content_type: The content type as defined in MIME standard\n    content: The actual attachment content (text or base64-encoded image data)",
                 "examples": [
                     {
                         "attachment_type": "log",
@@ -11533,6 +11536,11 @@
                         "attachment_type": "configuration",
                         "content": "foo: bar",
                         "content_type": "application/yaml"
+                    },
+                    {
+                        "attachment_type": "image",
+                        "content": "<base64-encoded image data>",
+                        "content_type": "image/png"
                     }
                 ]
             },

src/models/common/query.py

@@ -44,6 +44,9 @@ class Attachment(BaseModel):
     def validate_image_attachment(self) -> "Attachment":
         """Validate consistency between attachment_type and content_type for images.
 
+        Returns:
+            Self: The validated Attachment instance.
+
         Raises:
             ValueError: If image content_type is used without attachment_type='image',
                 if attachment_type='image' is used without an image content_type,

tests/unit/utils/agents/test_query.py

@@ -1,5 +1,6 @@
 """Unit tests for utils.agents.query module."""
 
+import base64
 from collections.abc import Callable
 from typing import Any, Optional
 
@@ -11,6 +12,7 @@
 from llama_stack_client import APIConnectionError, APIStatusError
 from pydantic_ai.messages import (
     FinishReason,
+    ImageUrl,
     ModelRequest,
     ModelResponse,
     NativeToolCallPart,
@@ -25,6 +27,7 @@
 
 from constants import ENDPOINT_PATH_QUERY
 from models.common.moderation import ShieldModerationBlocked, ShieldModerationPassed
+from models.common.query import Attachment
 from models.common.responses.responses_api_params import ResponsesApiParams
 from models.common.responses.types import ResponseInput
 from models.common.turn_summary import TurnSummary
@@ -431,6 +434,49 @@ async def test_success_returns_turn_summary(
         assert summary.llm_response == "Hello!"
         assert summary.id == "resp-success"
 
+    @pytest.mark.asyncio
+    async def test_success_with_image_attachments_sends_multimodal_prompt(
+        self,
+        mocker: MockerFixture,
+        make_agent_run_result: Callable[..., Any],
+        make_responses_params: Callable[..., ResponsesApiParams],
+        patch_recording_metrics: None,
+    ) -> None:
+        """Test that image attachments produce a multimodal prompt."""
+        run_result = make_agent_run_result(
+            content="I see a screenshot.",
+            response_id="resp-image",
+        )
+        mock_agent = mocker.AsyncMock()
+        mock_agent.run = mocker.AsyncMock(return_value=run_result)
+        mocker.patch(
+            "utils.agents.query.build_agent",
+            return_value=mock_agent,
+        )
+
+        image_data = base64.b64encode(b"\xff\xd8\xff\xe0" + b"\x00" * 10).decode()
+        image_attachment = Attachment(
+            attachment_type="image",
+            content=image_data,
+            content_type="image/jpeg",
+        )
+        params = make_responses_params(input_text="describe this")
+        params.image_attachments = [image_attachment]
+
+        summary = await retrieve_agent_response(
+            client=mocker.AsyncMock(),
+            responses_params=params,
+            moderation_result=ShieldModerationPassed(),
+            endpoint_path=ENDPOINT_PATH_QUERY,
+        )
+
+        prompt_arg = mock_agent.run.call_args[0][0]
+        assert isinstance(prompt_arg, list)
+        assert prompt_arg[0] == "describe this"
+        assert isinstance(prompt_arg[1], ImageUrl)
+        assert prompt_arg[1].url == f"data:image/jpeg;base64,{image_data}"
+        assert summary.llm_response == "I see a screenshot."
+
     @pytest.mark.asyncio
     @pytest.mark.usefixtures("patch_query_configuration")
     async def test_agent_connection_error_raises_http_exception(

tests/unit/utils/agents/test_streaming.py

@@ -3,6 +3,7 @@
 # pylint: disable=too-many-lines
 
 import asyncio
+import base64
 import json
 from collections.abc import AsyncIterator, Callable
 from typing import Any, Optional
@@ -19,6 +20,7 @@
     FinishReason,
     FunctionToolCallEvent,
     FunctionToolResultEvent,
+    ImageUrl,
     ModelResponse,
     NativeToolCallPart,
     NativeToolReturnPart,
@@ -50,6 +52,7 @@
     TurnCompleteStreamPayload,
 )
 from models.common.moderation import ShieldModerationBlocked, ShieldModerationPassed
+from models.common.query import Attachment as QueryAttachment
 from models.common.responses.contexts import ResponseGeneratorContext
 from models.common.responses.responses_api_params import ResponsesApiParams
 from models.common.turn_summary import RAGContext, TurnSummary
@@ -889,6 +892,68 @@ async def test_streams_token_events_and_updates_summary(
         assert turn_summary.token_usage.input_tokens == 4
         assert turn_summary.token_usage.output_tokens == 2
 
+    @pytest.mark.asyncio
+    async def test_streams_with_image_attachments_passes_multimodal_prompt(
+        self,
+        mocker: MockerFixture,
+        make_generator_context: Callable[..., ResponseGeneratorContext],
+        make_responses_params: Callable[..., ResponsesApiParams],
+        make_agent_run_result: Callable[..., Any],
+        patch_recording_metrics: None,
+    ) -> None:
+        """Test that image attachments produce a multimodal prompt for streaming."""
+        context = make_generator_context()
+        turn_summary = TurnSummary()
+        run_result = make_agent_run_result(
+            content="I see a screenshot.",
+            response_id="resp-image-stream",
+            input_tokens=5,
+            output_tokens=3,
+        )
+        events = [
+            PartStartEvent(index=0, part=TextPart(content="I see")),
+            PartDeltaEvent(
+                index=0, delta=TextPartDelta(content_delta=" a screenshot.")
+            ),
+            AgentRunResultEvent(result=run_result),
+        ]
+        mock_agent = mocker.Mock()
+        mock_agent.run_stream_events.return_value = _mock_run_stream(events)
+        mocker.patch(
+            "utils.agents.streaming.get_agent_finish_reason",
+            return_value=AgentFinishReason.SUCCESS,
+        )
+        mocker.patch(
+            "utils.agents.streaming.deduplicate_referenced_documents",
+            side_effect=lambda docs: docs,
+        )
+
+        image_data = base64.b64encode(b"\xff\xd8\xff\xe0" + b"\x00" * 10).decode()
+        image_attachment = QueryAttachment(
+            attachment_type="image",
+            content=image_data,
+            content_type="image/jpeg",
+        )
+        params = make_responses_params(input_text="describe this")
+        params.image_attachments = [image_attachment]
+
+        _ = [
+            event
+            async for event in agent_response_generator(
+                mock_agent,
+                params,
+                context,
+                turn_summary,
+                ENDPOINT_PATH_STREAMING_QUERY,
+            )
+        ]
+
+        prompt_arg = mock_agent.run_stream_events.call_args[0][0]
+        assert isinstance(prompt_arg, list)
+        assert prompt_arg[0] == "describe this"
+        assert isinstance(prompt_arg[1], ImageUrl)
+        assert prompt_arg[1].url == f"data:image/jpeg;base64,{image_data}"
+
     @pytest.mark.asyncio
     async def test_non_success_finish_reason_yields_error_event(
         self,

tests/unit/utils/test_query.py

@@ -441,6 +441,26 @@ def test_invalid_content_type(self) -> None:
         assert exc_info.value.status_code == 422
         assert "Invalid attachment content type" in str(exc_info.value.detail)
 
+    def test_valid_image_attachment_jpeg(self) -> None:
+        """Test validation passes for JPEG image attachment."""
+        image_data = base64.b64encode(b"\xff\xd8\xff\xe0" + b"\x00" * 10).decode()
+        attachment = Attachment(
+            attachment_type="image",
+            content=image_data,
+            content_type="image/jpeg",
+        )
+        validate_attachments_metadata([attachment])
+
+    def test_valid_image_attachment_png(self) -> None:
+        """Test validation passes for PNG image attachment."""
+        image_data = base64.b64encode(b"\x89PNG" + b"\x00" * 10).decode()
+        attachment = Attachment(
+            attachment_type="image",
+            content=image_data,
+            content_type="image/png",
+        )
+        validate_attachments_metadata([attachment])
+
 
 class TestIsTranscriptsEnabled:
     """Tests for is_transcripts_enabled function."""

tests/unit/utils/test_responses.py

@@ -2,6 +2,7 @@
 
 # pylint: disable=line-too-long,too-many-lines
 
+import base64
 import json
 from pathlib import Path
 from typing import Any, Optional, cast
@@ -55,6 +56,7 @@
 
 import constants
 from models.api.requests import QueryRequest
+from models.common.query import Attachment
 from models.common.responses.types import InputTool, InputToolMCP
 from models.config import (
     ApprovalFilter,
@@ -2226,6 +2228,54 @@ async def test_prepare_responses_params_api_status_error_on_conversation(
             await prepare_responses_params(mock_client, query_request, None, "token")
         assert exc_info.value.status_code == 500
 
+    @pytest.mark.asyncio
+    async def test_image_attachments_extracted(self, mocker: MockerFixture) -> None:
+        """Test that image attachments are extracted into ResponsesApiParams."""
+        mock_client = mocker.AsyncMock()
+        mock_conversation = mocker.Mock()
+        mock_conversation.id = "new_conv_id"
+        mock_client.conversations.create = mocker.AsyncMock(
+            return_value=mock_conversation
+        )
+
+        image_data = base64.b64encode(b"\xff\xd8\xff\xe0" + b"\x00" * 10).decode()
+        text_attachment = Attachment(
+            attachment_type="log",
+            content="log output",
+            content_type="text/plain",
+        )
+        image_attachment = Attachment(
+            attachment_type="image",
+            content=image_data,
+            content_type="image/jpeg",
+        )
+        query_request = QueryRequest(
+            query="describe this",
+            attachments=[text_attachment, image_attachment],
+        )  # pyright: ignore[reportCallIssue]
+
+        mock_config = mocker.Mock()
+        mock_config.inference = InferenceConfiguration()
+        mocker.patch("utils.responses.configuration", mock_config)
+        mocker.patch("utils.responses.get_system_prompt", return_value="System prompt")
+        mocker.patch("utils.responses.prepare_tools", return_value=None)
+        mocker.patch(
+            "utils.responses.select_model_for_responses",
+            return_value="provider1/model1",
+        )
+        mocker.patch("utils.responses.check_model_configured", return_value=True)
+
+        result = await prepare_responses_params(
+            mock_client, query_request, None, "token"
+        )
+
+        assert isinstance(result.input, str)
+        assert result.image_attachments is not None
+        assert len(result.image_attachments) == 1
+        assert result.image_attachments[0].content_type == "image/jpeg"
+        dumped = result.model_dump(exclude_none=True)
+        assert "image_attachments" not in dumped
+
 
 class TestParseReferencedDocuments:
     """Tests for parse_referenced_documents function."""