|
17 | 17 | AgentResponseUpdate, |
18 | 18 | AgentSession, |
19 | 19 | BaseContextProvider, |
| 20 | + BaseHistoryProvider, |
20 | 21 | Content, |
21 | 22 | Message, |
| 23 | + SessionContext, |
22 | 24 | ) |
23 | 25 | from agent_framework.exceptions import AgentException |
24 | 26 | from copilot.generated.session_events import Data, ErrorClass, Result, SessionEvent, SessionEventType |
@@ -1568,3 +1570,260 @@ async def test_context_preserved_across_runs( |
1568 | 1570 | spy.before_run_called = False |
1569 | 1571 | await agent.run("Hello again", session=session) |
1570 | 1572 | 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