From eb24f703e3e29b90211d7b5e3d026325dc23f99e Mon Sep 17 00:00:00 2001 From: droideronline Date: Mon, 9 Nov 2026 16:10:28 +0530 Subject: [PATCH 1/2] Python: Support response_format in GitHubCopilotAgent Forward response_format as response_schema to the Copilot SDK send and send_and_wait calls and keep it out of create_session kwargs. Parse AgentResponse.value in core with alias validation enabled while preserving each model's field-name validation. For streaming, only the root agent's final idle ends the run, aborted and autopilot idle events are handled like the SDK waiter, and events are correlated to the request ID returned by send so an earlier request cannot supply the structured value. --- .../packages/core/agent_framework/_types.py | 17 +- python/packages/core/tests/core/test_types.py | 69 ++++ .../agent_framework_github_copilot/_agent.py | 114 +++++- .../tests/test_github_copilot_agent.py | 361 +++++++++++++++++- 4 files changed, 554 insertions(+), 7 deletions(-) diff --git a/python/packages/core/agent_framework/_types.py b/python/packages/core/agent_framework/_types.py index e10eeccf920..fcfe33f9316 100644 --- a/python/packages/core/agent_framework/_types.py +++ b/python/packages/core/agent_framework/_types.py @@ -3116,6 +3116,21 @@ class ContinuationToken(TypedDict): # endregion +def _validate_structured_json(model: Any, text: str) -> Any: + """Validate JSON against ``model`` with alias validation enabled. + + Providers are asked for alias-keyed output (the model's JSON schema uses aliases), so aliases are + always accepted, even for a model configured with ``validate_by_alias=False``. The model's own + ``validate_by_name`` / ``populate_by_name`` setting is preserved. Overriding ``by_alias`` needs + pydantic 2.11; earlier versions use the model's own settings. + """ + from pydantic import VERSION + + if tuple(int(part) for part in VERSION.split(".")[:2]) >= (2, 11): + return model.model_validate_json(text, by_alias=True) + return model.model_validate_json(text) + + def _parse_structured_response_value(text: str, response_format: Any | None) -> Any | None: if response_format is None: return None @@ -3125,7 +3140,7 @@ def _parse_structured_response_value(text: str, response_format: Any | None) -> from pydantic import BaseModel if issubclass(response_format, BaseModel): - return response_format.model_validate_json(text) + return _validate_structured_json(response_format, text) if isinstance(response_format, Mapping): try: return json.loads(text) diff --git a/python/packages/core/tests/core/test_types.py b/python/packages/core/tests/core/test_types.py index f8547c1b7e5..65697a25d69 100644 --- a/python/packages/core/tests/core/test_types.py +++ b/python/packages/core/tests/core/test_types.py @@ -7902,3 +7902,72 @@ def test_data_uri_readers_agree_on_the_base64_marker(): payload_marker = f"data:image/png,x;base64,{png_b64}" with pytest.raises(ValueError, match="Data URI must use base64 encoding."): detect_media_type_from_base64(data_uri=payload_marker) + + +def test_agent_response_value_validates_by_alias_only() -> None: + """Structured output is validated with aliases only, matching the schema sent to providers.""" + from pydantic import VERSION, ConfigDict + + if tuple(int(part) for part in VERSION.split(".")[:2]) < (2, 11): + pytest.skip("validate_by_alias/validate_by_name require pydantic 2.11") + + class Aliased(BaseModel): + model_config = ConfigDict(validate_by_alias=False, validate_by_name=True) + item_count: int = Field(alias="itemCount") + + response = AgentResponse( + messages=[Message(role="assistant", contents=['{"itemCount": 3}'])], + response_format=Aliased, + ) + + assert response.value is not None + assert response.value.item_count == 3 + + +def test_agent_response_value_accepts_field_names_when_model_allows_it() -> None: + """A model configured to validate by field name keeps accepting name-keyed output.""" + from pydantic import ConfigDict + + class Named(BaseModel): + model_config = ConfigDict(validate_by_name=True, validate_by_alias=True) + item_count: int = Field(alias="itemCount") + + for text in ('{"item_count": 3}', '{"itemCount": 3}'): + response = AgentResponse( + messages=[Message(role="assistant", contents=[text])], + response_format=Named, + ) + assert response.value is not None + assert response.value.item_count == 3 + + +def test_agent_response_value_raises_original_error_for_invalid_output() -> None: + class Strict(BaseModel): + count: int + + response = AgentResponse( + messages=[Message(role="assistant", contents=['{"count": "x"}'])], + response_format=Strict, + ) + with pytest.raises(ValidationError): + _ = response.value + + +def test_agent_response_value_keeps_provider_value_for_defaulted_aliased_field() -> None: + """A defaulted aliased field must not silently fall back to its default for alias-keyed output.""" + from pydantic import VERSION, ConfigDict + + if tuple(int(part) for part in VERSION.split(".")[:2]) < (2, 11): + pytest.skip("validate_by_alias/validate_by_name require pydantic 2.11") + + class Defaulted(BaseModel): + model_config = ConfigDict(validate_by_alias=False, validate_by_name=True) + item_count: int = Field(default=0, alias="itemCount") + + response = AgentResponse( + messages=[Message(role="assistant", contents=['{"itemCount": 3}'])], + response_format=Defaulted, + ) + + assert response.value is not None + assert response.value.item_count == 3 diff --git a/python/packages/github_copilot/agent_framework_github_copilot/_agent.py b/python/packages/github_copilot/agent_framework_github_copilot/_agent.py index 4295475b092..f1cfe20bfe3 100644 --- a/python/packages/github_copilot/agent_framework_github_copilot/_agent.py +++ b/python/packages/github_copilot/agent_framework_github_copilot/_agent.py @@ -53,6 +53,7 @@ ) from agent_framework.exceptions import AgentException, ContentError, MiddlewareException from agent_framework.observability import AgentTelemetryLayer +from pydantic import BaseModel from ._feature_usage import FeatureIndex @@ -189,6 +190,25 @@ async def _resolve_function_approval( logger = logging.getLogger("agent_framework.github_copilot") +def _to_response_schema(response_format: Any) -> Any: + """Return a value the Copilot SDK can JSON-serialize as ``response_schema``. + + Pydantic model classes are passed through unchanged. Any other mapping (for example a + ``MappingProxyType`` or ``UserDict``) is converted, recursively, to plain ``dict``/``list`` objects. + """ + if response_format is None or isinstance(response_format, type): + return response_format + + def _plain(value: Any) -> Any: + if isinstance(value, Mapping): + return {key: _plain(item) for key, item in cast(Mapping[Any, Any], value).items()} + if isinstance(value, (list, tuple)): + return [_plain(item) for item in cast(Sequence[Any], value)] + return value + + return _plain(response_format) + + def _provider_service_session_state_keys(agent: object, client: object | None) -> frozenset[str]: """Return provider-owned session-state keys declared by the Copilot agent or client.""" keys: set[str] = set() @@ -534,6 +554,13 @@ class GitHubCopilotOptions(TypedDict, total=False): telemetry: TelemetryConfig """OpenTelemetry configuration for the Copilot CLI process.""" + response_format: type[BaseModel] | Mapping[str, Any] + """Structured output format for the run: a Pydantic model type or a JSON Schema mapping. + + Forwarded to the Copilot SDK as ``response_schema`` so the provider constrains the + final answer to the schema, and the parsed result is exposed on ``AgentResponse.value``. + Streaming still yields text; the value is parsed once the stream completes.""" + on_pre_tool_use: PreToolUseHandler """Pre-tool-use hook handler for the Copilot SDK. @@ -876,7 +903,14 @@ async def _after_run_hook(response: AgentResponse) -> None: logger.exception("Error running after_run providers in streaming result hook") def _finalize(updates: Sequence[AgentResponseUpdate]) -> AgentResponse: - return AgentResponse.from_updates(updates) + response_format: Any = cast(Mapping[str, Any], options or {}).get( + "response_format" + ) or self._default_options.get("response_format") + if response_format is not None: + # The structured value comes from the root agent's answer, so sub-agent updates + # (which still stream to the caller) are left out of the final response. + updates = [update for update in updates if not getattr(update.raw_representation, "agent_id", None)] + return AgentResponse.from_updates(updates, output_format_type=response_format) return ResponseStream( self._stream_updates( @@ -946,6 +980,8 @@ async def _run_impl( "together with on_permission_request instead." ) timeout = opts.get("timeout") or self._settings.get("timeout") or DEFAULT_TIMEOUT_SECONDS + response_format = opts.get("response_format") or self._default_options.get("response_format") + response_schema = _to_response_schema(response_format) input_messages = normalize_messages(messages) @@ -998,7 +1034,12 @@ def usage_event_handler(event: SessionEvent) -> None: unsubscribe = copilot_session.on(usage_event_handler) try: mark_feature_used(FeatureIndex.GITHUB_COPILOT) - response_event = await copilot_session.send_and_wait(prompt, attachments=attachments, timeout=timeout) + response_event = await copilot_session.send_and_wait( + prompt, + attachments=attachments, + response_schema=response_schema, + timeout=timeout, + ) except Exception as ex: raise AgentException(f"GitHub Copilot request failed: {ex}") from ex finally: @@ -1030,6 +1071,7 @@ def usage_event_handler(event: SessionEvent) -> None: finish_reason=cast(Any, finish_reason), usage_details=usage_details, additional_properties={"model": model} if model else None, + response_format=response_format, ) session_context._response = response # type: ignore[assignment] await self._run_after_providers(session=session, context=session_context) @@ -1083,6 +1125,8 @@ async def _stream_updates( "(set via default_options). Remove on_function_approval and use on_pre_tool_use " "together with on_permission_request instead." ) + response_format = opts.get("response_format") or self._default_options.get("response_format") + response_schema = _to_response_schema(response_format) input_messages = normalize_messages(messages) @@ -1102,7 +1146,15 @@ async def _stream_updates( queue: asyncio.Queue[AgentResponseUpdate | Exception | None] = asyncio.Queue() - def event_handler(event: SessionEvent) -> None: + # The request submitted by ``send``. Events are only acted on once this request has started, so + # the tail of an earlier request (for example one that timed out) cannot supply this run's answer + # or end it. Without a request ID (legacy runtimes) every event is accepted, as in the SDK waiter. + request_id: str | None = None + request_sent = False + started = False + pending_events: list[SessionEvent] = [] + + def handle_event(event: SessionEvent) -> None: if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA: data: Any = event.data if data.delta_content: @@ -1180,12 +1232,60 @@ def event_handler(event: SessionEvent) -> None: ) queue.put_nowait(update) elif event.type == SessionEventType.SESSION_IDLE: + # Only the root agent's final idle ends the run: not a sub-agent's, and not an autopilot + # idle, which the session leaves before it reaches its actual final state. + if getattr(event, "agent_id", None): + return + idle_data: Any = event.data + mode = getattr(idle_data, "mode", None) + if str(getattr(mode, "value", mode)) == "autopilot": + return + if getattr(idle_data, "aborted", False): + queue.put_nowait(AgentException("GitHub Copilot session aborted before response completed")) + return queue.put_nowait(None) + elif event.type == getattr(SessionEventType, "SESSION_AUTOPILOT_STOPPED", None): + stopped_data: Any = event.data + if not request_id or getattr(stopped_data, "request_id", None) != request_id: + return + reason = getattr(stopped_data, "reason", None) + if reason == "error": + queue.put_nowait(AgentException("GitHub Copilot autopilot request failed")) + elif reason == "aborted": + queue.put_nowait(AgentException("GitHub Copilot session aborted before response completed")) + else: + queue.put_nowait(None) elif event.type == SessionEventType.SESSION_ERROR: error_data: Any = event.data error_msg = error_data.message or "Unknown error" queue.put_nowait(AgentException(f"GitHub Copilot session error: {error_msg}")) + def dispatch_event(event: SessionEvent) -> None: + nonlocal started + if not started: + data: Any = event.data + if not request_id: + started = True + elif not getattr(event, "agent_id", None): + if event.type == SessionEventType.USER_MESSAGE: + started = getattr(data, "message_id", None) == request_id + elif event.type == SessionEventType.ASSISTANT_MESSAGE: + started = getattr(data, "originating_message_id", None) == request_id + elif event.type == SessionEventType.SESSION_ERROR: + # An error attributed to this request ends it even if it never started. + if getattr(data, "originating_message_id", None) != request_id: + return + started = True + if not started: + return + handle_event(event) + + def event_handler(event: SessionEvent) -> None: + if request_sent: + dispatch_event(event) + else: + pending_events.append(event) + async with self._session_run_scope( session, streaming=True, @@ -1200,7 +1300,12 @@ def event_handler(event: SessionEvent) -> None: try: mark_feature_used(FeatureIndex.GITHUB_COPILOT) - await copilot_session.send(prompt, attachments=attachments) + sent_id = await copilot_session.send(prompt, attachments=attachments, response_schema=response_schema) + request_id = sent_id if isinstance(sent_id, str) and sent_id else None + request_sent = True + for pending_event in pending_events: + dispatch_event(pending_event) + pending_events.clear() while (item := await queue.get()) is not None: if isinstance(item, Exception): @@ -1770,6 +1875,7 @@ def _build_session_kwargs( "on_pre_tool_use", "on_function_approval", "timeout", + "response_format", "cli_path", "log_level", "base_directory", diff --git a/python/packages/github_copilot/tests/test_github_copilot_agent.py b/python/packages/github_copilot/tests/test_github_copilot_agent.py index b0d6ad71f33..41a382d0084 100644 --- a/python/packages/github_copilot/tests/test_github_copilot_agent.py +++ b/python/packages/github_copilot/tests/test_github_copilot_agent.py @@ -9,7 +9,7 @@ from collections.abc import Sequence from datetime import datetime, timezone from pathlib import Path -from types import SimpleNamespace +from types import MappingProxyType, SimpleNamespace from typing import Any, cast from unittest.mock import AsyncMock, MagicMock, patch from uuid import uuid4 @@ -47,6 +47,7 @@ ToolExecutionCompleteResult, ) from copilot.tools import ToolInvocation, ToolResult +from pydantic import BaseModel, ConfigDict, Field, ValidationError from agent_framework_github_copilot import GitHubCopilotAgent, GitHubCopilotOptions, RawGitHubCopilotAgent from agent_framework_github_copilot._feature_usage import FeatureIndex @@ -126,7 +127,9 @@ def mock_session() -> MagicMock: """Create a mock CopilotSession.""" session = MagicMock() session.session_id = "test-session-id" - session.send = AsyncMock(return_value="test-message-id") + # No request ID, like a legacy runtime, so streaming accepts every event. Tests of request + # correlation set a request ID and emit the matching user message event. + session.send = AsyncMock(return_value=None) session.send_and_wait = AsyncMock() session.destroy = AsyncMock() session.on = MagicMock(return_value=lambda: None) @@ -1250,6 +1253,360 @@ def mock_on(handler: Any) -> Any: assert responses[3].contents[0].type == "text" +class TestGitHubCopilotAgentStructuredOutput: + """Test cases for response_format (structured output) support.""" + + class Answer(BaseModel): + value: int + + async def test_run_passes_response_format_as_response_schema( + self, + mock_client: MagicMock, + mock_session: MagicMock, + ) -> None: + """response_format is forwarded to send_and_wait and parsed into AgentResponse.value.""" + mock_session.send_and_wait.return_value = create_session_event( + SessionEventType.ASSISTANT_MESSAGE, content='{"value": 42}', message_id="msg-1" + ) + + agent = GitHubCopilotAgent(client=mock_client) + response = await agent.run("What is 19 + 23?", options=cast(Any, {"response_format": self.Answer})) + + assert mock_session.send_and_wait.call_args.kwargs["response_schema"] is self.Answer + assert response.value == self.Answer(value=42) + + async def test_run_uses_default_options_response_format( + self, + mock_client: MagicMock, + mock_session: MagicMock, + ) -> None: + """response_format from default_options is used and not leaked into create_session.""" + mock_session.send_and_wait.return_value = create_session_event( + SessionEventType.ASSISTANT_MESSAGE, content='{"value": 7}', message_id="msg-1" + ) + + agent = GitHubCopilotAgent(client=mock_client, default_options=cast(Any, {"response_format": self.Answer})) + response = await agent.run("Hi") + + assert mock_session.send_and_wait.call_args.kwargs["response_schema"] is self.Answer + assert "response_format" not in mock_client.create_session.call_args.kwargs + assert response.value == self.Answer(value=7) + + async def test_run_accepts_json_schema_mapping( + self, + mock_client: MagicMock, + mock_session: MagicMock, + ) -> None: + """A JSON Schema mapping is forwarded unchanged.""" + schema = {"type": "object", "properties": {"value": {"type": "integer"}}, "required": ["value"]} + mock_session.send_and_wait.return_value = create_session_event( + SessionEventType.ASSISTANT_MESSAGE, content='{"value": 1}', message_id="msg-1" + ) + + agent = GitHubCopilotAgent(client=mock_client) + response = await agent.run("Hi", options=cast(Any, {"response_format": schema})) + + assert mock_session.send_and_wait.call_args.kwargs["response_schema"] == schema + assert response.value == {"value": 1} + + async def test_run_without_response_format_sends_no_schema( + self, + mock_client: MagicMock, + mock_session: MagicMock, + assistant_message_event: SessionEvent, + ) -> None: + """No schema is sent when response_format is not set.""" + mock_session.send_and_wait.return_value = assistant_message_event + + agent = GitHubCopilotAgent(client=mock_client) + await agent.run("Hi") + + assert mock_session.send_and_wait.call_args.kwargs["response_schema"] is None + + async def test_run_converts_mapping_schema_to_plain_dict( + self, + mock_client: MagicMock, + mock_session: MagicMock, + ) -> None: + """Non-dict mappings are converted to plain dicts so the SDK can serialize them.""" + schema = MappingProxyType({ + "type": "object", + "properties": MappingProxyType({"value": MappingProxyType({"type": "integer"})}), + }) + mock_session.send_and_wait.return_value = create_session_event( + SessionEventType.ASSISTANT_MESSAGE, content='{"value": 1}', message_id="msg-1" + ) + + agent = GitHubCopilotAgent(client=mock_client) + await agent.run("Hi", options=cast(Any, {"response_format": schema})) + + sent = mock_session.send_and_wait.call_args.kwargs["response_schema"] + assert type(sent) is dict + assert type(sent["properties"]["value"]) is dict + json.dumps(sent) + + async def test_run_parses_aliased_model_by_alias( + self, + mock_client: MagicMock, + mock_session: MagicMock, + ) -> None: + """Aliased models are validated by alias only, matching the schema sent to the SDK.""" + + class Aliased(BaseModel): + model_config = ConfigDict(validate_by_alias=False, validate_by_name=True) + item_count: int = Field(alias="itemCount") + + mock_session.send_and_wait.return_value = create_session_event( + SessionEventType.ASSISTANT_MESSAGE, content='{"itemCount": 3}', message_id="msg-1" + ) + # Core validation with the model's own settings would fail here. + with pytest.raises(ValidationError): + Aliased.model_validate_json('{"itemCount": 3}') + + agent = GitHubCopilotAgent(client=mock_client) + response = await agent.run("Hi", options=cast(Any, {"response_format": Aliased})) + + assert response.value is not None + assert response.value.item_count == 3 + + class Defaulted(BaseModel): + model_config = ConfigDict(validate_by_alias=False, validate_by_name=True) + item_count: int = Field(default=0, alias="itemCount") + + async def test_run_keeps_provider_value_for_defaulted_aliased_field( + self, + mock_client: MagicMock, + mock_session: MagicMock, + ) -> None: + """An alias-keyed value is not lost to the field default (non-streaming).""" + mock_session.send_and_wait.return_value = create_session_event( + SessionEventType.ASSISTANT_MESSAGE, content='{"itemCount": 3}', message_id="msg-1" + ) + + agent = GitHubCopilotAgent(client=mock_client) + response = await agent.run("Hi", options=cast(Any, {"response_format": self.Defaulted})) + + assert response.value is not None + assert response.value.item_count == 3 + + async def test_streaming_keeps_provider_value_for_defaulted_aliased_field( + self, + mock_client: MagicMock, + mock_session: MagicMock, + ) -> None: + """An alias-keyed value is not lost to the field default (streaming).""" + events = [ + create_session_event( + SessionEventType.ASSISTANT_MESSAGE_DELTA, delta_content='{"itemCount": 3}', message_id="root" + ), + create_session_event(SessionEventType.SESSION_IDLE), + ] + + def mock_on(handler: Any) -> Any: + for event in events: + handler(event) + return lambda: None + + mock_session.on = mock_on + + agent = GitHubCopilotAgent(client=mock_client) + stream = agent.run("Hi", stream=True, options=cast(Any, {"response_format": self.Defaulted})) + async for _ in stream: + pass + response = await stream.get_final_response() + + assert response.value is not None + assert response.value.item_count == 3 + + async def test_streaming_value_ignores_trailing_subagent_text( + self, + mock_client: MagicMock, + mock_session: MagicMock, + ) -> None: + """A sub-agent delta after the root answer does not replace the structured value.""" + child = create_session_event( + SessionEventType.ASSISTANT_MESSAGE_DELTA, delta_content="child chatter", message_id="child" + ) + child.agent_id = "sub-agent" + events = [ + create_session_event( + SessionEventType.ASSISTANT_MESSAGE_DELTA, delta_content='{"value": 9}', message_id="root" + ), + child, + create_session_event(SessionEventType.SESSION_IDLE), + ] + + def mock_on(handler: Any) -> Any: + for event in events: + handler(event) + return lambda: None + + mock_session.on = mock_on + + agent = GitHubCopilotAgent(client=mock_client) + stream = agent.run("Hi", stream=True, options=cast(Any, {"response_format": self.Answer})) + texts = [u.text async for u in stream] + response = await stream.get_final_response() + + assert "child chatter" in "".join(texts) + assert response.value == self.Answer(value=9) + + async def test_streaming_ignores_subagent_idle_before_root_answer( + self, + mock_client: MagicMock, + mock_session: MagicMock, + ) -> None: + """A sub-agent idle event does not end the stream or drop the root structured answer.""" + child_idle = create_session_event(SessionEventType.SESSION_IDLE) + child_idle.agent_id = "sub-agent" + events = [ + create_session_event(SessionEventType.ASSISTANT_MESSAGE_DELTA, delta_content="preamble", message_id="pre"), + child_idle, + create_session_event( + SessionEventType.ASSISTANT_MESSAGE_DELTA, delta_content='{"value": 11}', message_id="root" + ), + create_session_event(SessionEventType.SESSION_IDLE), + ] + + def mock_on(handler: Any) -> Any: + for event in events: + handler(event) + return lambda: None + + mock_session.on = mock_on + + agent = GitHubCopilotAgent(client=mock_client) + stream = agent.run("Hi", stream=True, options=cast(Any, {"response_format": self.Answer})) + texts = [u.text async for u in stream] + response = await stream.get_final_response() + + assert '{"value": 11}' in "".join(texts) + assert response.value is not None + assert response.value.value == 11 + + @staticmethod + def _replay(mock_session: MagicMock, events: list[SessionEvent]) -> None: + mock_session.send.return_value = "req-1" + + def mock_on(handler: Any) -> Any: + for event in events: + handler(event) + return lambda: None + + mock_session.on = mock_on + + async def _stream_value(self, mock_client: MagicMock) -> tuple[list[str], Any]: + agent = GitHubCopilotAgent(client=mock_client) + stream = agent.run("Hi", stream=True, options=cast(Any, {"response_format": self.Answer})) + texts = [u.text async for u in stream] + return texts, await stream.get_final_response() + + async def test_streaming_ignores_events_from_an_earlier_request( + self, + mock_client: MagicMock, + mock_session: MagicMock, + ) -> None: + """An earlier request's root answer and idle must not supply or end this run.""" + self._replay( + mock_session, + [ + create_session_event( + SessionEventType.ASSISTANT_MESSAGE_DELTA, delta_content='{"value": 1}', message_id="old" + ), + create_session_event(SessionEventType.SESSION_IDLE), + create_session_event(SessionEventType.USER_MESSAGE, message_id="req-1"), + create_session_event( + SessionEventType.ASSISTANT_MESSAGE_DELTA, delta_content='{"value": 2}', message_id="new" + ), + create_session_event(SessionEventType.SESSION_IDLE), + ], + ) + + texts, response = await self._stream_value(mock_client) + + assert "".join(texts) == '{"value": 2}' + assert response.value is not None + assert response.value.value == 2 + + async def test_streaming_rejects_aborted_root_idle( + self, + mock_client: MagicMock, + mock_session: MagicMock, + ) -> None: + """An aborted idle is an error, not a successful structured result.""" + aborted_idle = create_session_event(SessionEventType.SESSION_IDLE) + aborted_idle.data.aborted = True # type: ignore[attr-defined] + self._replay( + mock_session, + [ + create_session_event(SessionEventType.USER_MESSAGE, message_id="req-1"), + create_session_event( + SessionEventType.ASSISTANT_MESSAGE_DELTA, delta_content='{"value": 1}', message_id="m1" + ), + aborted_idle, + ], + ) + + with pytest.raises(AgentException, match="aborted"): + await self._stream_value(mock_client) + + async def test_streaming_ignores_autopilot_idle_until_final_response( + self, + mock_client: MagicMock, + mock_session: MagicMock, + ) -> None: + """An autopilot idle does not end the stream; the later final root response is used.""" + autopilot_idle = create_session_event(SessionEventType.SESSION_IDLE) + autopilot_idle.data.mode = "autopilot" # type: ignore[attr-defined] + self._replay( + mock_session, + [ + create_session_event(SessionEventType.USER_MESSAGE, message_id="req-1"), + create_session_event( + SessionEventType.ASSISTANT_MESSAGE_DELTA, delta_content='{"value": 1}', message_id="m1" + ), + autopilot_idle, + create_session_event( + SessionEventType.ASSISTANT_MESSAGE_DELTA, delta_content='{"value": 2}', message_id="m2" + ), + create_session_event(SessionEventType.SESSION_IDLE), + ], + ) + + _, response = await self._stream_value(mock_client) + + assert response.value is not None + assert response.value.value == 2 + + async def test_streaming_passes_response_format_and_parses_value( + self, + mock_client: MagicMock, + mock_session: MagicMock, + ) -> None: + """Streaming forwards the schema to send and parses the final value after the stream.""" + events = [ + create_session_event(SessionEventType.ASSISTANT_MESSAGE_DELTA, delta_content='{"value": ', message_id="m"), + create_session_event(SessionEventType.ASSISTANT_MESSAGE_DELTA, delta_content="5}", message_id="m"), + create_session_event(SessionEventType.SESSION_IDLE), + ] + + def mock_on(handler: Any) -> Any: + for event in events: + handler(event) + return lambda: None + + mock_session.on = mock_on + + agent = GitHubCopilotAgent(client=mock_client) + stream = agent.run("Hi", stream=True, options=cast(Any, {"response_format": self.Answer})) + async for _ in stream: + pass + response = await stream.get_final_response() + + assert mock_session.send.call_args.kwargs["response_schema"] is self.Answer + assert response.value == self.Answer(value=5) + + class TestGitHubCopilotAgentSessionManagement: """Test cases for session management.""" From 397de11b0b6b6bd31becf7d1c9bf960dfb92a357 Mon Sep 17 00:00:00 2001 From: droideronline Date: Mon, 9 Nov 2026 17:50:32 +0530 Subject: [PATCH 2/2] Python: Fix typing of idle event attribute setup in Copilot tests --- .../github_copilot/tests/test_github_copilot_agent.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/python/packages/github_copilot/tests/test_github_copilot_agent.py b/python/packages/github_copilot/tests/test_github_copilot_agent.py index 41a382d0084..49a8f962aa5 100644 --- a/python/packages/github_copilot/tests/test_github_copilot_agent.py +++ b/python/packages/github_copilot/tests/test_github_copilot_agent.py @@ -1535,7 +1535,8 @@ async def test_streaming_rejects_aborted_root_idle( ) -> None: """An aborted idle is an error, not a successful structured result.""" aborted_idle = create_session_event(SessionEventType.SESSION_IDLE) - aborted_idle.data.aborted = True # type: ignore[attr-defined] + aborted_data: Any = aborted_idle.data + aborted_data.aborted = True self._replay( mock_session, [ @@ -1557,7 +1558,8 @@ async def test_streaming_ignores_autopilot_idle_until_final_response( ) -> None: """An autopilot idle does not end the stream; the later final root response is used.""" autopilot_idle = create_session_event(SessionEventType.SESSION_IDLE) - autopilot_idle.data.mode = "autopilot" # type: ignore[attr-defined] + autopilot_data: Any = autopilot_idle.data + autopilot_data.mode = "autopilot" self._replay( mock_session, [