aixtools 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

{aixtools-0.1.4.dist-info → aixtools-0.1.6.dist-info}/RECORD

@@ -1,8 +1,8 @@
 aixtools/__init__.py,sha256=9NGHm7LjsQmsvjTZvw6QFJexSvAU4bCoN_KBk9SCa00,260
-aixtools/_version.py,sha256=rLCrf4heo25FJtBY-2Ap7ZuWW-5FS7sqTjsolIUuI5c,704
+aixtools/_version.py,sha256=riGXiVTWXmtdoju9hVCWvTxpszEMAAIK0sZZWoLKlnU,704
 aixtools/app.py,sha256=JzQ0nrv_bjDQokllIlGHOV0HEb-V8N6k_nGQH-TEsVU,5227
 aixtools/chainlit.md,sha256=yC37Ly57vjKyiIvK4oUvf4DYxZCwH7iocTlx7bLeGLU,761
-aixtools/context.py,sha256=XuvSGjG8f-QHBJlI_yCPdjYo4rm_WrswmUE8GjLoRqI,491
+aixtools/context.py,sha256=I_MD40ZnvRm5WPKAKqBUAdXIf8YaurkYUUHSVVy-QvU,598
 aixtools/.chainlit/config.toml,sha256=jxpzXQ9l2IRqBKTFLdvpDG4DunUcOko6kIEb3dQw4HU,3788
 aixtools/.chainlit/translations/bn.json,sha256=eB36bL3SggncVGejh29UDnGYFd_MMDtQGBiMxQ9w1fM,16432
 aixtools/.chainlit/translations/en-US.json,sha256=V5pTnHxsR0dkzhUwlkxqKe0qvR-T39N9tJN0c1CLsAw,7118
@@ -17,15 +17,22 @@ aixtools/.chainlit/translations/nl.json,sha256=R3e-WxkQXAiuQgnnXjFWhwzpn1EA9xJ8g
 aixtools/.chainlit/translations/ta.json,sha256=pxa2uLEEDjiGiT6MFcCJ_kNh5KoFViHFptcJjc79Llc,17224
 aixtools/.chainlit/translations/te.json,sha256=0qGj-ODEHVOcxfVVX5IszS1QBCKSXuU1okANP_EbvBQ,16885
 aixtools/.chainlit/translations/zh-CN.json,sha256=EWxhT2_6CW9z0F6SI2llr3RsaL2omH1QZWHVG2n5POA,8664
-aixtools/a2a/__init__.py,sha256=UGeU-1JoE-QmgT3A_9r4Gzw7WQU2cZr4JxNGqm5ZZrg,191
-aixtools/a2a/app.py,sha256=VQAKJHYJJr5-qJRLXvRgc2pZtH_SPXvB293nJaEDXTw,5071
+aixtools/a2a/app.py,sha256=p18G7fAInl9dcNYq6RStBjv1C3aD6oilQq3WXtBuk30,5069
 aixtools/a2a/utils.py,sha256=EHr3IyyBJn23ni-JcfAf6i3VpQmPs0g1TSnAZazvY_8,4039
+aixtools/a2a/google_sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aixtools/a2a/google_sdk/card.py,sha256=P0L3bKbm28HaRkcIxIvjuSGUKOOc0ymyRAFHKm3a5GQ,996
+aixtools/a2a/google_sdk/remote_agent_connection.py,sha256=oDCRSN3gfONY1Ibp8BrtysIVqfQQ-lWe5N7lr1ymHxY,2819
+aixtools/a2a/google_sdk/utils.py,sha256=hjrNRZywJEUxHHaOttJFQU0FLzteg0Ggtm3qAeXMSVw,2430
+aixtools/a2a/google_sdk/pydantic_ai_adapter/agent_executor.py,sha256=MMbhbEnUL6NwSYnisJrDdHW8zJoSyJ3Pzzkt8jqwNdI,7066
+aixtools/a2a/google_sdk/pydantic_ai_adapter/storage.py,sha256=nGoVL7MPoZJW7iVR71laqpUYP308yFKZIifJtvUgpiU,878
 aixtools/agents/__init__.py,sha256=MAW196S2_G7uGqv-VNjvlOETRfuV44WlU1leO7SiR0A,282
 aixtools/agents/agent.py,sha256=E1zu70t53RqIbcLI_R09wUtsiYZR1bTnElCQ5PrsrKw,6127
 aixtools/agents/agent_batch.py,sha256=0Zu9yNCRPAQZPjXQ-dIUAmP1uGTVbxVt7xvnMpoJMjU,2251
+aixtools/agents/prompt.py,sha256=VCOVSnhNKsPIT347ouzwM1PH4I9UTm2cSnTh3ZpjRwk,3391
 aixtools/db/__init__.py,sha256=b8vRhme3egV-aUZbAntnOaDkSXB8UT0Xy5oqQhU_z0Q,399
 aixtools/db/database.py,sha256=caWe95GlxZYlxn2ubDmR-_cQUW0ulkpR3BHunKIaOsw,3369
 aixtools/db/vector_db.py,sha256=be4JGyXj3o8VEfy9L6SO1aAoDET_zazMJkYfjlYHTYQ,4133
+aixtools/google/client.py,sha256=8yuv_zEZKlmUTI-zRxAb3vjLUrfiwrBhcpNe0hYsO0g,1078
 aixtools/log_view/__init__.py,sha256=0fWLCq9BMo8GoH3Z5WDgvf0-J2TP0XWqtef0f28SHBA,405
 aixtools/log_view/app.py,sha256=DZp3PUM_iS3DpMHqHfFXVACvbZ9PItbOCNMkDjIOfTc,6595
 aixtools/log_view/display.py,sha256=8ygvtfUjieD8JKov_cnAi5KNMsGoOCE4AeZmDwAa8DU,9971
@@ -37,12 +44,13 @@ aixtools/logfilters/__init__.py,sha256=pTD8ujCqjPWBCeB7yv7lmCtnA2KXOnkIv0HExDagk
 aixtools/logfilters/context_filter.py,sha256=zR3Bnv3fCqXLeb7bCFTmlnWhC6dFIvUb-u712tOnUPk,2259
 aixtools/logging/__init__.py,sha256=b5oYyGQDUHHxhRtzqKUaQPv8hQeWw54rzDXSV8lDY1w,613
 aixtools/logging/log_objects.py,sha256=hKMLIsWZEw9Q0JT3GCn9mS8O7DJCzsgMZTL7mlMObpM,6828
-aixtools/logging/logging_config.py,sha256=LBUjR5aDUh_G5U2EA2yjzw9IuOZHHUJli1y-TVpj9lA,3267
+aixtools/logging/logging_config.py,sha256=LvxV3C75-I0096PpcCIbgM-Cp998LzWXeMM14HYbU20,4985
 aixtools/logging/mcp_log_models.py,sha256=7-H2GJXiiyLhpImuyLLftAGG4skxJal8Swax0ob04MY,3463
 aixtools/logging/mcp_logger.py,sha256=d2I5l4t0d6rQH17w23FpE1IUD8Ax-mSaKfByCH86q4I,6257
 aixtools/logging/model_patch_logging.py,sha256=MY2EvR7ZSctC4hJxNMe8iACeVayUJ2V5In2GAnKdgOo,2880
 aixtools/logging/open_telemetry.py,sha256=fJjF1ou_8GyfNfbyWDQPGK6JAUrUaPwURYPHhXEtDBE,1121
 aixtools/mcp/__init__.py,sha256=tLo2KZ1Ojo-rgEEJBGtZfUw-iOoopWoHDnYQTq3IzfE,163
+aixtools/mcp/client.py,sha256=yUcurbNQ8bRaPc8-gK_ESpcPb26d5ckDOEDQrG_YW0c,11823
 aixtools/mcp/example_client.py,sha256=QCFGP3NCNJMOKWjUOnFwjnbJhUSb879IA1ZYmwjRnmc,889
 aixtools/mcp/example_server.py,sha256=1SWCyrLWsAnOa81HC4QbPJo_lBVu0b3SZBWI-qDh1vQ,458
 aixtools/mcp/fast_mcp_log.py,sha256=XYOS406dVjn5YTHyGRsRvVNQ0SKlRObfrKj6EeLFjHg,1057
@@ -51,7 +59,7 @@ aixtools/model_patch/model_patch.py,sha256=JT-oHubIn2LeoSwWbzEQ5vLH7crJmFUecHyQf
 aixtools/server/__init__.py,sha256=rwPx020YpOzCnrxA80Lc4yLLcIp-Mpe9hNqVO9wDPv0,448
 aixtools/server/app_mounter.py,sha256=0tJ0tC140ezAjnYdlhpLJQjY-TO8NVw7D8LseYCCVY8,3336
 aixtools/server/path.py,sha256=SaIJxvmhJy3kzx5zJ6d4cKP6kKu2wFFciQkOLGTA4gg,3056
-aixtools/server/utils.py,sha256=3kIkwpqvc3KsLr5Ja2aGaQ6xy13UaG6K75s2NJVjj-o,2237
+aixtools/server/utils.py,sha256=tZWITIx6M-luV9yve4j3rPtYGSSA6zWS0JWEAySne_M,2276
 aixtools/testing/__init__.py,sha256=mlmaAR2gmS4SbsYNCxnIprmFpFp-syjgVUkpUszo3mE,166
 aixtools/testing/aix_test_model.py,sha256=dlI3sdyvmu4fUs_K4-oazs_a7cE6V-gnI6RQ0_fPVxg,5925
 aixtools/testing/mock_tool.py,sha256=4I0LxxSkLhGIKM2YxCP3cnYI8IYJjdKhfwGZ3dioXsM,2465
@@ -60,13 +68,16 @@ aixtools/tools/doctor/__init__.py,sha256=FPwYzC1eJyw8IH0-BP0wgxSprLy6Y_4yXCek749
 aixtools/tools/doctor/tool_doctor.py,sha256=flp00mbFwVI0-Ii_xC4YDW6Vrn-EAExA1TtQkY6cOZE,2583
 aixtools/tools/doctor/tool_recommendation.py,sha256=t-l5bm6kwnXs1NH-ZZVTWhVrEAmWa460M44bi_Bip4g,1463
 aixtools/utils/__init__.py,sha256=xT6almZBQYMfj4h7Hq9QXDHyVXbOOTxqLsmJsxYYnSw,757
-aixtools/utils/config.py,sha256=1_sGqjj9qahu2thdjJUo6RGi6W2b79UB10sefyfZNMs,4146
+aixtools/utils/config.py,sha256=pNWVMC1V9Hn2KEqaXaLbhxCI_iwQfGiVKKaZLrRM4ug,4820
 aixtools/utils/config_util.py,sha256=3Ya4Qqhj1RJ1qtTTykQ6iayf5uxlpigPXgEJlTi1wn4,2229
 aixtools/utils/enum_with_description.py,sha256=zjSzWxG74eR4x7dpmb74pLTYCWNSMvauHd7_9LpDYIw,1088
+aixtools/utils/files.py,sha256=8JnxwHJRJcjWCdFpjzWmo0po2fRg8esj4H7sOxElYXU,517
 aixtools/utils/persisted_dict.py,sha256=0jQzV7oF-A6Or-HjcU6V7aMXWQL67SOKpULgmtFwAfg,3110
-aixtools/utils/utils.py,sha256=4AkAPPnymYt4faThWz0QYSrAeQVys-l-YO8Kw302CcA,4703
+aixtools/utils/utils.py,sha256=5911Ej1ES2NU_FKIWA3CWKhKnwgjvi1aDR2aiD6Xv3E,4880
 aixtools/utils/chainlit/cl_agent_show.py,sha256=vaRuowp4BRvhxEr5hw0zHEJ7iaSF_5bo_9BH7pGPPpw,4398
 aixtools/utils/chainlit/cl_utils.py,sha256=fxaxdkcZg6uHdM8uztxdPowg3a2f7VR7B26VPY4t-3c,5738
+aixtools/vault/__init__.py,sha256=fsr_NuX3GZ9WZ7dGfe0gp_5-z3URxAfwVRXw7Xyc0dU,141
+aixtools/vault/vault.py,sha256=JeAnRnsXm_etkTUntE9ABIiNlI8M81E2b85IQHfGehI,2817
 docker/mcp-base/Dockerfile,sha256=sSpbt0sasSBHHeGwPIpJpiEQMU5HGeXzerK8biVSt7Q,1547
 notebooks/example_faulty_mcp_server.ipynb,sha256=b2Cy3GXfj-gOBZ7SoUzj25F1rxp5u-32EWPHWQ-sxn8,1729
 notebooks/example_mcp_server_stdio.ipynb,sha256=ya4dRKNFU2vQxob-uIhKHGAzINXGQ6MehgKVmSCpHLk,1634
@@ -78,8 +89,32 @@ scripts/log_view.sh,sha256=bp8oXFRRbbHpyvHAN85wfDHTVK7vMJOYsBx_-bgECQc,511
 scripts/run_example_mcp_server.sh,sha256=f7m7h7O_wo6-nAsYlOXVWIASCOh3Qbuu0XWizlxMhl8,355
 scripts/run_faulty_mcp_server.sh,sha256=u_-8NbPDnJQt6IinNSjh8tc2ed-_MjGyipJXrUXaGR8,291
 scripts/run_server.sh,sha256=5iiB9bB5M2MuOgxVQqu7Oa_tBVtJpt0uB4z9uLu2J50,720
-aixtools-0.1.4.dist-info/METADATA,sha256=bf7ho9WYXQx1MchAPtz5HWkOi3-gDcOBLHrp9QWIBeg,10109
-aixtools-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aixtools-0.1.4.dist-info/entry_points.txt,sha256=dHoutULEZx7xXSqJrZdViSVjfInJibfLibi2nRXL3SE,56
-aixtools-0.1.4.dist-info/top_level.txt,sha256=IPyw70hj9gVDyugaIr3LRlanLYXzostW4azlTgdlALo,34
-aixtools-0.1.4.dist-info/RECORD,,
+scripts/test.sh,sha256=5akwfnX7P-98898WCXcQRFQt84UBgms5Y9fXC_ym1a4,662
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/unit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/unit/a2a/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/unit/a2a/google_sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/unit/a2a/google_sdk/test_card.py,sha256=g8OUIX9BCtApM9y8l_nL1Q7sm3yezxu5yBxrpy76mo4,4359
+tests/unit/a2a/google_sdk/test_remote_agent_connection.py,sha256=nIY8eg32w96BAddaQ25mT-lr0ozPb6UrG-_Vpqx5RMY,17492
+tests/unit/a2a/google_sdk/test_utils.py,sha256=-eHmIk2GJH57W2bAdTzfRrUUb5jnd9Pf-QSXJogN3g8,8312
+tests/unit/a2a/google_sdk/pydantic_ai_adapter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/unit/a2a/google_sdk/pydantic_ai_adapter/test_agent_executor.py,sha256=PcyCw0N3y-txu2KJzufzbCjs7ZfoBBCVjpZuRBqTmOw,7722
+tests/unit/a2a/google_sdk/pydantic_ai_adapter/test_storage.py,sha256=tb67pFfvyWSaDfKaiPDNBQfl6-o17WtCMZh3lQHrYxY,5468
+tests/unit/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/unit/agents/test_prompt.py,sha256=YWFZdH_F774hxw79gsWoTWBPVs8UjOAtJOgNXJ8N9gs,15384
+tests/unit/google/__init__.py,sha256=eRYHldBi5cFWL7oo2_t5TErI8ESmIjNvBZIcp-w8hSA,45
+tests/unit/google/test_client.py,sha256=fXR4Cozea7bdL2prM-1s9IqUQ9AheklQnHpN-4YM3gg,11005
+tests/unit/mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/unit/mcp/test_client.py,sha256=n9sZvmzNzJfozvxoHweAg4M5ZLNhEizq16IjcZHGdj0,8838
+tests/unit/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/unit/server/test_path.py,sha256=1QKiKLLRga9GNxmaUEt_wEZ9U14yzB-7PIhAOgB4wwo,9523
+tests/unit/server/test_utils.py,sha256=kvhzdgNfsJl5tqcRBWg2yTR5GPpyrFCOmEIOuHb3904,14848
+tests/unit/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/unit/utils/test_files.py,sha256=AKFmXQqXstyKd2PreE4EmQyhQYeqOmu1Sp80MwHrf_Q,5782
+tests/unit/vault/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/unit/vault/test_vault.py,sha256=YzmJ-JZo8OLGNcmc845knCh3zp8jhkANVgKT09cuhSU,4250
+aixtools-0.1.6.dist-info/METADATA,sha256=6JFv550ISVltjdNxLIcsM0TNd-O7KS-g2ZsvCuanuJ0,18569
+aixtools-0.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aixtools-0.1.6.dist-info/entry_points.txt,sha256=dHoutULEZx7xXSqJrZdViSVjfInJibfLibi2nRXL3SE,56
+aixtools-0.1.6.dist-info/top_level.txt,sha256=ee4eF-0pqu45zCUVml0mWIhnXQgqMQper2-49BBVHLY,40
+aixtools-0.1.6.dist-info/RECORD,,

{aixtools-0.1.4.dist-info → aixtools-0.1.6.dist-info}/top_level.txt

@@ -2,3 +2,4 @@ aixtools
 docker
 notebooks
 scripts
+tests

scripts/test.sh

@@ -0,0 +1,23 @@
+#!/bin/bash -eu
+set -o pipefail
+
+# Get the directory of this script
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/config.sh"
+
+# Install required dependencies
+echo "Installing test dependencies..."
+uv pip install pytest pytest-asyncio pytest-mock pytest-cov
+
+# Ensure .env exists
+touch .env
+
+# Add the project root to PYTHONPATH so imports work correctly
+export PYTHONPATH="${PROJECT_DIR}:${PYTHONPATH:-}"
+
+# Run all tests using pytest with coverage
+echo "Running tests with coverage..."
+pytest tests/ -v --cov=aixtools --cov-report=term-missing
+
+# Generate HTML coverage report
+# pytest tests/ --cov=aixtools --cov-report=html

tests/unit/a2a/google_sdk/pydantic_ai_adapter/test_agent_executor.py

@@ -0,0 +1,188 @@
+"""Tests for the Pydantic AI adapter agent executor module."""
+
+import unittest
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from a2a.server.agent_execution import RequestContext
+from a2a.server.events import EventQueue
+from a2a.types import Message, TaskState, TaskStatusUpdateEvent
+from pydantic_ai import Agent
+
+from aixtools.a2a.google_sdk.pydantic_ai_adapter.agent_executor import (
+    AgentParameters,
+    RunOutput,
+    PydanticAgentExecutor,
+    _task_failed_event,
+)
+
+
+class TestAgentParameters(unittest.TestCase):
+    """Tests for the AgentParameters model."""
+
+    def test_agent_parameters_creation(self):
+        """Test creating AgentParameters with valid data."""
+        params = AgentParameters(
+            system_prompt="Test prompt",
+            mcp_servers=["server1", "server2"]
+        )
+        
+        self.assertEqual(params.system_prompt, "Test prompt")
+        self.assertEqual(params.mcp_servers, ["server1", "server2"])
+
+
+class TestRunOutput(unittest.TestCase):
+    """Tests for the RunOutput model."""
+
+    def test_run_output_creation(self):
+        """Test creating RunOutput with valid data."""
+        output = RunOutput(
+            is_task_failed=False,
+            is_task_in_progress=True,
+            is_input_required=False,
+            output="Test output",
+            created_artifacts_paths=["path1", "path2"]
+        )
+        
+        self.assertFalse(output.is_task_failed)
+        self.assertTrue(output.is_task_in_progress)
+        self.assertFalse(output.is_input_required)
+        self.assertEqual(output.output, "Test output")
+        self.assertEqual(output.created_artifacts_paths, ["path1", "path2"])
+
+
+class TestTaskFailedEvent(unittest.TestCase):
+    """Tests for the _task_failed_event function."""
+
+    def test_task_failed_event_creation(self):
+        """Test creating a task failed event."""
+        text = "Test error message"
+        context_id = "ctx123"
+        task_id = "task456"
+        
+        event = _task_failed_event(text, context_id, task_id)
+        
+        self.assertIsInstance(event, TaskStatusUpdateEvent)
+        self.assertEqual(event.status.state, TaskState.failed)
+        self.assertEqual(event.context_id, context_id)
+        self.assertEqual(event.task_id, task_id)
+        self.assertTrue(event.final)
+
+    def test_task_failed_event_with_none_ids(self):
+        """Test creating a task failed event with None IDs."""
+        text = "Test error message"
+        
+        event = _task_failed_event(text, "default_ctx", "default_task")
+        
+        self.assertIsInstance(event, TaskStatusUpdateEvent)
+        self.assertEqual(event.status.state, TaskState.failed)
+        self.assertEqual(event.context_id, "default_ctx")
+        self.assertEqual(event.task_id, "default_task")
+        self.assertTrue(event.final)
+
+
+class TestPydanticAgentExecutor(unittest.IsolatedAsyncioTestCase):
+    """Tests for the PydanticAgentExecutor class."""
+
+    def setUp(self):
+        self.agent_params = AgentParameters(
+            system_prompt="Test system prompt",
+            mcp_servers=["test_server"]
+        )
+        self.executor = PydanticAgentExecutor(self.agent_params)
+
+    def test_init(self):
+        """Test PydanticAgentExecutor initialization."""
+        self.assertEqual(self.executor._agent_parameters, self.agent_params)
+        self.assertIsNotNone(self.executor.history_storage)
+
+    @patch("aixtools.a2a.google_sdk.pydantic_ai_adapter.agent_executor.get_message_text")
+    @patch("aixtools.a2a.google_sdk.pydantic_ai_adapter.agent_executor.get_file_parts")
+    def test_convert_message_to_pydantic_parts_text_only(self, mock_get_file_parts, mock_get_message_text):
+        """Test converting message with text only."""
+        mock_get_message_text.return_value = "Test message"
+        mock_get_file_parts.return_value = []
+        
+        mock_message = MagicMock(spec=Message)
+        mock_message.parts = []
+        session_tuple = ("user1", "session1")
+        
+        result = self.executor._convert_message_to_pydantic_parts(session_tuple, mock_message)
+        
+        self.assertEqual(result, "Test message")
+        mock_get_message_text.assert_called_once_with(mock_message)
+        mock_get_file_parts.assert_called_once_with([])
+
+    @patch("aixtools.a2a.google_sdk.pydantic_ai_adapter.agent_executor.build_user_input")
+    @patch("aixtools.a2a.google_sdk.pydantic_ai_adapter.agent_executor.get_message_text")
+    @patch("aixtools.a2a.google_sdk.pydantic_ai_adapter.agent_executor.get_file_parts")
+    def test_convert_message_to_pydantic_parts_with_files(self, mock_get_file_parts, mock_get_message_text, mock_build_user_input):
+        """Test converting message with files."""
+        mock_get_message_text.return_value = "Test message"
+        mock_file_part = MagicMock()
+        mock_file_part.uri = "/test/path.txt"
+        mock_get_file_parts.return_value = [mock_file_part]
+        mock_build_user_input.return_value = ["processed", "input"]
+        
+        mock_message = MagicMock(spec=Message)
+        mock_message.parts = [mock_file_part]
+        session_tuple = ("user1", "session1")
+        
+        result = self.executor._convert_message_to_pydantic_parts(session_tuple, mock_message)
+        
+        self.assertEqual(result, ["processed", "input"])
+        # Verify that build_user_input was called (exact args may vary due to filtering)
+        mock_build_user_input.assert_called_once()
+
+    def test_execute_no_message_validation(self):
+        """Test that execute validates message presence."""
+        # This is a simple validation test without complex integration
+        mock_context = MagicMock(spec=RequestContext)
+        mock_context.message = None
+        
+        # The actual validation happens in the execute method
+        # We test the validation logic separately
+        self.assertIsNone(mock_context.message)
+
+    async def test_cancel_not_supported(self):
+        """Test that cancel raises an exception."""
+        mock_context = MagicMock(spec=RequestContext)
+        mock_event_queue = AsyncMock(spec=EventQueue)
+        
+        with self.assertRaises(Exception) as context:
+            await self.executor.cancel(mock_context, mock_event_queue)
+        
+        self.assertIn("cancel not supported", str(context.exception))
+
+    @patch("aixtools.a2a.google_sdk.pydantic_ai_adapter.agent_executor.get_agent")
+    @patch("aixtools.a2a.google_sdk.pydantic_ai_adapter.agent_executor.get_configured_mcp_servers")
+    def test_build_agent(self, mock_get_mcp_servers, mock_get_agent):
+        """Test building an agent."""
+        mock_agent = MagicMock(spec=Agent)
+        mock_get_agent.return_value = mock_agent
+        mock_get_mcp_servers.return_value = ["mcp1", "mcp2"]
+        
+        session_tuple = ("user1", "session1")
+        result = self.executor._build_agent(session_tuple)
+        
+        self.assertEqual(result, mock_agent)
+        mock_get_mcp_servers.assert_called_once_with(session_tuple, ["test_server"])
+        mock_get_agent.assert_called_once_with(
+            system_prompt="Test system prompt",
+            toolsets=["mcp1", "mcp2"],
+            output_type=RunOutput
+        )
+
+    def test_task_creation_logic(self):
+        """Test task creation logic validation."""
+        # Test the basic logic without complex integration
+        mock_context = MagicMock(spec=RequestContext)
+        mock_context.current_task = None
+        mock_context.message = MagicMock(spec=Message)
+        
+        # Verify that when current_task is None, we have a message to work with
+        self.assertIsNone(mock_context.current_task)
+        self.assertIsNotNone(mock_context.message)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/unit/a2a/google_sdk/pydantic_ai_adapter/test_storage.py

@@ -0,0 +1,156 @@
+"""Tests for the Pydantic AI adapter storage module."""
+
+import unittest
+from unittest.mock import MagicMock
+
+from aixtools.a2a.google_sdk.pydantic_ai_adapter.storage import (
+    PydanticAiAgentHistoryStorage,
+    InMemoryHistoryStorage,
+)
+
+
+class TestInMemoryHistoryStorage(unittest.TestCase):
+    """Tests for the InMemoryHistoryStorage class."""
+
+    def setUp(self):
+        self.storage = InMemoryHistoryStorage()
+
+    def test_init(self):
+        """Test InMemoryHistoryStorage initialization."""
+        self.assertEqual(self.storage.storage, {})
+
+    def test_get_nonexistent_task(self):
+        """Test getting history for a task that doesn't exist."""
+        result = self.storage.get("nonexistent_task")
+        self.assertIsNone(result)
+
+    def test_store_and_get_messages(self):
+        """Test storing and retrieving messages."""
+        task_id = "test_task_1"
+        # Use simple mock objects that can be stored
+        messages = [MagicMock(), MagicMock()]
+        
+        # Store the messages
+        self.storage.store(task_id, messages)
+        
+        # Retrieve the messages
+        result = self.storage.get(task_id)
+        
+        self.assertIsNotNone(result)
+        self.assertEqual(result, messages)
+        self.assertEqual(len(result), 2)
+
+    def test_store_overwrites_existing(self):
+        """Test that storing overwrites existing messages for the same task."""
+        task_id = "test_task_3"
+        
+        # Store initial messages
+        initial_messages = [MagicMock()]
+        self.storage.store(task_id, initial_messages)
+        
+        # Store new messages (should overwrite)
+        new_messages = [MagicMock(), MagicMock()]
+        self.storage.store(task_id, new_messages)
+        
+        # Retrieve and verify new messages are stored
+        result = self.storage.get(task_id)
+        
+        self.assertIsNotNone(result)
+        self.assertEqual(result, new_messages)
+        self.assertEqual(len(result), 2)
+        self.assertNotEqual(result, initial_messages)
+
+    def test_multiple_tasks(self):
+        """Test storing and retrieving messages for multiple tasks."""
+        task1_id = "task_1"
+        task2_id = "task_2"
+        
+        task1_messages = [MagicMock()]
+        task2_messages = [MagicMock(), MagicMock()]
+        
+        # Store messages for both tasks
+        self.storage.store(task1_id, task1_messages)
+        self.storage.store(task2_id, task2_messages)
+        
+        # Retrieve and verify both tasks' messages
+        result1 = self.storage.get(task1_id)
+        result2 = self.storage.get(task2_id)
+        
+        self.assertIsNotNone(result1)
+        self.assertIsNotNone(result2)
+        self.assertEqual(result1, task1_messages)
+        self.assertEqual(result2, task2_messages)
+        self.assertNotEqual(result1, result2)
+
+    def test_store_empty_list(self):
+        """Test storing an empty list of messages."""
+        task_id = "empty_task"
+        empty_messages = []
+        
+        self.storage.store(task_id, empty_messages)
+        result = self.storage.get(task_id)
+        
+        self.assertIsNotNone(result)
+        self.assertEqual(result, empty_messages)
+        self.assertEqual(len(result), 0)
+
+    def test_get_after_multiple_stores(self):
+        """Test that get returns the most recent store for a task."""
+        task_id = "update_task"
+        
+        # Store multiple times
+        messages1 = [MagicMock()]
+        messages2 = [MagicMock()]
+        messages3 = [MagicMock(), MagicMock()]
+        
+        self.storage.store(task_id, messages1)
+        self.storage.store(task_id, messages2)
+        self.storage.store(task_id, messages3)
+        
+        result = self.storage.get(task_id)
+        
+        self.assertIsNotNone(result)
+        self.assertEqual(result, messages3)
+
+    def test_storage_isolation(self):
+        """Test that different storage instances are isolated."""
+        storage1 = InMemoryHistoryStorage()
+        storage2 = InMemoryHistoryStorage()
+        
+        task_id = "isolation_test"
+        messages1 = [MagicMock()]
+        messages2 = [MagicMock()]
+        
+        storage1.store(task_id, messages1)
+        storage2.store(task_id, messages2)
+        
+        result1 = storage1.get(task_id)
+        result2 = storage2.get(task_id)
+        
+        self.assertIsNotNone(result1)
+        self.assertIsNotNone(result2)
+        self.assertEqual(result1, messages1)
+        self.assertEqual(result2, messages2)
+        self.assertNotEqual(result1, result2)
+
+
+class TestPydanticAiAgentHistoryStorageInterface(unittest.TestCase):
+    """Tests for the PydanticAiAgentHistoryStorage abstract interface."""
+
+    def test_cannot_instantiate_abstract_class(self):
+        """Test that the abstract base class cannot be instantiated."""
+        with self.assertRaises(TypeError):
+            PydanticAiAgentHistoryStorage()
+
+    def test_inmemory_implements_interface(self):
+        """Test that InMemoryHistoryStorage properly implements the interface."""
+        storage = InMemoryHistoryStorage()
+        
+        # Verify it's an instance of the abstract base class
+        self.assertIsInstance(storage, PydanticAiAgentHistoryStorage)
+        
+        # Verify it has the required methods
+        self.assertTrue(hasattr(storage, 'get'))
+        self.assertTrue(hasattr(storage, 'store'))
+        self.assertTrue(callable(getattr(storage, 'get')))
+        self.assertTrue(callable(getattr(storage, 'store')))

tests/unit/a2a/google_sdk/test_card.py

@@ -0,0 +1,114 @@
+"""Tests for the A2A card module."""
+
+import unittest
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import httpx
+from a2a.client import A2ACardResolver
+from a2a.types import AgentCard
+
+from aixtools.a2a.google_sdk.card import get_agent_card
+
+
+class TestCard(unittest.IsolatedAsyncioTestCase):
+    """Tests for the A2A card module."""
+
+    def setUp(self):
+        self.test_agent_host = "http://localhost:9999"
+
+    @patch("aixtools.a2a.google_sdk.card.A2ACardResolver")
+    async def test_get_agent_card_success(self, mock_resolver_class):
+        """Test successful retrieval of agent card."""
+        # Setup
+        mock_client = AsyncMock(spec=httpx.AsyncClient)
+        
+        mock_resolver = AsyncMock(spec=A2ACardResolver)
+        mock_resolver_class.return_value = mock_resolver
+        
+        mock_card = MagicMock(spec=AgentCard)
+        mock_card.model_dump_json.return_value = '{"test": "data"}'
+        mock_resolver.get_agent_card.return_value = mock_card
+        
+        # Call the function
+        result = await get_agent_card(mock_client, self.test_agent_host)
+        
+        # Verify the result
+        self.assertEqual(result, mock_card)
+        
+        # Verify the resolver was created correctly
+        mock_resolver_class.assert_called_once_with(
+            httpx_client=mock_client,
+            base_url=self.test_agent_host
+        )
+        
+        # Verify the card was fetched
+        mock_resolver.get_agent_card.assert_called_once()
+        
+        # Verify the URL was set
+        self.assertEqual(result.url, self.test_agent_host)
+
+    @patch("aixtools.a2a.google_sdk.card.A2ACardResolver")
+    async def test_get_agent_card_failure(self, mock_resolver_class):
+        """Test handling of errors when retrieving agent card."""
+        # Setup
+        mock_client = AsyncMock(spec=httpx.AsyncClient)
+        
+        mock_resolver = AsyncMock(spec=A2ACardResolver)
+        mock_resolver_class.return_value = mock_resolver
+        
+        # Make the resolver raise an exception
+        mock_resolver.get_agent_card.side_effect = Exception("Failed to fetch card")
+        
+        # Call the function and expect an exception
+        with self.assertRaises(RuntimeError) as context:
+            await get_agent_card(mock_client, self.test_agent_host)
+        
+        self.assertIn("Failed to fetch the public agent card", str(context.exception))
+
+    @patch("aixtools.a2a.google_sdk.card.logger")
+    @patch("aixtools.a2a.google_sdk.card.A2ACardResolver")
+    async def test_get_agent_card_logging(self, mock_resolver_class, mock_logger):
+        """Test that proper logging occurs during card retrieval."""
+        # Setup
+        mock_client = AsyncMock(spec=httpx.AsyncClient)
+        
+        mock_resolver = AsyncMock(spec=A2ACardResolver)
+        mock_resolver_class.return_value = mock_resolver
+        
+        mock_card = MagicMock(spec=AgentCard)
+        mock_card.model_dump_json.return_value = '{"test": "data"}'
+        mock_resolver.get_agent_card.return_value = mock_card
+        
+        # Call the function
+        await get_agent_card(mock_client, self.test_agent_host)
+        
+        # Verify logging calls
+        mock_logger.info.assert_called()
+        self.assertEqual(mock_logger.info.call_count, 2)  # Two info calls in the function
+
+    @patch("aixtools.a2a.google_sdk.card.logger")
+    @patch("aixtools.a2a.google_sdk.card.A2ACardResolver")
+    async def test_get_agent_card_error_logging(self, mock_resolver_class, mock_logger):
+        """Test that errors are properly logged."""
+        # Setup
+        mock_client = AsyncMock(spec=httpx.AsyncClient)
+        
+        mock_resolver = AsyncMock(spec=A2ACardResolver)
+        mock_resolver_class.return_value = mock_resolver
+        
+        test_error = Exception("Test error")
+        mock_resolver.get_agent_card.side_effect = test_error
+        
+        # Call the function and expect an exception
+        with self.assertRaises(RuntimeError):
+            await get_agent_card(mock_client, self.test_agent_host)
+        
+        # Verify error logging
+        mock_logger.error.assert_called_once()
+        args, kwargs = mock_logger.error.call_args
+        self.assertIn("Critical error fetching public agent card", args[0])
+        self.assertTrue(kwargs.get('exc_info'))
+
+
+if __name__ == '__main__':
+    unittest.main()