pydantic-ai 0.2.2__tar.gz → 0.2.3__tar.gz

{pydantic_ai-0.2.2 → pydantic_ai-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai
-Version: 0.2.2
+Version: 0.2.3
 Summary: Agent Framework / shim to use Pydantic with LLMs
 Project-URL: Homepage, https://ai.pydantic.dev
 Project-URL: Source, https://github.com/pydantic/pydantic-ai
@@ -28,9 +28,9 @@ Classifier: Topic :: Internet
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
-Requires-Dist: pydantic-ai-slim[anthropic,bedrock,cli,cohere,evals,groq,mcp,mistral,openai,vertexai]==0.2.2
+Requires-Dist: pydantic-ai-slim[a2a,anthropic,bedrock,cli,cohere,evals,groq,mcp,mistral,openai,vertexai]==0.2.3
 Provides-Extra: examples
-Requires-Dist: pydantic-ai-examples==0.2.2; extra == 'examples'
+Requires-Dist: pydantic-ai-examples==0.2.3; extra == 'examples'
 Provides-Extra: logfire
 Requires-Dist: logfire>=3.11.0; extra == 'logfire'
 Description-Content-Type: text/markdown

{pydantic_ai-0.2.2 → pydantic_ai-0.2.3}/pyproject.toml

@@ -46,7 +46,7 @@ requires-python = ">=3.9"
 
 [tool.hatch.metadata.hooks.uv-dynamic-versioning]
 dependencies = [
-    "pydantic-ai-slim[openai,vertexai,groq,anthropic,mistral,cohere,bedrock,cli,mcp,evals]=={{ version }}",
+    "pydantic-ai-slim[openai,vertexai,groq,anthropic,mistral,cohere,bedrock,cli,mcp,evals,a2a]=={{ version }}",
 ]
 
 [tool.hatch.metadata.hooks.uv-dynamic-versioning.optional-dependencies]
@@ -67,6 +67,7 @@ pydantic-ai-slim = { workspace = true }
 pydantic-evals = { workspace = true }
 pydantic-graph = { workspace = true }
 pydantic-ai-examples = { workspace = true }
+fasta2a = { workspace = true }
 
 [tool.uv.workspace]
 members = [
@@ -76,6 +77,7 @@ members = [
     "mcp-run-python",
     "clai",
     "examples",
+    "fasta2a",
 ]
 
 [dependency-groups]
@@ -105,6 +107,7 @@ include = [
     "pydantic_evals/**/*.py",
     "pydantic_graph/**/*.py",
     "mcp-run-python/**/*.py",
+    "fasta2a/**/*.py",
     "examples/**/*.py",
     "clai/**/*.py",
     "tests/**/*.py",
@@ -162,6 +165,7 @@ include = [
     "pydantic_evals",
     "pydantic_graph",
     "mcp-run-python",
+    "fasta2a",
     "tests",
     "examples",
     "clai",
@@ -187,6 +191,8 @@ testpaths = "tests"
 xfail_strict = true
 filterwarnings = [
     "error",
+    # Issue with python-multipart - we don't want to bump the minimum version of starlette.
+    "ignore::PendingDeprecationWarning:starlette",
     # boto3
     "ignore::DeprecationWarning:botocore.*",
     "ignore::RuntimeWarning:pydantic_ai.mcp",
@@ -205,6 +211,8 @@ include = [
     "pydantic_ai_slim/**/*.py",
     "pydantic_evals/**/*.py",
     "pydantic_graph/**/*.py",
+    # TODO(Marcelo): Add 100% coverage for A2A.
+    # "fasta2a/**/*.py",
     "tests/**/*.py",
 ]
 omit = ["tests/test_live.py", "tests/example_modules/*.py"]

{pydantic_ai-0.2.2 → pydantic_ai-0.2.3}/tests/evals/test_evaluator_common.py

@@ -7,6 +7,8 @@ import pytest
 from inline_snapshot import snapshot
 from pytest_mock import MockerFixture
 
+from pydantic_ai.settings import ModelSettings
+
 from ..conftest import try_import
 
 with try_import() as imports_successful:
@@ -222,7 +224,7 @@ async def test_llm_judge_evaluator(mocker: MockerFixture):
     assert result.value is True
     assert result.reason == 'Test passed'
 
-    mock_judge_output.assert_called_once_with('Hello world', 'Content contains a greeting', None)
+    mock_judge_output.assert_called_once_with('Hello world', 'Content contains a greeting', None, None)
 
     # Test with input
     evaluator = LLMJudge(rubric='Output contains input', include_input=True, model='openai:gpt-4o')
@@ -232,7 +234,7 @@ async def test_llm_judge_evaluator(mocker: MockerFixture):
     assert result.reason == 'Test passed'
 
     mock_judge_input_output.assert_called_once_with(
-        {'prompt': 'Hello'}, 'Hello world', 'Output contains input', 'openai:gpt-4o'
+        {'prompt': 'Hello'}, 'Hello world', 'Output contains input', 'openai:gpt-4o', None
     )
 
     # Test with failing result
@@ -244,6 +246,61 @@ async def test_llm_judge_evaluator(mocker: MockerFixture):
     assert result.reason == 'Test failed'
 
 
+@pytest.mark.anyio
+async def test_llm_judge_evaluator_with_model_settings(mocker: MockerFixture):
+    """Test LLMJudge evaluator with specific model_settings."""
+    mock_grading_output = mocker.MagicMock()
+    mock_grading_output.pass_ = True
+    mock_grading_output.reason = 'Test passed with settings'
+
+    mock_judge_output = mocker.patch('pydantic_evals.evaluators.llm_as_a_judge.judge_output')
+    mock_judge_output.return_value = mock_grading_output
+
+    mock_judge_input_output = mocker.patch('pydantic_evals.evaluators.llm_as_a_judge.judge_input_output')
+    mock_judge_input_output.return_value = mock_grading_output
+
+    custom_model_settings = ModelSettings(temperature=0.77)
+
+    ctx = EvaluatorContext(
+        name='test_custom_settings',
+        inputs={'prompt': 'Hello Custom'},
+        metadata=None,
+        expected_output=None,
+        output='Hello world custom settings',
+        duration=0.0,
+        _span_tree=SpanTreeRecordingError('spans were not recorded'),
+        attributes={},
+        metrics={},
+    )
+
+    # Test without input, with custom model_settings
+    evaluator_no_input = LLMJudge(rubric='Greeting with custom settings', model_settings=custom_model_settings)
+    result_no_input = await evaluator_no_input.evaluate(ctx)
+    assert result_no_input.value is True
+    assert result_no_input.reason == 'Test passed with settings'
+    mock_judge_output.assert_called_once_with(
+        'Hello world custom settings', 'Greeting with custom settings', None, custom_model_settings
+    )
+
+    # Test with input, with custom model_settings
+    evaluator_with_input = LLMJudge(
+        rubric='Output contains input with custom settings',
+        include_input=True,
+        model='openai:gpt-3.5-turbo',
+        model_settings=custom_model_settings,
+    )
+    result_with_input = await evaluator_with_input.evaluate(ctx)
+    assert result_with_input.value is True
+    assert result_with_input.reason == 'Test passed with settings'
+    mock_judge_input_output.assert_called_once_with(
+        {'prompt': 'Hello Custom'},
+        'Hello world custom settings',
+        'Output contains input with custom settings',
+        'openai:gpt-3.5-turbo',
+        custom_model_settings,
+    )
+
+
 async def test_python():
     """Test Python evaluator."""
     evaluator = Python(expression='ctx.output > 0')

{pydantic_ai-0.2.2 → pydantic_ai-0.2.3}/tests/evals/test_llm_as_a_judge.py

@@ -6,6 +6,7 @@ from pytest_mock import MockerFixture
 from ..conftest import try_import
 
 with try_import() as imports_successful:
+    from pydantic_ai.settings import ModelSettings
     from pydantic_evals.evaluators.llm_as_a_judge import (
         GradingOutput,
         _stringify,  # pyright: ignore[reportPrivateUsage]
@@ -87,6 +88,34 @@ async def test_judge_output_mock(mocker: MockerFixture):
     assert '<Rubric>\nContent contains a greeting\n</Rubric>' in call_args[0]
 
 
+@pytest.mark.anyio
+async def test_judge_output_with_model_settings_mock(mocker: MockerFixture):
+    """Test judge_output function with model_settings and mocked agent."""
+    mock_result = mocker.MagicMock()
+    mock_result.output = GradingOutput(reason='Test passed with settings', pass_=True, score=1.0)
+    mock_run = mocker.patch('pydantic_ai.Agent.run', return_value=mock_result)
+
+    test_model_settings = ModelSettings(temperature=1)
+
+    grading_output = await judge_output(
+        'Hello world settings',
+        'Content contains a greeting with settings',
+        model_settings=test_model_settings,
+    )
+    assert isinstance(grading_output, GradingOutput)
+    assert grading_output.reason == 'Test passed with settings'
+    assert grading_output.pass_ is True
+    assert grading_output.score == 1.0
+
+    mock_run.assert_called_once()
+    call_args, call_kwargs = mock_run.call_args
+    assert '<Output>\nHello world settings\n</Output>' in call_args[0]
+    assert '<Rubric>\nContent contains a greeting with settings\n</Rubric>' in call_args[0]
+    assert call_kwargs['model_settings'] == test_model_settings
+    # Check if 'model' kwarg is passed, its value will be the default model or None
+    assert 'model' in call_kwargs
+
+
 @pytest.mark.anyio
 async def test_judge_input_output_mock(mocker: MockerFixture):
     """Test judge_input_output function with mocked agent."""
@@ -108,3 +137,33 @@ async def test_judge_input_output_mock(mocker: MockerFixture):
     assert '<Input>\nHello\n</Input>' in call_args[0]
     assert '<Output>\nHello world\n</Output>' in call_args[0]
     assert '<Rubric>\nOutput contains input\n</Rubric>' in call_args[0]
+
+
+@pytest.mark.anyio
+async def test_judge_input_output_with_model_settings_mock(mocker: MockerFixture):
+    """Test judge_input_output function with model_settings and mocked agent."""
+    mock_result = mocker.MagicMock()
+    mock_result.output = GradingOutput(reason='Test passed with settings', pass_=True, score=1.0)
+    mock_run = mocker.patch('pydantic_ai.Agent.run', return_value=mock_result)
+
+    test_model_settings = ModelSettings(temperature=1)
+
+    result = await judge_input_output(
+        'Hello settings',
+        'Hello world with settings',
+        'Output contains input with settings',
+        model_settings=test_model_settings,
+    )
+    assert isinstance(result, GradingOutput)
+    assert result.reason == 'Test passed with settings'
+    assert result.pass_ is True
+    assert result.score == 1.0
+
+    mock_run.assert_called_once()
+    call_args, call_kwargs = mock_run.call_args
+    assert '<Input>\nHello settings\n</Input>' in call_args[0]
+    assert '<Output>\nHello world with settings\n</Output>' in call_args[0]
+    assert '<Rubric>\nOutput contains input with settings\n</Rubric>' in call_args[0]
+    assert call_kwargs['model_settings'] == test_model_settings
+    # Check if 'model' kwarg is passed, its value will be the default model or None
+    assert 'model' in call_kwargs

{pydantic_ai-0.2.2 → pydantic_ai-0.2.3}/tests/json_body_serializer.py

@@ -6,12 +6,12 @@ from typing import TYPE_CHECKING, Any
 import yaml
 
 if TYPE_CHECKING:
-    from yaml import Dumper, Loader
+    from yaml import Dumper
 else:
     try:
-        from yaml import CDumper as Dumper, CLoader as Loader
-    except ImportError:
-        from yaml import Dumper, Loader
+        from yaml import CDumper as Dumper
+    except ImportError:  # pragma: no cover
+        from yaml import Dumper
 
 FILTERED_HEADER_PREFIXES = ['anthropic-', 'cf-', 'x-']
 FILTERED_HEADERS = {'authorization', 'date', 'request-id', 'server', 'user-agent', 'via', 'set-cookie', 'api-key'}
@@ -35,7 +35,7 @@ LiteralDumper.add_representer(str, str_presenter)
 
 
 def deserialize(cassette_string: str):
-    cassette_dict = yaml.load(cassette_string, Loader=Loader)
+    cassette_dict = yaml.safe_load(cassette_string)
     for interaction in cassette_dict['interactions']:
         for kind, data in interaction.items():
             parsed_body = data.pop('parsed_body', None)
@@ -45,7 +45,7 @@ def deserialize(cassette_string: str):
     return cassette_dict
 
 
-def serialize(cassette_dict: Any):
+def serialize(cassette_dict: Any):  # pragma: lax no cover
     for interaction in cassette_dict['interactions']:
         for _kind, data in interaction.items():
             headers: dict[str, list[str]] = data.get('headers', {})

pydantic_ai-0.2.3/tests/test_a2a.py

@@ -0,0 +1,352 @@
+import anyio
+import httpx
+import pytest
+from asgi_lifespan import LifespanManager
+from inline_snapshot import snapshot
+
+from pydantic_ai import Agent
+from pydantic_ai.messages import ModelMessage, ModelResponse, ToolCallPart
+from pydantic_ai.models.function import AgentInfo, FunctionModel
+
+from .conftest import IsDatetime, IsStr, try_import
+
+with try_import() as imports_successful:
+    from fasta2a.client import A2AClient
+    from fasta2a.schema import DataPart, FilePart, Message, TextPart
+    from fasta2a.storage import InMemoryStorage
+
+
+pytestmark = [
+    pytest.mark.skipif(not imports_successful(), reason='fasta2a not installed'),
+    pytest.mark.anyio,
+    pytest.mark.vcr,
+]
+
+
+def return_string(_: list[ModelMessage], info: AgentInfo) -> ModelResponse:
+    assert info.output_tools is not None
+    args_json = '{"response": ["foo", "bar"]}'
+    return ModelResponse(parts=[ToolCallPart(info.output_tools[0].name, args_json)])
+
+
+model = FunctionModel(return_string)
+
+
+async def test_a2a_runtime_error_without_lifespan():
+    agent = Agent(model=model, output_type=tuple[str, str])
+    app = agent.to_a2a()
+
+    transport = httpx.ASGITransport(app)
+    async with httpx.AsyncClient(transport=transport) as http_client:
+        a2a_client = A2AClient(http_client=http_client)
+
+        message = Message(role='user', parts=[TextPart(text='Hello, world!', type='text')])
+
+        with pytest.raises(RuntimeError, match='TaskManager was not properly initialized.'):
+            await a2a_client.send_task(message=message)
+
+
+async def test_a2a_simple():
+    agent = Agent(model=model, output_type=tuple[str, str])
+    app = agent.to_a2a()
+
+    async with LifespanManager(app):
+        transport = httpx.ASGITransport(app)
+        async with httpx.AsyncClient(transport=transport) as http_client:
+            a2a_client = A2AClient(http_client=http_client)
+
+            message = Message(role='user', parts=[TextPart(text='Hello, world!', type='text')])
+            response = await a2a_client.send_task(message=message)
+            assert response == snapshot(
+                {
+                    'jsonrpc': '2.0',
+                    'id': IsStr(),
+                    'result': {
+                        'id': IsStr(),
+                        'session_id': IsStr(),
+                        'status': {'state': 'submitted', 'timestamp': IsDatetime(iso_string=True)},
+                        'history': [{'role': 'user', 'parts': [{'type': 'text', 'text': 'Hello, world!'}]}],
+                    },
+                }
+            )
+
+            assert 'result' in response
+            task_id = response['result']['id']
+
+            while task := await a2a_client.get_task(task_id):
+                if 'result' in task and task['result']['status']['state'] == 'completed':
+                    break
+                await anyio.sleep(0.1)
+            assert task == snapshot(
+                {
+                    'jsonrpc': '2.0',
+                    'id': None,
+                    'result': {
+                        'id': IsStr(),
+                        'session_id': IsStr(),
+                        'status': {'state': 'completed', 'timestamp': IsDatetime(iso_string=True)},
+                        'history': [{'role': 'user', 'parts': [{'type': 'text', 'text': 'Hello, world!'}]}],
+                        'artifacts': [
+                            {'name': 'result', 'parts': [{'type': 'text', 'text': "('foo', 'bar')"}], 'index': 0}
+                        ],
+                    },
+                }
+            )
+
+
+async def test_a2a_file_message_with_file():
+    agent = Agent(model=model, output_type=tuple[str, str])
+    app = agent.to_a2a()
+
+    async with LifespanManager(app):
+        transport = httpx.ASGITransport(app)
+        async with httpx.AsyncClient(transport=transport) as http_client:
+            a2a_client = A2AClient(http_client=http_client)
+
+            message = Message(
+                role='user',
+                parts=[
+                    FilePart(
+                        type='file',
+                        file={'url': 'https://example.com/file.txt', 'mime_type': 'text/plain'},
+                    )
+                ],
+            )
+            response = await a2a_client.send_task(message=message)
+            assert response == snapshot(
+                {
+                    'jsonrpc': '2.0',
+                    'id': IsStr(),
+                    'result': {
+                        'id': IsStr(),
+                        'session_id': IsStr(),
+                        'status': {'state': 'submitted', 'timestamp': IsDatetime(iso_string=True)},
+                        'history': [
+                            {
+                                'role': 'user',
+                                'parts': [
+                                    {
+                                        'type': 'file',
+                                        'file': {'mime_type': 'text/plain', 'url': 'https://example.com/file.txt'},
+                                    }
+                                ],
+                            }
+                        ],
+                    },
+                }
+            )
+
+            assert 'result' in response
+            task_id = response['result']['id']
+
+            while task := await a2a_client.get_task(task_id):
+                if 'result' in task and task['result']['status']['state'] == 'completed':
+                    break
+                await anyio.sleep(0.1)
+            assert task == snapshot(
+                {
+                    'jsonrpc': '2.0',
+                    'id': None,
+                    'result': {
+                        'id': IsStr(),
+                        'session_id': IsStr(),
+                        'status': {'state': 'completed', 'timestamp': IsDatetime(iso_string=True)},
+                        'history': [
+                            {
+                                'role': 'user',
+                                'parts': [
+                                    {
+                                        'type': 'file',
+                                        'file': {'mime_type': 'text/plain', 'url': 'https://example.com/file.txt'},
+                                    }
+                                ],
+                            }
+                        ],
+                        'artifacts': [
+                            {'name': 'result', 'parts': [{'type': 'text', 'text': "('foo', 'bar')"}], 'index': 0}
+                        ],
+                    },
+                }
+            )
+
+
+async def test_a2a_file_message_with_file_content():
+    agent = Agent(model=model, output_type=tuple[str, str])
+    app = agent.to_a2a()
+
+    async with LifespanManager(app):
+        transport = httpx.ASGITransport(app)
+        async with httpx.AsyncClient(transport=transport) as http_client:
+            a2a_client = A2AClient(http_client=http_client)
+
+            message = Message(
+                role='user',
+                parts=[
+                    FilePart(type='file', file={'data': 'foo', 'mime_type': 'text/plain'}),
+                ],
+            )
+            response = await a2a_client.send_task(message=message)
+            assert response == snapshot(
+                {
+                    'jsonrpc': '2.0',
+                    'id': IsStr(),
+                    'result': {
+                        'id': IsStr(),
+                        'session_id': IsStr(),
+                        'status': {'state': 'submitted', 'timestamp': IsDatetime(iso_string=True)},
+                        'history': [
+                            {
+                                'role': 'user',
+                                'parts': [{'type': 'file', 'file': {'mime_type': 'text/plain', 'data': 'foo'}}],
+                            }
+                        ],
+                    },
+                }
+            )
+
+            assert 'result' in response
+            task_id = response['result']['id']
+
+            while task := await a2a_client.get_task(task_id):
+                if 'result' in task and task['result']['status']['state'] == 'completed':
+                    break
+                await anyio.sleep(0.1)
+            assert task == snapshot(
+                {
+                    'jsonrpc': '2.0',
+                    'id': None,
+                    'result': {
+                        'id': IsStr(),
+                        'session_id': IsStr(),
+                        'status': {'state': 'completed', 'timestamp': IsDatetime(iso_string=True)},
+                        'history': [
+                            {
+                                'role': 'user',
+                                'parts': [{'type': 'file', 'file': {'mime_type': 'text/plain', 'data': 'foo'}}],
+                            }
+                        ],
+                        'artifacts': [
+                            {'name': 'result', 'parts': [{'type': 'text', 'text': "('foo', 'bar')"}], 'index': 0}
+                        ],
+                    },
+                }
+            )
+
+
+async def test_a2a_file_message_with_data():
+    agent = Agent(model=model, output_type=tuple[str, str])
+    app = agent.to_a2a()
+
+    async with LifespanManager(app):
+        transport = httpx.ASGITransport(app)
+        async with httpx.AsyncClient(transport=transport) as http_client:
+            a2a_client = A2AClient(http_client=http_client)
+
+            message = Message(
+                role='user',
+                parts=[DataPart(type='data', data={'foo': 'bar'})],
+            )
+            response = await a2a_client.send_task(message=message)
+            assert response == snapshot(
+                {
+                    'jsonrpc': '2.0',
+                    'id': IsStr(),
+                    'result': {
+                        'id': IsStr(),
+                        'session_id': IsStr(),
+                        'status': {'state': 'submitted', 'timestamp': IsDatetime(iso_string=True)},
+                        'history': [{'role': 'user', 'parts': [{'type': 'data', 'data': {'foo': 'bar'}}]}],
+                    },
+                }
+            )
+
+            assert 'result' in response
+            task_id = response['result']['id']
+
+            while task := await a2a_client.get_task(task_id):
+                if 'result' in task and task['result']['status']['state'] == 'failed':
+                    break
+                await anyio.sleep(0.1)
+            assert task == snapshot(
+                {
+                    'jsonrpc': '2.0',
+                    'id': None,
+                    'result': {
+                        'id': IsStr(),
+                        'session_id': IsStr(),
+                        'status': {'state': 'failed', 'timestamp': IsDatetime(iso_string=True)},
+                        'history': [{'role': 'user', 'parts': [{'type': 'data', 'data': {'foo': 'bar'}}]}],
+                    },
+                }
+            )
+
+
+async def test_a2a_multiple_messages():
+    agent = Agent(model=model, output_type=tuple[str, str])
+    storage = InMemoryStorage()
+    app = agent.to_a2a(storage=storage)
+
+    async with LifespanManager(app):
+        transport = httpx.ASGITransport(app)
+        async with httpx.AsyncClient(transport=transport) as http_client:
+            a2a_client = A2AClient(http_client=http_client)
+
+            message = Message(role='user', parts=[TextPart(text='Hello, world!', type='text')])
+            response = await a2a_client.send_task(message=message)
+            assert response == snapshot(
+                {
+                    'jsonrpc': '2.0',
+                    'id': IsStr(),
+                    'result': {
+                        'id': IsStr(),
+                        'session_id': IsStr(),
+                        'status': {'state': 'submitted', 'timestamp': IsDatetime(iso_string=True)},
+                        'history': [{'role': 'user', 'parts': [{'type': 'text', 'text': 'Hello, world!'}]}],
+                    },
+                }
+            )
+
+            # NOTE: We include the agent history before we start working on the task.
+            assert 'result' in response
+            task_id = response['result']['id']
+            task = storage.tasks[task_id]
+            assert 'history' in task
+            task['history'].append(Message(role='agent', parts=[TextPart(text='Whats up?', type='text')]))
+
+            response = await a2a_client.get_task(task_id)
+            assert response == snapshot(
+                {
+                    'jsonrpc': '2.0',
+                    'id': None,
+                    'result': {
+                        'id': IsStr(),
+                        'session_id': IsStr(),
+                        'status': {'state': 'submitted', 'timestamp': IsDatetime(iso_string=True)},
+                        'history': [
+                            {'role': 'user', 'parts': [{'type': 'text', 'text': 'Hello, world!'}]},
+                            {'role': 'agent', 'parts': [{'type': 'text', 'text': 'Whats up?'}]},
+                        ],
+                    },
+                }
+            )
+
+            await anyio.sleep(0.1)
+            task = await a2a_client.get_task(task_id)
+            assert task == snapshot(
+                {
+                    'jsonrpc': '2.0',
+                    'id': None,
+                    'result': {
+                        'id': IsStr(),
+                        'session_id': IsStr(),
+                        'status': {'state': 'completed', 'timestamp': IsDatetime(iso_string=True)},
+                        'history': [
+                            {'role': 'user', 'parts': [{'type': 'text', 'text': 'Hello, world!'}]},
+                            {'role': 'agent', 'parts': [{'type': 'text', 'text': 'Whats up?'}]},
+                        ],
+                        'artifacts': [
+                            {'name': 'result', 'parts': [{'type': 'text', 'text': "('foo', 'bar')"}], 'index': 0}
+                        ],
+                    },
+                }
+            )