Skip to content

Commit 1e6d1be

Browse files
CopilotCopilot
andcommitted
fix(#3984): address review feedback for context provider integration
- Build prompt from session_context.get_messages(include_input=True) so provider-injected context_messages are included in both non-streaming and streaming paths (review comments #1, #2) - Preserve timeout in opts (use get instead of pop) so providers can observe it via context.options (review comment #3) - Eliminate streaming double-buffer: move after_run invocation to a ResponseStream result_hook (matching Agent class pattern) instead of maintaining a separate updates list in the generator (review comment #4) - Improve _run_before_providers docstring Add tests for: - Context messages included in prompt (non-streaming + streaming) - Error path: after_run NOT called when send_and_wait/streaming raises - Multiple providers: forward before_run, reverse after_run ordering - BaseHistoryProvider with load_messages=False is skipped - Streaming after_run response contains aggregated updates - Streaming with no updates still sets empty response - Timeout preserved in session context options for providers Note: _run_before_providers remains on GitHubCopilotAgent for now. A follow-up PR should extract it to BaseAgent so subclasses can reuse it without duplicating the provider iteration logic. Co-authored-by: Copilot <[email protected]>
1 parent 9c331ac commit 1e6d1be

2 files changed

Lines changed: 289 additions & 9 deletions

File tree

‎python/packages/github_copilot/agent_framework_github_copilot/_agent.py‎

Lines changed: 30 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -354,13 +354,22 @@ def run(
354354
AgentException: If the request fails.
355355
"""
356356
if stream:
357+
ctx_holder: dict[str, Any] = {}
358+
359+
async def _after_run_hook(response: AgentResponse) -> None:
360+
session_context = ctx_holder.get("session_context")
361+
sess = ctx_holder.get("session")
362+
if session_context is not None and sess is not None:
363+
session_context._response = response
364+
await self._run_after_providers(session=sess, context=session_context)
357365

358366
def _finalize(updates: Sequence[AgentResponseUpdate]) -> AgentResponse:
359367
return AgentResponse.from_updates(updates)
360368

361369
return ResponseStream(
362-
self._stream_updates(messages=messages, session=session, options=options),
370+
self._stream_updates(messages=messages, session=session, options=options, _ctx_holder=ctx_holder),
363371
finalizer=_finalize,
372+
result_hooks=[_after_run_hook],
364373
)
365374
return self._run_impl(messages=messages, session=session, options=options)
366375

@@ -379,14 +388,17 @@ async def _run_impl(
379388
session = self.create_session()
380389

381390
opts: dict[str, Any] = dict(options) if options else {}
382-
timeout = opts.pop("timeout", None) or self._settings.get("timeout") or DEFAULT_TIMEOUT_SECONDS
391+
timeout = opts.get("timeout") or self._settings.get("timeout") or DEFAULT_TIMEOUT_SECONDS
383392

384393
copilot_session = await self._get_or_create_session(session, streaming=False, runtime_options=opts)
385394
input_messages = normalize_messages(messages)
386395

387396
session_context = await self._run_before_providers(session=session, input_messages=input_messages, options=opts)
388397

389-
prompt = "\n".join([message.text for message in input_messages])
398+
# Build the prompt from the full set of messages in the session context,
399+
# so that any context/history provider-injected messages are included.
400+
context_messages = session_context.get_messages(include_input=True)
401+
prompt = "\n".join([message.text for message in context_messages])
390402
if session_context.instructions:
391403
prompt = "\n".join(session_context.instructions) + "\n" + prompt
392404
message_options = cast(MessageOptions, {"prompt": prompt})
@@ -426,6 +438,7 @@ async def _stream_updates(
426438
*,
427439
session: AgentSession | None = None,
428440
options: OptionsT | None = None,
441+
_ctx_holder: dict[str, Any] | None = None,
429442
) -> AsyncIterable[AgentResponseUpdate]:
430443
"""Internal method to stream updates from GitHub Copilot.
431444
@@ -435,6 +448,9 @@ async def _stream_updates(
435448
Keyword Args:
436449
session: The conversation session associated with the message(s).
437450
options: Runtime options (model, timeout, etc.).
451+
_ctx_holder: Internal dict populated with session_context and session
452+
so that the caller (via a ResponseStream result_hook) can run
453+
after_run providers without duplicating the updates buffer.
438454
439455
Yields:
440456
AgentResponseUpdate items.
@@ -455,7 +471,13 @@ async def _stream_updates(
455471

456472
session_context = await self._run_before_providers(session=session, input_messages=input_messages, options=opts)
457473

458-
prompt = "\n".join([message.text for message in input_messages])
474+
if _ctx_holder is not None:
475+
_ctx_holder["session_context"] = session_context
476+
_ctx_holder["session"] = session
477+
478+
# Build the prompt from the full session context so provider-injected messages are included.
479+
context_messages = session_context.get_messages(include_input=True)
480+
prompt = "\n".join([message.text for message in context_messages])
459481
if session_context.instructions:
460482
prompt = "\n".join(session_context.instructions) + "\n" + prompt
461483
message_options = cast(MessageOptions, {"prompt": prompt})
@@ -517,22 +539,17 @@ def event_handler(event: SessionEvent) -> None:
517539
queue.put_nowait(AgentException(f"GitHub Copilot session error: {error_msg}"))
518540

519541
unsubscribe = copilot_session.on(event_handler)
520-
all_updates: list[AgentResponseUpdate] = []
521542

522543
try:
523544
await copilot_session.send(message_options)
524545

525546
while (item := await queue.get()) is not None:
526547
if isinstance(item, Exception):
527548
raise item
528-
all_updates.append(item)
529549
yield item
530550
finally:
531551
unsubscribe()
532552

533-
if all_updates:
534-
session_context._response = AgentResponse.from_updates(all_updates) # type: ignore[assignment]
535-
await self._run_after_providers(session=session, context=session_context)
536553

537554
async def _run_before_providers(
538555
self,
@@ -543,6 +560,10 @@ async def _run_before_providers(
543560
) -> SessionContext:
544561
"""Run before_run on all context providers and return the session context.
545562
563+
Creates a SessionContext and invokes ``before_run`` on each provider in
564+
forward order. ``BaseHistoryProvider`` instances with
565+
``load_messages=False`` are skipped.
566+
546567
Keyword Args:
547568
session: The conversation session.
548569
input_messages: The normalized input messages.

‎python/packages/github_copilot/tests/test_github_copilot_agent.py‎

Lines changed: 259 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -17,8 +17,10 @@
1717
AgentResponseUpdate,
1818
AgentSession,
1919
BaseContextProvider,
20+
BaseHistoryProvider,
2021
Content,
2122
Message,
23+
SessionContext,
2224
)
2325
from agent_framework.exceptions import AgentException
2426
from copilot.generated.session_events import Data, ErrorClass, Result, SessionEvent, SessionEventType
@@ -1568,3 +1570,260 @@ async def test_context_preserved_across_runs(
15681570
spy.before_run_called = False
15691571
await agent.run("Hello again", session=session)
15701572
assert spy.before_run_called
1573+
1574+
async def test_context_messages_included_in_prompt(
1575+
self,
1576+
mock_client: MagicMock,
1577+
mock_session: MagicMock,
1578+
assistant_message_event: SessionEvent,
1579+
) -> None:
1580+
"""Test that context messages added by providers via extend_messages are included in the prompt."""
1581+
mock_session.send_and_wait.return_value = assistant_message_event
1582+
1583+
class MessageInjectingProvider(BaseContextProvider):
1584+
def __init__(self) -> None:
1585+
super().__init__(source_id="msg-injector")
1586+
1587+
async def before_run(self, *, agent: Any, session: AgentSession, context: Any, state: dict[str, Any]) -> None:
1588+
context.extend_messages(self, [Message(role="user", contents=[Content.from_text("History message")])])
1589+
1590+
async def after_run(self, *, agent: Any, session: AgentSession, context: Any, state: dict[str, Any]) -> None:
1591+
pass
1592+
1593+
provider = MessageInjectingProvider()
1594+
agent = GitHubCopilotAgent(client=mock_client, context_providers=[provider])
1595+
session = agent.create_session()
1596+
await agent.run("Hello", session=session)
1597+
1598+
sent_prompt = mock_session.send_and_wait.call_args[0][0]["prompt"]
1599+
assert "History message" in sent_prompt
1600+
assert "Hello" in sent_prompt
1601+
1602+
async def test_context_messages_included_in_streaming_prompt(
1603+
self,
1604+
mock_client: MagicMock,
1605+
mock_session: MagicMock,
1606+
assistant_delta_event: SessionEvent,
1607+
session_idle_event: SessionEvent,
1608+
) -> None:
1609+
"""Test that context messages added by providers are included in the streaming prompt."""
1610+
events = [assistant_delta_event, session_idle_event]
1611+
1612+
def mock_on(handler: Any) -> Any:
1613+
for event in events:
1614+
handler(event)
1615+
return lambda: None
1616+
1617+
mock_session.on = mock_on
1618+
1619+
class MessageInjectingProvider(BaseContextProvider):
1620+
def __init__(self) -> None:
1621+
super().__init__(source_id="msg-injector")
1622+
1623+
async def before_run(self, *, agent: Any, session: AgentSession, context: Any, state: dict[str, Any]) -> None:
1624+
context.extend_messages(self, [Message(role="user", contents=[Content.from_text("History message")])])
1625+
1626+
async def after_run(self, *, agent: Any, session: AgentSession, context: Any, state: dict[str, Any]) -> None:
1627+
pass
1628+
1629+
provider = MessageInjectingProvider()
1630+
agent = GitHubCopilotAgent(client=mock_client, context_providers=[provider])
1631+
session = agent.create_session()
1632+
async for _ in agent.run("Hello", stream=True, session=session):
1633+
pass
1634+
1635+
sent_prompt = mock_session.send.call_args[0][0]["prompt"]
1636+
assert "History message" in sent_prompt
1637+
assert "Hello" in sent_prompt
1638+
1639+
async def test_after_run_not_called_on_error(
1640+
self,
1641+
mock_client: MagicMock,
1642+
mock_session: MagicMock,
1643+
) -> None:
1644+
"""Test that after_run is NOT called when send_and_wait raises."""
1645+
mock_session.send_and_wait.side_effect = Exception("Request failed")
1646+
spy = SpyContextProvider()
1647+
1648+
agent = GitHubCopilotAgent(client=mock_client, context_providers=[spy])
1649+
session = agent.create_session()
1650+
with pytest.raises(AgentException):
1651+
await agent.run("Hello", session=session)
1652+
1653+
assert spy.before_run_called
1654+
assert not spy.after_run_called
1655+
1656+
async def test_after_run_not_called_on_streaming_error(
1657+
self,
1658+
mock_client: MagicMock,
1659+
mock_session: MagicMock,
1660+
session_error_event: SessionEvent,
1661+
) -> None:
1662+
"""Test that after_run is NOT called when streaming encounters an error."""
1663+
events = [session_error_event]
1664+
1665+
def mock_on(handler: Any) -> Any:
1666+
for event in events:
1667+
handler(event)
1668+
return lambda: None
1669+
1670+
mock_session.on = mock_on
1671+
spy = SpyContextProvider()
1672+
1673+
agent = GitHubCopilotAgent(client=mock_client, context_providers=[spy])
1674+
session = agent.create_session()
1675+
with pytest.raises(AgentException):
1676+
async for _ in agent.run("Hello", stream=True, session=session):
1677+
pass
1678+
1679+
assert spy.before_run_called
1680+
assert not spy.after_run_called
1681+
1682+
async def test_multiple_providers_ordering(
1683+
self,
1684+
mock_client: MagicMock,
1685+
mock_session: MagicMock,
1686+
assistant_message_event: SessionEvent,
1687+
) -> None:
1688+
"""Test that before_run is called in forward order and after_run in reverse order."""
1689+
mock_session.send_and_wait.return_value = assistant_message_event
1690+
call_order: list[str] = []
1691+
1692+
class OrderedProvider(BaseContextProvider):
1693+
def __init__(self, name: str) -> None:
1694+
super().__init__(source_id=name)
1695+
self.name = name
1696+
1697+
async def before_run(self, *, agent: Any, session: AgentSession, context: Any, state: dict[str, Any]) -> None:
1698+
call_order.append(f"before:{self.name}")
1699+
1700+
async def after_run(self, *, agent: Any, session: AgentSession, context: Any, state: dict[str, Any]) -> None:
1701+
call_order.append(f"after:{self.name}")
1702+
1703+
providers = [OrderedProvider("A"), OrderedProvider("B"), OrderedProvider("C")]
1704+
agent = GitHubCopilotAgent(client=mock_client, context_providers=providers)
1705+
session = agent.create_session()
1706+
await agent.run("Hello", session=session)
1707+
1708+
assert call_order == ["before:A", "before:B", "before:C", "after:C", "after:B", "after:A"]
1709+
1710+
async def test_history_provider_skip_when_load_messages_false(
1711+
self,
1712+
mock_client: MagicMock,
1713+
mock_session: MagicMock,
1714+
assistant_message_event: SessionEvent,
1715+
) -> None:
1716+
"""Test that BaseHistoryProvider with load_messages=False is skipped in before_run."""
1717+
mock_session.send_and_wait.return_value = assistant_message_event
1718+
1719+
class StubHistoryProvider(BaseHistoryProvider):
1720+
def __init__(self, *, load_messages: bool = True) -> None:
1721+
super().__init__(source_id="stub-history", load_messages=load_messages)
1722+
self.before_run_called = False
1723+
1724+
async def before_run(self, *, agent: Any, session: AgentSession, context: Any, state: dict[str, Any]) -> None:
1725+
self.before_run_called = True
1726+
1727+
async def after_run(self, *, agent: Any, session: AgentSession, context: Any, state: dict[str, Any]) -> None:
1728+
pass
1729+
1730+
async def get_messages(self, *, session_id: str, **kwargs: Any) -> list[Message]:
1731+
return []
1732+
1733+
async def save_messages(self, *, session_id: str, messages: list[Message], **kwargs: Any) -> None:
1734+
pass
1735+
1736+
skipped_provider = StubHistoryProvider(load_messages=False)
1737+
active_provider = StubHistoryProvider(load_messages=True)
1738+
# Use unique source_ids
1739+
skipped_provider._source_id = "skipped-history"
1740+
active_provider._source_id = "active-history"
1741+
1742+
agent = GitHubCopilotAgent(client=mock_client, context_providers=[skipped_provider, active_provider])
1743+
session = agent.create_session()
1744+
await agent.run("Hello", session=session)
1745+
1746+
assert not skipped_provider.before_run_called
1747+
assert active_provider.before_run_called
1748+
1749+
async def test_streaming_after_run_response_has_updates(
1750+
self,
1751+
mock_client: MagicMock,
1752+
mock_session: MagicMock,
1753+
assistant_delta_event: SessionEvent,
1754+
session_idle_event: SessionEvent,
1755+
) -> None:
1756+
"""Test that streaming after_run context.response contains the aggregated updates."""
1757+
events = [assistant_delta_event, session_idle_event]
1758+
1759+
def mock_on(handler: Any) -> Any:
1760+
for event in events:
1761+
handler(event)
1762+
return lambda: None
1763+
1764+
mock_session.on = mock_on
1765+
spy = SpyContextProvider()
1766+
1767+
agent = GitHubCopilotAgent(client=mock_client, context_providers=[spy])
1768+
session = agent.create_session()
1769+
async for _ in agent.run("Hello", stream=True, session=session):
1770+
pass
1771+
1772+
assert spy.after_run_context is not None
1773+
assert spy.after_run_context.response is not None
1774+
assert len(spy.after_run_context.response.messages) > 0
1775+
assert spy.after_run_context.response.messages[0].text == "Hello"
1776+
1777+
async def test_streaming_after_run_sets_empty_response_on_no_updates(
1778+
self,
1779+
mock_client: MagicMock,
1780+
mock_session: MagicMock,
1781+
session_idle_event: SessionEvent,
1782+
) -> None:
1783+
"""Test that streaming after_run sets an empty response when no updates are yielded."""
1784+
events = [session_idle_event]
1785+
1786+
def mock_on(handler: Any) -> Any:
1787+
for event in events:
1788+
handler(event)
1789+
return lambda: None
1790+
1791+
mock_session.on = mock_on
1792+
spy = SpyContextProvider()
1793+
1794+
agent = GitHubCopilotAgent(client=mock_client, context_providers=[spy])
1795+
session = agent.create_session()
1796+
async for _ in agent.run("Hello", stream=True, session=session):
1797+
pass
1798+
1799+
assert spy.after_run_called
1800+
assert spy.after_run_context.response is not None
1801+
assert len(spy.after_run_context.response.messages) == 0
1802+
1803+
async def test_timeout_preserved_in_session_context_options(
1804+
self,
1805+
mock_client: MagicMock,
1806+
mock_session: MagicMock,
1807+
assistant_message_event: SessionEvent,
1808+
) -> None:
1809+
"""Test that timeout is preserved in session context options for providers."""
1810+
mock_session.send_and_wait.return_value = assistant_message_event
1811+
observed_options: dict[str, Any] = {}
1812+
1813+
class OptionsObserverProvider(BaseContextProvider):
1814+
def __init__(self) -> None:
1815+
super().__init__(source_id="options-observer")
1816+
1817+
async def before_run(self, *, agent: Any, session: AgentSession, context: Any, state: dict[str, Any]) -> None:
1818+
observed_options.update(context.options)
1819+
1820+
async def after_run(self, *, agent: Any, session: AgentSession, context: Any, state: dict[str, Any]) -> None:
1821+
pass
1822+
1823+
provider = OptionsObserverProvider()
1824+
agent = GitHubCopilotAgent(client=mock_client, context_providers=[provider])
1825+
session = agent.create_session()
1826+
await agent.run("Hello", session=session, options={"timeout": 120})
1827+
1828+
assert observed_options.get("timeout") == 120
1829+

0 commit comments

Comments
 (0)