wehub-resource-sync
808 lines
32 KiB
Python
808 lines
32 KiB
Python
"""Tests for the optional `id` parameter on copilotkit_emit_tool_call.
|
|
|
|
Covers:
|
|
1. LangGraph variant: default UUID generation, custom ID passthrough, return value
|
|
2. CrewAI variant: default UUID generation, custom ID passthrough, return value
|
|
3. AG-UI agent dispatch: custom ID propagates to all three TOOL_CALL events
|
|
4. AG-UI dispatch validation: defensive CopilotKitMisuseError paths for
|
|
missing/invalid id, name, args, non-serializable args, and non-dict value
|
|
"""
|
|
|
|
import asyncio
|
|
import json
|
|
import logging
|
|
import uuid
|
|
import pytest
|
|
from unittest.mock import MagicMock, AsyncMock, patch
|
|
from ag_ui.core import (
|
|
EventType,
|
|
CustomEvent,
|
|
)
|
|
from ag_ui_langgraph import LangGraphAgent as AGUIBase
|
|
from copilotkit.langgraph_agui_agent import (
|
|
LangGraphAGUIAgent,
|
|
CustomEventNames,
|
|
)
|
|
from copilotkit.exc import CopilotKitMisuseError
|
|
|
|
|
|
# ---- Fixtures ----
|
|
|
|
|
|
@pytest.fixture
|
|
def agent():
|
|
"""Create a LangGraphAGUIAgent with a mocked graph."""
|
|
mock_graph = MagicMock()
|
|
mock_graph.get_state = MagicMock()
|
|
a = LangGraphAGUIAgent(name="test", graph=mock_graph)
|
|
a.active_run = {"id": "run-1", "thread_id": "t-1"}
|
|
return a
|
|
|
|
|
|
def _track_parent_dispatches(agent):
|
|
"""Collect events dispatched to the AG-UI base class."""
|
|
from contextlib import contextmanager
|
|
|
|
@contextmanager
|
|
def _ctx():
|
|
dispatched = []
|
|
original = AGUIBase._dispatch_event
|
|
|
|
def _tracking(self_inner, event):
|
|
dispatched.append(event)
|
|
return original(self_inner, event)
|
|
|
|
with patch.object(AGUIBase, "_dispatch_event", new=_tracking):
|
|
yield dispatched
|
|
|
|
return _ctx()
|
|
|
|
|
|
# ---- LangGraph variant tests ----
|
|
|
|
|
|
class TestLangGraphEmitToolCallOptionalId:
|
|
"""copilotkit_emit_tool_call (langgraph) with optional id parameter."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_default_generates_uuid(self):
|
|
"""When no id is provided, a UUID v4 string should be generated and returned."""
|
|
with patch(
|
|
"copilotkit.langgraph.adispatch_custom_event", new_callable=AsyncMock
|
|
) as mock_dispatch:
|
|
from copilotkit.langgraph import copilotkit_emit_tool_call
|
|
|
|
config = {"metadata": {}}
|
|
result = await copilotkit_emit_tool_call(
|
|
config, name="MyTool", args={"key": "val"}
|
|
)
|
|
|
|
assert isinstance(result, str)
|
|
uuid.UUID(result)
|
|
|
|
payload = mock_dispatch.call_args[0][1]
|
|
assert payload["id"] == result
|
|
assert payload["name"] == "MyTool"
|
|
assert payload["args"] == {"key": "val"}
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_custom_id_passthrough(self):
|
|
"""When a custom id is provided, it should be used as-is."""
|
|
with patch(
|
|
"copilotkit.langgraph.adispatch_custom_event", new_callable=AsyncMock
|
|
) as mock_dispatch:
|
|
from copilotkit.langgraph import copilotkit_emit_tool_call
|
|
|
|
config = {"metadata": {}}
|
|
result = await copilotkit_emit_tool_call(
|
|
config, name="MyTool", args={"key": "val"}, tool_call_id="custom-id-123"
|
|
)
|
|
|
|
assert result == "custom-id-123"
|
|
|
|
payload = mock_dispatch.call_args[0][1]
|
|
assert payload["id"] == "custom-id-123"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_returns_generated_id(self):
|
|
"""The return value should be the tool call ID (generated or custom)."""
|
|
with patch(
|
|
"copilotkit.langgraph.adispatch_custom_event", new_callable=AsyncMock
|
|
):
|
|
from copilotkit.langgraph import copilotkit_emit_tool_call
|
|
|
|
config = {"metadata": {}}
|
|
|
|
result_auto = await copilotkit_emit_tool_call(config, name="Tool", args={})
|
|
assert isinstance(result_auto, str)
|
|
assert len(result_auto) > 0
|
|
|
|
result_custom = await copilotkit_emit_tool_call(
|
|
config, name="Tool", args={}, tool_call_id="my-id"
|
|
)
|
|
assert result_custom == "my-id"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_none_id_generates_uuid(self):
|
|
"""Explicitly passing tool_call_id=None should behave the same as omitting it."""
|
|
with patch(
|
|
"copilotkit.langgraph.adispatch_custom_event", new_callable=AsyncMock
|
|
) as mock_dispatch:
|
|
from copilotkit.langgraph import copilotkit_emit_tool_call
|
|
|
|
config = {"metadata": {}}
|
|
result = await copilotkit_emit_tool_call(
|
|
config, name="Tool", args={}, tool_call_id=None
|
|
)
|
|
|
|
assert isinstance(result, str)
|
|
uuid.UUID(result)
|
|
assert mock_dispatch.call_args[0][1]["id"] == result
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_empty_string_id_raises(self):
|
|
"""Passing an empty string should raise ValueError."""
|
|
with patch(
|
|
"copilotkit.langgraph.adispatch_custom_event", new_callable=AsyncMock
|
|
):
|
|
from copilotkit.langgraph import copilotkit_emit_tool_call
|
|
|
|
config = {"metadata": {}}
|
|
with pytest.raises(ValueError, match="non-empty string"):
|
|
await copilotkit_emit_tool_call(
|
|
config, name="Tool", args={}, tool_call_id=""
|
|
)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_whitespace_only_id_raises(self):
|
|
"""Passing a whitespace-only string should raise ValueError."""
|
|
with patch(
|
|
"copilotkit.langgraph.adispatch_custom_event", new_callable=AsyncMock
|
|
):
|
|
from copilotkit.langgraph import copilotkit_emit_tool_call
|
|
|
|
config = {"metadata": {}}
|
|
with pytest.raises(ValueError, match="non-empty string"):
|
|
await copilotkit_emit_tool_call(
|
|
config, name="Tool", args={}, tool_call_id=" "
|
|
)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_whitespace_only_name_raises(self):
|
|
"""Passing a whitespace-only name should raise CopilotKitMisuseError."""
|
|
with patch(
|
|
"copilotkit.langgraph.adispatch_custom_event", new_callable=AsyncMock
|
|
):
|
|
from copilotkit.langgraph import copilotkit_emit_tool_call
|
|
|
|
config = {"metadata": {}}
|
|
with pytest.raises(CopilotKitMisuseError, match="non-empty string"):
|
|
await copilotkit_emit_tool_call(config, name=" ", args={})
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_empty_name_raises(self):
|
|
"""Passing an empty name should raise CopilotKitMisuseError."""
|
|
with patch(
|
|
"copilotkit.langgraph.adispatch_custom_event", new_callable=AsyncMock
|
|
):
|
|
from copilotkit.langgraph import copilotkit_emit_tool_call
|
|
|
|
config = {"metadata": {}}
|
|
with pytest.raises(CopilotKitMisuseError, match="non-empty string"):
|
|
await copilotkit_emit_tool_call(config, name="", args={})
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_non_serializable_args_raises(self):
|
|
"""Passing non-JSON-serializable args should raise CopilotKitMisuseError."""
|
|
with patch(
|
|
"copilotkit.langgraph.adispatch_custom_event", new_callable=AsyncMock
|
|
):
|
|
from copilotkit.langgraph import copilotkit_emit_tool_call
|
|
|
|
config = {"metadata": {}}
|
|
with pytest.raises(CopilotKitMisuseError, match="not JSON-serializable"):
|
|
await copilotkit_emit_tool_call(
|
|
config, name="Tool", args={"bad": {1, 2, 3}}
|
|
)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_cancelled_error_propagates_from_post_dispatch_sleep(self):
|
|
"""CancelledError during the shielded post-dispatch sleep must propagate."""
|
|
with patch(
|
|
"copilotkit.langgraph.adispatch_custom_event", new_callable=AsyncMock
|
|
) as mock_dispatch:
|
|
from copilotkit.langgraph import copilotkit_emit_tool_call
|
|
|
|
config = {"metadata": {}}
|
|
|
|
async def _run_and_cancel():
|
|
task = asyncio.current_task()
|
|
# Schedule cancellation after dispatch completes but during sleep
|
|
original_sleep = asyncio.sleep
|
|
|
|
async def _cancel_during_sleep(delay):
|
|
task.cancel()
|
|
await original_sleep(0)
|
|
|
|
with patch(
|
|
"copilotkit.langgraph.asyncio.sleep",
|
|
side_effect=_cancel_during_sleep,
|
|
):
|
|
with patch(
|
|
"copilotkit.langgraph.asyncio.shield",
|
|
side_effect=lambda coro: coro,
|
|
):
|
|
return await copilotkit_emit_tool_call(
|
|
config,
|
|
name="CancelTool",
|
|
args={},
|
|
tool_call_id="cancel-test-id",
|
|
)
|
|
|
|
with pytest.raises(asyncio.CancelledError):
|
|
await _run_and_cancel()
|
|
|
|
mock_dispatch.assert_called_once()
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_cancelled_error_logs_warning(self, caplog):
|
|
"""CancelledError during post-dispatch sleep should log with the tool_call_id."""
|
|
with patch(
|
|
"copilotkit.langgraph.adispatch_custom_event", new_callable=AsyncMock
|
|
):
|
|
from copilotkit.langgraph import copilotkit_emit_tool_call
|
|
|
|
config = {"metadata": {}}
|
|
|
|
async def _cancel_sleep(delay):
|
|
raise asyncio.CancelledError()
|
|
|
|
with caplog.at_level(logging.WARNING, logger="copilotkit.langgraph"):
|
|
with patch(
|
|
"copilotkit.langgraph.asyncio.sleep", side_effect=_cancel_sleep
|
|
):
|
|
with patch(
|
|
"copilotkit.langgraph.asyncio.shield",
|
|
side_effect=lambda coro: coro,
|
|
):
|
|
with pytest.raises(asyncio.CancelledError):
|
|
await copilotkit_emit_tool_call(
|
|
config,
|
|
name="Tool",
|
|
args={},
|
|
tool_call_id="log-cancel-id",
|
|
)
|
|
|
|
assert any("log-cancel-id" in record.message for record in caplog.records)
|
|
|
|
|
|
# ---- CrewAI variant tests ----
|
|
|
|
try:
|
|
import crewai # noqa: F401
|
|
|
|
_has_crewai = True
|
|
except ImportError:
|
|
_has_crewai = False
|
|
|
|
|
|
@pytest.mark.skipif(not _has_crewai, reason="crewai not installed")
|
|
class TestCrewAIEmitToolCallOptionalId:
|
|
"""copilotkit_emit_tool_call (crewai) with optional id parameter."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_default_generates_uuid(self):
|
|
"""When no id is provided, a UUID v4 string should be generated and returned."""
|
|
with patch(
|
|
"copilotkit.crewai.crewai_sdk.queue_put", new_callable=AsyncMock
|
|
) as mock_queue:
|
|
from copilotkit.crewai.crewai_sdk import copilotkit_emit_tool_call
|
|
|
|
result = await copilotkit_emit_tool_call(name="MyTool", args={"key": "val"})
|
|
|
|
assert isinstance(result, str)
|
|
uuid.UUID(result)
|
|
|
|
start_ev, args_ev, end_ev = mock_queue.call_args[0]
|
|
assert start_ev["actionExecutionId"] == result
|
|
assert start_ev["parentMessageId"] == result
|
|
assert start_ev["actionName"] == "MyTool"
|
|
assert args_ev["actionExecutionId"] == result
|
|
assert json.loads(args_ev["args"]) == {"key": "val"}
|
|
assert end_ev["actionExecutionId"] == result
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_custom_id_passthrough(self):
|
|
"""When a custom id is provided, it should be used as the message_id."""
|
|
with patch(
|
|
"copilotkit.crewai.crewai_sdk.queue_put", new_callable=AsyncMock
|
|
) as mock_queue:
|
|
from copilotkit.crewai.crewai_sdk import copilotkit_emit_tool_call
|
|
|
|
result = await copilotkit_emit_tool_call(
|
|
name="MyTool", args={"key": "val"}, tool_call_id="crew-custom-id"
|
|
)
|
|
|
|
assert result == "crew-custom-id"
|
|
|
|
start_ev, args_ev, end_ev = mock_queue.call_args[0]
|
|
assert start_ev["actionExecutionId"] == "crew-custom-id"
|
|
assert start_ev["parentMessageId"] == "crew-custom-id"
|
|
assert args_ev["actionExecutionId"] == "crew-custom-id"
|
|
assert end_ev["actionExecutionId"] == "crew-custom-id"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_returns_id(self):
|
|
"""Should return the tool call ID regardless of whether it was auto or custom."""
|
|
with patch("copilotkit.crewai.crewai_sdk.queue_put", new_callable=AsyncMock):
|
|
from copilotkit.crewai.crewai_sdk import copilotkit_emit_tool_call
|
|
|
|
result_auto = await copilotkit_emit_tool_call(name="T", args={})
|
|
assert isinstance(result_auto, str)
|
|
assert len(result_auto) > 0
|
|
|
|
result_custom = await copilotkit_emit_tool_call(
|
|
name="T", args={}, tool_call_id="explicit"
|
|
)
|
|
assert result_custom == "explicit"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_empty_string_id_raises(self):
|
|
"""Passing an empty string should raise ValueError."""
|
|
with patch("copilotkit.crewai.crewai_sdk.queue_put", new_callable=AsyncMock):
|
|
from copilotkit.crewai.crewai_sdk import copilotkit_emit_tool_call
|
|
|
|
with pytest.raises(ValueError, match="non-empty string"):
|
|
await copilotkit_emit_tool_call(name="Tool", args={}, tool_call_id="")
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_whitespace_only_id_raises(self):
|
|
"""Passing a whitespace-only string should raise ValueError."""
|
|
with patch("copilotkit.crewai.crewai_sdk.queue_put", new_callable=AsyncMock):
|
|
from copilotkit.crewai.crewai_sdk import copilotkit_emit_tool_call
|
|
|
|
with pytest.raises(ValueError, match="non-empty string"):
|
|
await copilotkit_emit_tool_call(
|
|
name="Tool", args={}, tool_call_id=" "
|
|
)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_none_id_generates_uuid(self):
|
|
"""Explicitly passing tool_call_id=None should behave the same as omitting it."""
|
|
with patch("copilotkit.crewai.crewai_sdk.queue_put", new_callable=AsyncMock):
|
|
from copilotkit.crewai.crewai_sdk import copilotkit_emit_tool_call
|
|
|
|
result = await copilotkit_emit_tool_call(
|
|
name="Tool", args={}, tool_call_id=None
|
|
)
|
|
assert isinstance(result, str)
|
|
uuid.UUID(result)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_whitespace_only_name_raises(self):
|
|
"""Passing a whitespace-only name should raise CopilotKitMisuseError."""
|
|
with patch("copilotkit.crewai.crewai_sdk.queue_put", new_callable=AsyncMock):
|
|
from copilotkit.crewai.crewai_sdk import copilotkit_emit_tool_call
|
|
|
|
with pytest.raises(CopilotKitMisuseError, match="non-empty string"):
|
|
await copilotkit_emit_tool_call(name=" ", args={})
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_non_serializable_args_raises(self):
|
|
"""Passing non-JSON-serializable args should raise CopilotKitMisuseError."""
|
|
with patch("copilotkit.crewai.crewai_sdk.queue_put", new_callable=AsyncMock):
|
|
from copilotkit.crewai.crewai_sdk import copilotkit_emit_tool_call
|
|
|
|
with pytest.raises(CopilotKitMisuseError, match="not JSON-serializable"):
|
|
await copilotkit_emit_tool_call(name="Tool", args={"bad": {1, 2, 3}})
|
|
|
|
|
|
# ---- CrewAI variant: compensating action_execution_end tests ----
|
|
|
|
|
|
@pytest.mark.skipif(not _has_crewai, reason="crewai not installed")
|
|
class TestCrewAICompensatingEnd:
|
|
"""Tests for the compensating action_execution_end when dispatch fails mid-stream.
|
|
|
|
queue_put is called once with all three events (start, args, end) in a single
|
|
batch for atomicity. If the batch fails, a compensating end is always attempted
|
|
as a best-effort measure — an orphaned END is harmless, but an orphaned START
|
|
hangs the client UI.
|
|
"""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_batch_failure_emits_compensating_end(self):
|
|
"""If the batched queue_put fails, a compensating end is emitted."""
|
|
call_count = 0
|
|
|
|
async def _failing_queue_put(*events):
|
|
nonlocal call_count
|
|
call_count += 1
|
|
if call_count == 1:
|
|
raise RuntimeError("batch failed")
|
|
|
|
with patch("copilotkit.crewai.crewai_sdk.queue_put", new=_failing_queue_put):
|
|
from copilotkit.crewai.crewai_sdk import copilotkit_emit_tool_call
|
|
|
|
with pytest.raises(RuntimeError, match="batch failed"):
|
|
await copilotkit_emit_tool_call(
|
|
name="FailTool", args={"x": 1}, tool_call_id="comp-crew-1"
|
|
)
|
|
|
|
assert call_count == 2
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_compensating_end_failure_reraises_original(self):
|
|
"""If the compensating end also fails, the original error still propagates."""
|
|
call_count = 0
|
|
|
|
async def _failing_queue_put(*events):
|
|
nonlocal call_count
|
|
call_count += 1
|
|
raise RuntimeError(f"queue failure #{call_count}")
|
|
|
|
with patch("copilotkit.crewai.crewai_sdk.queue_put", new=_failing_queue_put):
|
|
from copilotkit.crewai.crewai_sdk import copilotkit_emit_tool_call
|
|
|
|
with pytest.raises(RuntimeError, match="queue failure #1"):
|
|
await copilotkit_emit_tool_call(
|
|
name="FailTool", args={}, tool_call_id="comp-crew-3"
|
|
)
|
|
|
|
assert call_count == 2
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_compensating_end_failure_emits_log(self, caplog):
|
|
"""The logger.error call includes the message_id when compensating end fails."""
|
|
call_count = 0
|
|
|
|
async def _failing_queue_put(*events):
|
|
nonlocal call_count
|
|
call_count += 1
|
|
raise RuntimeError(f"queue failure #{call_count}")
|
|
|
|
with caplog.at_level(logging.ERROR, logger="copilotkit.crewai.crewai_sdk"):
|
|
with patch(
|
|
"copilotkit.crewai.crewai_sdk.queue_put", new=_failing_queue_put
|
|
):
|
|
from copilotkit.crewai.crewai_sdk import copilotkit_emit_tool_call
|
|
|
|
with pytest.raises(RuntimeError):
|
|
await copilotkit_emit_tool_call(
|
|
name="FailTool", args={}, tool_call_id="log-crew-id"
|
|
)
|
|
|
|
assert any("log-crew-id" in record.message for record in caplog.records)
|
|
|
|
|
|
# ---- AG-UI dispatch: custom ID propagates through all events ----
|
|
|
|
|
|
class TestCustomIdPropagatesThroughAGUI:
|
|
"""When a custom id is used, the downstream AG-UI events carry that exact ID."""
|
|
|
|
def test_custom_id_in_all_tool_call_events(self, agent):
|
|
"""TOOL_CALL_START, TOOL_CALL_ARGS, and TOOL_CALL_END should all carry the custom id."""
|
|
with _track_parent_dispatches(agent) as dispatched:
|
|
event = CustomEvent(
|
|
type=EventType.CUSTOM,
|
|
name=CustomEventNames.ManuallyEmitToolCall.value,
|
|
value={
|
|
"id": "user-provided-id-42",
|
|
"name": "CustomTool",
|
|
"args": {"x": 1},
|
|
},
|
|
)
|
|
agent._dispatch_event(event)
|
|
|
|
tool_events = [e for e in dispatched if hasattr(e, "tool_call_id")]
|
|
assert len(tool_events) == 3
|
|
for e in tool_events:
|
|
assert e.tool_call_id == "user-provided-id-42"
|
|
|
|
def test_custom_id_in_parent_message_id(self, agent):
|
|
"""ToolCallStartEvent.parent_message_id should match the custom id."""
|
|
with _track_parent_dispatches(agent) as dispatched:
|
|
event = CustomEvent(
|
|
type=EventType.CUSTOM,
|
|
name=CustomEventNames.ManuallyEmitToolCall.value,
|
|
value={
|
|
"id": "parent-test-id",
|
|
"name": "ParentTool",
|
|
"args": {},
|
|
},
|
|
)
|
|
agent._dispatch_event(event)
|
|
|
|
start_events = [e for e in dispatched if e.type == EventType.TOOL_CALL_START]
|
|
assert len(start_events) == 1
|
|
assert start_events[0].parent_message_id == "parent-test-id"
|
|
|
|
def test_custom_id_with_dict_args_serialized(self, agent):
|
|
"""Custom id + dict args should both work: args JSON-serialized, id preserved."""
|
|
with _track_parent_dispatches(agent) as dispatched:
|
|
event = CustomEvent(
|
|
type=EventType.CUSTOM,
|
|
name=CustomEventNames.ManuallyEmitToolCall.value,
|
|
value={
|
|
"id": "combo-test",
|
|
"name": "ComboTool",
|
|
"args": {"nested": {"deep": True}},
|
|
},
|
|
)
|
|
agent._dispatch_event(event)
|
|
|
|
args_events = [e for e in dispatched if e.type == EventType.TOOL_CALL_ARGS]
|
|
assert len(args_events) == 1
|
|
assert args_events[0].tool_call_id == "combo-test"
|
|
assert json.loads(args_events[0].delta) == {"nested": {"deep": True}}
|
|
|
|
def test_string_args_passed_through_unchanged(self, agent):
|
|
"""When args is already a JSON string, it should be passed through without re-serializing."""
|
|
with _track_parent_dispatches(agent) as dispatched:
|
|
event = CustomEvent(
|
|
type=EventType.CUSTOM,
|
|
name=CustomEventNames.ManuallyEmitToolCall.value,
|
|
value={
|
|
"id": "string-args-test",
|
|
"name": "StringArgsTool",
|
|
"args": '{"x": 1}',
|
|
},
|
|
)
|
|
agent._dispatch_event(event)
|
|
|
|
args_events = [e for e in dispatched if e.type == EventType.TOOL_CALL_ARGS]
|
|
assert len(args_events) == 1
|
|
assert args_events[0].delta == '{"x": 1}'
|
|
|
|
def test_empty_dict_args_does_not_raise(self, agent):
|
|
"""An empty dict for args is valid and should not raise."""
|
|
with _track_parent_dispatches(agent) as dispatched:
|
|
event = CustomEvent(
|
|
type=EventType.CUSTOM,
|
|
name=CustomEventNames.ManuallyEmitToolCall.value,
|
|
value={
|
|
"id": "empty-args-test",
|
|
"name": "EmptyArgsTool",
|
|
"args": {},
|
|
},
|
|
)
|
|
agent._dispatch_event(event)
|
|
|
|
tool_events = [e for e in dispatched if hasattr(e, "tool_call_id")]
|
|
assert len(tool_events) == 3
|
|
|
|
|
|
# ---- AG-UI dispatch: validation negative tests ----
|
|
|
|
|
|
class TestAGUIDispatchValidation:
|
|
"""Negative tests for defensive validation in _dispatch_event."""
|
|
|
|
def test_missing_id_raises(self, agent):
|
|
"""Event with no 'id' field should raise CopilotKitMisuseError."""
|
|
event = CustomEvent(
|
|
type=EventType.CUSTOM,
|
|
name=CustomEventNames.ManuallyEmitToolCall.value,
|
|
value={"name": "Tool", "args": {}},
|
|
)
|
|
with pytest.raises(CopilotKitMisuseError, match="valid 'id'"):
|
|
agent._dispatch_event(event)
|
|
|
|
def test_non_string_id_raises(self, agent):
|
|
"""Event with non-string 'id' should raise CopilotKitMisuseError."""
|
|
event = CustomEvent(
|
|
type=EventType.CUSTOM,
|
|
name=CustomEventNames.ManuallyEmitToolCall.value,
|
|
value={"id": 42, "name": "Tool", "args": {}},
|
|
)
|
|
with pytest.raises(CopilotKitMisuseError, match="valid 'id'"):
|
|
agent._dispatch_event(event)
|
|
|
|
def test_empty_string_id_raises(self, agent):
|
|
"""Event with empty string 'id' should raise CopilotKitMisuseError."""
|
|
event = CustomEvent(
|
|
type=EventType.CUSTOM,
|
|
name=CustomEventNames.ManuallyEmitToolCall.value,
|
|
value={"id": "", "name": "Tool", "args": {}},
|
|
)
|
|
with pytest.raises(CopilotKitMisuseError, match="valid 'id'"):
|
|
agent._dispatch_event(event)
|
|
|
|
def test_whitespace_only_id_raises(self, agent):
|
|
"""Event with whitespace-only 'id' should raise CopilotKitMisuseError."""
|
|
event = CustomEvent(
|
|
type=EventType.CUSTOM,
|
|
name=CustomEventNames.ManuallyEmitToolCall.value,
|
|
value={"id": " ", "name": "Tool", "args": {}},
|
|
)
|
|
with pytest.raises(CopilotKitMisuseError, match="valid 'id'"):
|
|
agent._dispatch_event(event)
|
|
|
|
def test_missing_name_raises(self, agent):
|
|
"""Event with no 'name' field should raise CopilotKitMisuseError."""
|
|
event = CustomEvent(
|
|
type=EventType.CUSTOM,
|
|
name=CustomEventNames.ManuallyEmitToolCall.value,
|
|
value={"id": "valid-id", "args": {}},
|
|
)
|
|
with pytest.raises(CopilotKitMisuseError, match="valid 'name'"):
|
|
agent._dispatch_event(event)
|
|
|
|
def test_whitespace_only_name_raises(self, agent):
|
|
"""Event with whitespace-only 'name' should raise CopilotKitMisuseError."""
|
|
event = CustomEvent(
|
|
type=EventType.CUSTOM,
|
|
name=CustomEventNames.ManuallyEmitToolCall.value,
|
|
value={"id": "valid-id", "name": " ", "args": {}},
|
|
)
|
|
with pytest.raises(CopilotKitMisuseError, match="valid 'name'"):
|
|
agent._dispatch_event(event)
|
|
|
|
def test_missing_args_raises(self, agent):
|
|
"""Event with no 'args' field should raise CopilotKitMisuseError."""
|
|
event = CustomEvent(
|
|
type=EventType.CUSTOM,
|
|
name=CustomEventNames.ManuallyEmitToolCall.value,
|
|
value={"id": "valid-id", "name": "Tool"},
|
|
)
|
|
with pytest.raises(CopilotKitMisuseError, match="missing 'args'"):
|
|
agent._dispatch_event(event)
|
|
|
|
def test_non_serializable_args_raises(self, agent):
|
|
"""Event with non-JSON-serializable args (set) should raise CopilotKitMisuseError."""
|
|
event = CustomEvent(
|
|
type=EventType.CUSTOM,
|
|
name=CustomEventNames.ManuallyEmitToolCall.value,
|
|
value={"id": "valid-id", "name": "Tool", "args": {1, 2, 3}},
|
|
)
|
|
with pytest.raises(CopilotKitMisuseError, match="not JSON-serializable"):
|
|
agent._dispatch_event(event)
|
|
|
|
def test_non_dict_value_raises(self, agent):
|
|
"""Event with non-dict value should raise CopilotKitMisuseError."""
|
|
event = CustomEvent(
|
|
type=EventType.CUSTOM,
|
|
name=CustomEventNames.ManuallyEmitToolCall.value,
|
|
value=None,
|
|
)
|
|
with pytest.raises(CopilotKitMisuseError, match="must be a dict"):
|
|
agent._dispatch_event(event)
|
|
|
|
def test_list_args_accepted(self, agent):
|
|
"""Event with list args should be accepted (JSON-serializable)."""
|
|
with _track_parent_dispatches(agent) as dispatched:
|
|
event = CustomEvent(
|
|
type=EventType.CUSTOM,
|
|
name=CustomEventNames.ManuallyEmitToolCall.value,
|
|
value={"id": "list-args-id", "name": "Tool", "args": [1, 2, 3]},
|
|
)
|
|
agent._dispatch_event(event)
|
|
|
|
args_events = [e for e in dispatched if e.type == EventType.TOOL_CALL_ARGS]
|
|
assert len(args_events) == 1
|
|
assert args_events[0].delta == "[1, 2, 3]"
|
|
|
|
def test_int_args_accepted(self, agent):
|
|
"""Event with int args should be accepted (JSON-serializable)."""
|
|
with _track_parent_dispatches(agent) as dispatched:
|
|
event = CustomEvent(
|
|
type=EventType.CUSTOM,
|
|
name=CustomEventNames.ManuallyEmitToolCall.value,
|
|
value={"id": "int-args-id", "name": "Tool", "args": 42},
|
|
)
|
|
agent._dispatch_event(event)
|
|
|
|
args_events = [e for e in dispatched if e.type == EventType.TOOL_CALL_ARGS]
|
|
assert len(args_events) == 1
|
|
assert args_events[0].delta == "42"
|
|
|
|
|
|
# ---- AG-UI dispatch: compensating TOOL_CALL_END on mid-stream failure ----
|
|
|
|
|
|
class TestAGUICompensatingEnd:
|
|
"""Tests for the compensating TOOL_CALL_END when dispatch fails mid-stream."""
|
|
|
|
def _make_event(self, tool_call_id="comp-test-id"):
|
|
return CustomEvent(
|
|
type=EventType.CUSTOM,
|
|
name=CustomEventNames.ManuallyEmitToolCall.value,
|
|
value={
|
|
"id": tool_call_id,
|
|
"name": "FailTool",
|
|
"args": {"x": 1},
|
|
},
|
|
)
|
|
|
|
def test_failure_after_start_emits_compensating_end(self, agent):
|
|
"""If TOOL_CALL_ARGS fails after START was sent, a compensating END is dispatched."""
|
|
call_count = 0
|
|
original = AGUIBase._dispatch_event
|
|
|
|
def _fail_on_args(self_inner, evt):
|
|
nonlocal call_count
|
|
call_count += 1
|
|
if call_count == 2:
|
|
raise RuntimeError("args dispatch failed")
|
|
return original(self_inner, evt)
|
|
|
|
with patch.object(AGUIBase, "_dispatch_event", new=_fail_on_args):
|
|
with pytest.raises(RuntimeError, match="args dispatch failed"):
|
|
agent._dispatch_event(self._make_event())
|
|
|
|
assert call_count == 3
|
|
|
|
def test_failure_on_start_does_not_emit_compensating_end(self, agent):
|
|
"""If TOOL_CALL_START itself fails, no compensating END is dispatched."""
|
|
call_count = 0
|
|
original = AGUIBase._dispatch_event
|
|
|
|
def _fail_on_start(self_inner, evt):
|
|
nonlocal call_count
|
|
call_count += 1
|
|
if call_count == 1:
|
|
raise RuntimeError("start dispatch failed")
|
|
return original(self_inner, evt)
|
|
|
|
with patch.object(AGUIBase, "_dispatch_event", new=_fail_on_start):
|
|
with pytest.raises(RuntimeError, match="start dispatch failed"):
|
|
agent._dispatch_event(self._make_event())
|
|
|
|
assert call_count == 1
|
|
|
|
def test_compensating_end_failure_reraises_original(self, agent):
|
|
"""If the compensating END also fails, the original error propagates."""
|
|
call_count = 0
|
|
original = AGUIBase._dispatch_event
|
|
|
|
def _fail_on_args_and_end(self_inner, evt):
|
|
nonlocal call_count
|
|
call_count += 1
|
|
if call_count == 1:
|
|
return original(self_inner, evt)
|
|
raise RuntimeError(f"dispatch failure #{call_count}")
|
|
|
|
with patch.object(AGUIBase, "_dispatch_event", new=_fail_on_args_and_end):
|
|
with pytest.raises(RuntimeError, match="dispatch failure #2"):
|
|
agent._dispatch_event(self._make_event())
|
|
|
|
assert call_count == 3
|
|
|
|
def test_compensating_end_failure_emits_log(self, agent, caplog):
|
|
"""The logger.error call includes the tool_call_id when compensating END fails."""
|
|
call_count = 0
|
|
original = AGUIBase._dispatch_event
|
|
|
|
def _fail_on_args_and_end(self_inner, evt):
|
|
nonlocal call_count
|
|
call_count += 1
|
|
if call_count == 1:
|
|
return original(self_inner, evt)
|
|
raise RuntimeError(f"dispatch failure #{call_count}")
|
|
|
|
with caplog.at_level(logging.ERROR, logger="copilotkit.langgraph_agui_agent"):
|
|
with patch.object(AGUIBase, "_dispatch_event", new=_fail_on_args_and_end):
|
|
with pytest.raises(RuntimeError):
|
|
agent._dispatch_event(self._make_event("log-test-id"))
|
|
|
|
assert any("log-test-id" in record.message for record in caplog.records)
|
|
|
|
def test_failure_on_end_emits_compensating_end(self, agent):
|
|
"""If TOOL_CALL_END itself fails, a compensating END is still attempted."""
|
|
call_count = 0
|
|
original = AGUIBase._dispatch_event
|
|
|
|
def _fail_on_end(self_inner, evt):
|
|
nonlocal call_count
|
|
call_count += 1
|
|
if call_count == 3:
|
|
raise RuntimeError("end dispatch failed")
|
|
return original(self_inner, evt)
|
|
|
|
with patch.object(AGUIBase, "_dispatch_event", new=_fail_on_end):
|
|
with pytest.raises(RuntimeError, match="end dispatch failed"):
|
|
agent._dispatch_event(self._make_event("end-fail-id"))
|
|
|
|
assert call_count == 4
|