aixtools 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

aixtools/mcp/client.py

@@ -0,0 +1,274 @@
+"""MCP server utilities with caching and robust error handling."""
+
+import asyncio
+from typing import Any
+
+import anyio
+from cachebox import TTLCache
+from mcp import types as mcp_types
+from mcp.shared.exceptions import McpError
+from pydantic_ai import RunContext, exceptions
+from pydantic_ai.mcp import MCPServerStreamableHTTP, ToolResult
+from pydantic_ai.toolsets.abstract import ToolsetTool
+
+from aixtools.context import SessionIdTuple
+from aixtools.logging.logging_config import get_logger
+
+MCP_TOOL_CACHE_TTL = 300  # 5 minutes
+DEFAULT_MCP_CONNECTION_TIMEOUT = 30
+CACHE_KEY = "TOOL_LIST"
+
+logger = get_logger(__name__)
+
+
+def get_mcp_headers(session_id_tuple: SessionIdTuple) -> dict[str, str] | None:
+    """
+    Generate headers for MCP server requests.
+
+    This function creates a dictionary of headers to be used in requests to
+    the MCP servers. If a `user_id` or `session_id` is provided, they are
+    included in the headers.
+
+    Args:
+        session_id_tuple (SessionIdTuple): user_id and session_id tuple
+    Returns:
+        dict[str, str] | None: A dictionary of headers for MCP server requests,
+                               or None if neither user_id nor session_id is
+                               provided. When None is returned, default headers
+                               from the client or transport will be used.
+    """
+    headers = None
+    user_id, session_id = session_id_tuple
+    if session_id or user_id:
+        headers = {}
+        if session_id:
+            headers["session-id"] = session_id
+        if user_id:
+            headers["user-id"] = user_id
+    return headers
+
+
+def get_configured_mcp_servers(
+    session_id_tuple: SessionIdTuple, mcp_urls: list[str], timeout: int = DEFAULT_MCP_CONNECTION_TIMEOUT
+):
+    """
+    Retrieve the configured MCP server instances with optional caching.
+
+    Context values `user_id` and `session_id` are included in the headers for each server request.
+
+    Each server is wrapped in a try-except block to isolate them from each other.
+    If one server fails, it won't affect the others.
+
+    Args:
+        session_id_tuple (SessionIdTuple): A tuple containing (user_id, session_id).
+        mcp_urls: (list[str], optional): A list of MCP server URLs to use.
+        timeout (int, optional): Timeout in seconds for MCP server connections. Defaults to 30 seconds.
+    Returns:
+        list[MCPServerStreamableHTTP]: A list of configured MCP server instances. If
+                              neither user_id nor session_id is provided, the
+                              server instances will use default headers defined
+                              by the underlying HTTP implementation.
+    """
+    headers = get_mcp_headers(session_id_tuple)
+
+    return [CachedMCPServerStreamableHTTP(url=url, headers=headers, timeout=timeout) for url in mcp_urls]
+
+
+class CachedMCPServerStreamableHTTP(MCPServerStreamableHTTP):
+    """StreamableHTTP MCP server with cachebox-based TTL caching and robust error handling.
+
+    This class addresses the cancellation propagation issue by:
+    1. Using complete task isolation to prevent CancelledError propagation
+    2. Implementing comprehensive error handling for all MCP operations
+    3. Using fallback mechanisms when servers become unavailable
+    4. Overriding pydantic_ai methods to fix variable scoping bug
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._tools_cache = TTLCache(maxsize=1, ttl=MCP_TOOL_CACHE_TTL)
+        self._tools_list = None
+        self._isolation_lock = asyncio.Lock()  # Lock for critical operations
+
+    async def _run_direct_or_isolated(self, func, fallback, timeout: float | None):
+        """Run a coroutine in complete isolation to prevent cancellation propagation.
+
+        Args:
+            func: Function that returns a coroutine to run
+            fallback: Function that takes an exception and returns a fallback value
+            timeout: Timeout in seconds. If None, then direct run is performed
+
+        Returns:
+            The result of the coroutine on success, or fallback value on any exception
+        """
+        try:
+            if timeout is None:
+                return await func()
+
+            task = asyncio.create_task(func())
+
+            # Use asyncio.wait to prevent cancellation propagation
+            done, pending = await asyncio.wait([task], timeout=timeout)
+
+            if pending:
+                # Cancel pending tasks safely
+                for t in pending:
+                    t.cancel()
+                    try:
+                        await t
+                    except (asyncio.CancelledError, Exception):  # pylint: disable=broad-except
+                        pass
+                raise TimeoutError(f"Task timed out after {timeout} seconds")
+
+            # Get result from completed task
+            completed_task = done.pop()
+            if exc := completed_task.exception():
+                raise exc
+            return completed_task.result()
+
+        except exceptions.ModelRetry as exc:
+            logger.warning("MCP %s: %s ModelRetry: %s", self.url, func.__name__, exc)
+            raise
+        except TimeoutError as exc:
+            logger.warning("MCP %s: %s timed out: %s", self.url, func.__name__, exc)
+            return fallback(exc)
+        except asyncio.CancelledError as exc:
+            logger.warning("MCP %s: %s was cancelled", self.url, func.__name__)
+            return fallback(exc)
+        except anyio.ClosedResourceError as exc:
+            logger.warning("MCP %s: %s closed resource.", self.url, func.__name__)
+            return fallback(exc)
+        except Exception as exc:  # pylint: disable=broad-except
+            if str(exc) == "Attempted to exit cancel scope in a different task than it was entered in":
+                logger.warning("MCP %s: %s enter/exit cancel scope task mismatch.", self.url, func.__name__)
+            else:
+                logger.warning("MCP %s: %s exception %s: %s", self.url, func.__name__, type(exc), exc)
+            return fallback(exc)
+
+    async def __aenter__(self):
+        """Enter the context of the cached MCP server with complete cancellation isolation."""
+        async with self._isolation_lock:
+
+            async def direct_init():
+                return await super(CachedMCPServerStreamableHTTP, self).__aenter__()  # pylint: disable=super-with-arguments
+
+            def fallback(_exc):
+                self._client = None
+                return self
+
+            return await self._run_direct_or_isolated(direct_init, fallback, timeout=None)
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Exit the context of the cached MCP server with complete cancellation isolation."""
+        async with self._isolation_lock:
+            # If we're being cancelled, just clean up
+            if exc_type is asyncio.CancelledError:
+                logger.warning("MCP %s: __aexit__ called with cancellation - cleaning up", self.url)
+                self._client = None
+                return True
+
+            # If client is already None, skip cleanup
+            if not self._client:
+                logger.warning("MCP %s: is uninitialized -> skipping cleanup", self.url)
+                return True
+
+            async def direct_cleanup():
+                return await super(CachedMCPServerStreamableHTTP, self).__aexit__(exc_type, exc_val, exc_tb)  # pylint: disable=super-with-arguments
+
+            def fallback(_exc):
+                self._client = None
+                return True  # Suppress exceptions to prevent propagation
+
+            return await self._run_direct_or_isolated(direct_cleanup, fallback, timeout=None)
+
+    async def list_tools(self) -> list[mcp_types.Tool]:
+        """Override to fix variable scoping bug and add caching with cancellation isolation."""
+        # If client is not initialized, return empty list
+        if not self._client:
+            logger.warning("MCP %s: is uninitialized -> no tools", self.url)
+            return []
+
+        # First, check if we have a valid cached result
+        if CACHE_KEY in self._tools_cache:
+            logger.info("Using cached tools for %s", self.url)
+            return self._tools_cache[CACHE_KEY]
+
+        # Create isolated task to prevent cancellation propagation
+        async def isolated_list_tools():
+            """Isolated list_tools with variable scoping bug fix."""
+            result = None  # Initialize to prevent UnboundLocalError
+            async with self:  # Ensure server is running
+                result = await self._client.list_tools()
+            if result:
+                self._tools_list = result.tools or []
+                self._tools_cache[CACHE_KEY] = self._tools_list
+                logger.info("MCP %s: list_tools returned %d tools", self.url, len(self._tools_list))
+            else:
+                logger.warning("MCP %s: list_tools returned no result", self.url)
+            return self._tools_list or []
+
+        def fallback(_exc):
+            return self._tools_list or []
+
+        return await self._run_direct_or_isolated(isolated_list_tools, fallback, timeout=5.0)
+
+    async def call_tool(
+        self,
+        name: str,
+        tool_args: dict[str, Any],
+        ctx: RunContext[Any],
+        tool: ToolsetTool[Any],
+    ) -> ToolResult:
+        """Call tool with complete isolation from cancellation using patched pydantic_ai."""
+        logger.info("MCP %s: call_tool '%s' started.", self.url, name)
+
+        # Early returns for uninitialized servers
+        if not self._client:
+            logger.warning("MCP %s: is uninitialized -> cannot call tool", self.url)
+            return f"There was an error with calling tool '{name}': MCP connection is uninitialized."
+
+        # Create isolated task to prevent cancellation propagation
+        async def isolated_call_tool():
+            """Isolated call_tool using patched pydantic_ai methods."""
+            return await super(CachedMCPServerStreamableHTTP, self).call_tool(name, tool_args, ctx, tool)  # pylint: disable=super-with-arguments
+
+        def fallback(exc):
+            return f"Exception {type(exc)} when calling tool '{name}': {exc}. Consider alternative approaches."
+
+        result = await self._run_direct_or_isolated(isolated_call_tool, fallback, timeout=3600.0)
+        logger.info("MCP %s: call_tool '%s' completed.", self.url, name)
+        return result
+
+    async def direct_call_tool(
+        self, name: str, args: dict[str, Any], metadata: dict[str, Any] | None = None
+    ) -> ToolResult:
+        """Override to fix variable scoping bug in direct_call_tool."""
+        result = None  # Initialize to prevent UnboundLocalError
+        async with self:  # Ensure server is running
+            try:
+                result = await self._client.send_request(
+                    mcp_types.ClientRequest(
+                        mcp_types.CallToolRequest(
+                            method="tools/call",
+                            params=mcp_types.CallToolRequestParams(
+                                name=name,
+                                arguments=args,
+                                _meta=mcp_types.RequestParams.Meta(**metadata) if metadata else None,
+                            ),
+                        )
+                    ),
+                    mcp_types.CallToolResult,
+                )
+            except McpError as e:
+                raise exceptions.ModelRetry(e.error.message)
+
+        if not result:
+            raise exceptions.ModelRetry("No result from MCP server")
+
+        content = [await self._map_tool_result_part(part) for part in result.content]
+
+        if result.isError:
+            text = "\n".join(str(part) for part in content)
+            raise exceptions.ModelRetry(text)
+
+        return content[0] if len(content) == 1 else content

aixtools/mcp/faulty_mcp.py

@@ -128,19 +128,19 @@ class StarletteErrorMiddleware:  # pylint: disable=too-few-public-methods
                 logger.info("[StarletteErrorMiddleware] Simulating 404 error on DELETE request")
                 should_inject_404 = True
 
-        if http_method == "GET":
-            random_number = random()
-            logger.info("[StarletteErrorMiddleware] random number: %f", random_number)
-            if random_number < config.prob_on_get_crash:
-                logger.warning("[StarletteErrorMiddleware] Simulating server crash on GET request!")
-                os.kill(os.getpid(), 9)
-
         async def logging_receive():
             nonlocal should_inject_404
             message = await receive()
             logger.info("[StarletteErrorMiddleware] Received message: %s", str(message))
 
             if message["type"] == "http.request":  # pylint: disable=too-many-nested-blocks
+                if http_method == "GET":
+                    random_number = random()
+                    logger.info("[StarletteErrorMiddleware] random number: %f", random_number)
+                    if random_number < config.prob_on_get_crash:
+                        logger.warning("[StarletteErrorMiddleware] Simulating server crash on GET request!")
+                        os.kill(os.getpid(), 9)
+
                 body = message.get("body", b"")
                 if body:
                     body_parts.append(body)

aixtools/server/utils.py

@@ -8,7 +8,7 @@ from functools import wraps
 from fastmcp import Context
 from fastmcp.server import dependencies
 
-from ..context import session_id_var, user_id_var
+from ..context import DEFAULT_SESSION_ID, DEFAULT_USER_ID, session_id_var, user_id_var
 
 
 def get_session_id_tuple(ctx: Context | None = None) -> tuple[str, str]:
@@ -18,9 +18,9 @@ def get_session_id_tuple(ctx: Context | None = None) -> tuple[str, str]:
     Returns: Tuple of (user_id, session_id).
     """
     user_id = get_user_id_from_request(ctx)
-    user_id = user_id or user_id_var.get("default_user")
+    user_id = user_id or user_id_var.get(DEFAULT_USER_ID)
     session_id = get_session_id_from_request(ctx)
-    session_id = session_id or session_id_var.get("default_session")
+    session_id = session_id or session_id_var.get(DEFAULT_SESSION_ID)
     return user_id, session_id
 
 

aixtools/utils/config.py

@@ -9,6 +9,7 @@ from pathlib import Path
 from dotenv import dotenv_values, load_dotenv
 
 from aixtools.utils.config_util import find_env_file, get_project_root, get_variable_env
+from aixtools.utils.utils import str2bool
 
 # Debug mode
 LOG_LEVEL = logging.DEBUG
@@ -116,3 +117,8 @@ BEDROCK_MODEL_NAME = get_variable_env("BEDROCK_MODEL_NAME", allow_empty=True)
 # LogFire
 LOGFIRE_TOKEN = get_variable_env("LOGFIRE_TOKEN", True, "")
 LOGFIRE_TRACES_ENDPOINT = get_variable_env("LOGFIRE_TRACES_ENDPOINT", True, "")
+
+# Google Vertex AI
+GOOGLE_GENAI_USE_VERTEXAI = str2bool(get_variable_env("GOOGLE_GENAI_USE_VERTEXAI", True, True))
+GOOGLE_CLOUD_PROJECT = get_variable_env("GOOGLE_CLOUD_PROJECT", True)
+GOOGLE_CLOUD_LOCATION = get_variable_env("GOOGLE_CLOUD_LOCATION", True)

aixtools/utils/files.py

@@ -0,0 +1,17 @@
+"""File utilities"""
+
+
+def is_text_content(data: bytes, mime_type: str) -> bool:
+    """Check if content is text based on mime type and content analysis."""
+    # Check mime type first
+    if mime_type and (
+        mime_type.startswith("text/") or mime_type in ["application/json", "application/xml", "application/javascript"]
+    ):
+        return True
+
+    # Try to decode as UTF-8 to check if it's text
+    try:
+        data.decode("utf-8")
+        return True
+    except UnicodeDecodeError:
+        return False

aixtools/utils/utils.py

@@ -154,6 +154,13 @@ def timestamp_uuid_tuple() -> tuple[str, str, str]:
     return (now.strftime("%Y-%m-%d"), now.strftime("%H:%M:%S"), str(uuid.uuid4()))
 
 
+def str2bool(v: str | None) -> bool:
+    """Convert a string to a boolean value."""
+    if not v:
+        return False
+    return str(v).lower() in ("yes", "true", "on", "1")
+
+
 async def async_iter(items):
     """Asynchronously iterate over items."""
     for item in items:

{aixtools-0.1.3.dist-info → aixtools-0.1.5.dist-info}/METADATA

@@ -1,9 +1,11 @@
 Metadata-Version: 2.4
 Name: aixtools
-Version: 0.1.3
+Version: 0.1.5
 Summary: Tools for AI exploration and debugging
 Requires-Python: >=3.11.2
 Description-Content-Type: text/markdown
+Requires-Dist: a2a-sdk>=0.3.1
+Requires-Dist: cachebox>=5.0.1
 Requires-Dist: chainlit>=2.5.5
 Requires-Dist: colorlog>=6.9.0
 Requires-Dist: fasta2a>=0.5.0

{aixtools-0.1.3.dist-info → aixtools-0.1.5.dist-info}/RECORD

@@ -1,8 +1,8 @@
 aixtools/__init__.py,sha256=9NGHm7LjsQmsvjTZvw6QFJexSvAU4bCoN_KBk9SCa00,260
-aixtools/_version.py,sha256=q5nF98G8SoVeJqaknL0xdyxtv0egsqb0fK06_84Izu8,704
+aixtools/_version.py,sha256=rdxBMYpwzYxiWk08QbPLHSAxHoDfeKWwyaJIAM0lSic,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,21 +44,22 @@ 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
-aixtools/mcp/faulty_mcp.py,sha256=IzayVeElQZRw-sw_QwOwHHh2PuK2T9NKikEi_tt8SPU,12759
+aixtools/mcp/faulty_mcp.py,sha256=uU9vlNGCS_i2k20wocVMaDHTlYjMQxuzjILad9O1cjA,12807
 aixtools/model_patch/model_patch.py,sha256=JT-oHubIn2LeoSwWbzEQ5vLH7crJmFUecHyQfaAFHa0,1813
 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,11 +68,12 @@ 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=x6zfDDAwD0dQglRJnlENxYXZKo_IMUaSLo9Ed6XKboc,4446
 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
 docker/mcp-base/Dockerfile,sha256=sSpbt0sasSBHHeGwPIpJpiEQMU5HGeXzerK8biVSt7Q,1547
@@ -78,8 +87,30 @@ 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.3.dist-info/METADATA,sha256=EjMCZ1tNjNpNF95J0h08jI3Rb19Phe9-fDei7S1Syg0,10109
-aixtools-0.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aixtools-0.1.3.dist-info/entry_points.txt,sha256=dHoutULEZx7xXSqJrZdViSVjfInJibfLibi2nRXL3SE,56
-aixtools-0.1.3.dist-info/top_level.txt,sha256=IPyw70hj9gVDyugaIr3LRlanLYXzostW4azlTgdlALo,34
-aixtools-0.1.3.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
+aixtools-0.1.5.dist-info/METADATA,sha256=QbJnhcWkwh9yMwKh5e95XmVuLKVAltsOx2bce11oKbs,10170
+aixtools-0.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aixtools-0.1.5.dist-info/entry_points.txt,sha256=dHoutULEZx7xXSqJrZdViSVjfInJibfLibi2nRXL3SE,56
+aixtools-0.1.5.dist-info/top_level.txt,sha256=ee4eF-0pqu45zCUVml0mWIhnXQgqMQper2-49BBVHLY,40
+aixtools-0.1.5.dist-info/RECORD,,

{aixtools-0.1.3.dist-info → aixtools-0.1.5.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