aixtools 0.2.6__tar.gz → 0.2.8__tar.gz

{aixtools-0.2.6 → aixtools-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aixtools
-Version: 0.2.6
+Version: 0.2.8
 Summary: Tools for AI exploration and debugging
 Requires-Python: >=3.11.2
 Description-Content-Type: text/markdown

{aixtools-0.2.6 → aixtools-0.2.8}/aixtools/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.6'
-__version_tuple__ = version_tuple = (0, 2, 6)
+__version__ = version = '0.2.8'
+__version_tuple__ = version_tuple = (0, 2, 8)
 
-__commit_id__ = commit_id = 'g9b369b8bb'
+__commit_id__ = commit_id = 'gac214deb6'

{aixtools-0.2.6 → aixtools-0.2.8}/aixtools/a2a/google_sdk/pydantic_ai_adapter/agent_executor.py

@@ -158,7 +158,7 @@ class PydanticAgentExecutor(AgentExecutor):
             return
 
         for idx, artifact in enumerate(run_output.created_artifacts_paths):
-            image_file = FileWithUri(uri=str(artifact), name=f"image_{idx}")
+            artifact_file = FileWithUri(uri=str(artifact), name=f"art_{idx}")
             await event_queue.enqueue_event(
                 TaskArtifactUpdateEvent(
                     append=False,
@@ -166,8 +166,8 @@ class PydanticAgentExecutor(AgentExecutor):
                     task_id=task.id,
                     last_chunk=True,
                     artifact=Artifact(
-                        artifact_id=f"image_{idx}",
-                        parts=[Part(root=FilePart(file=image_file))],
+                        artifact_id=f"art_{idx}",
+                        parts=[Part(root=FilePart(file=artifact_file))],
                     ),
                 )
             )

aixtools-0.2.8/aixtools/a2a/google_sdk/utils.py

@@ -0,0 +1,90 @@
+"""Utilities for handling A2A SDK agent cards and connections."""
+
+import asyncio
+
+import httpx
+from a2a.client import A2ACardResolver, ClientConfig, ClientFactory
+from a2a.server.agent_execution import RequestContext
+from a2a.types import AgentCard
+from a2a.utils import AGENT_CARD_WELL_KNOWN_PATH, PREV_AGENT_CARD_WELL_KNOWN_PATH
+
+from aixtools.a2a.google_sdk.remote_agent_connection import RemoteAgentConnection
+from aixtools.context import DEFAULT_SESSION_ID, DEFAULT_USER_ID, SessionIdTuple
+from aixtools.logging.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+DEFAULT_A2A_TIMEOUT = 60.0
+
+
+class AgentCardLoadFailedError(Exception):
+    pass
+
+
+async def get_agent_card(client: httpx.AsyncClient, address: str) -> AgentCard:
+    """Retrieve the agent card from the given agent address."""
+    for card_path in [AGENT_CARD_WELL_KNOWN_PATH, PREV_AGENT_CARD_WELL_KNOWN_PATH]:
+        try:
+            card_resolver = A2ACardResolver(client, address, card_path)
+            card = await card_resolver.get_agent_card()
+            card.url = address
+            return card
+        except Exception as e:
+            logger.warning(f"Error retrieving agent card from {address} at path {card_path}: {e}")
+
+    raise AgentCardLoadFailedError(f"Failed to load agent card from {address}")
+
+
+class _AgentCardResolver:
+    """Helper class to resolve and manage agent cards and their connections."""
+
+    def __init__(self, client: httpx.AsyncClient):
+        self._httpx_client = client
+        self._a2a_client_factory = ClientFactory(ClientConfig(httpx_client=self._httpx_client))
+        self.clients: dict[str, RemoteAgentConnection] = {}
+
+    def register_agent_card(self, card: AgentCard):
+        remote_connection = RemoteAgentConnection(card, self._a2a_client_factory.create(card))
+        self.clients[card.name] = remote_connection
+
+    async def retrieve_card(self, address: str):
+        try:
+            card = await get_agent_card(self._httpx_client, address)
+            self.register_agent_card(card)
+            return
+        except Exception as e:
+            logger.error(f"Error retrieving agent card from {address}: {e}")
+            return
+
+    async def get_a2a_clients(self, agent_hosts: list[str]) -> dict[str, RemoteAgentConnection]:
+        async with asyncio.TaskGroup() as task_group:
+            for address in agent_hosts:
+                task_group.create_task(self.retrieve_card(address))
+
+        return self.clients
+
+
+async def get_a2a_clients(
+    ctx: SessionIdTuple, agent_hosts: list[str], *, timeout: float = DEFAULT_A2A_TIMEOUT
+) -> dict[str, RemoteAgentConnection]:
+    """Get A2A clients for all agents defined in the configuration."""
+    headers = {
+        "user-id": ctx[0],
+        "session-id": ctx[1],
+    }
+    httpx_client = httpx.AsyncClient(headers=headers, timeout=timeout, follow_redirects=True)
+    return await _AgentCardResolver(httpx_client).get_a2a_clients(agent_hosts)
+
+
+def card2description(card: AgentCard) -> str:
+    """Convert agent card to a description string."""
+    descr = f"{card.name}: {card.description}\n"
+    for skill in card.skills:
+        descr += f"\t - {skill.name}: {skill.description}\n"
+    return descr
+
+
+def get_session_id_tuple(context: RequestContext) -> SessionIdTuple:
+    """Get the user_id, session_id tuple from the request context."""
+    headers = context.call_context.state.get("headers", {})
+    return headers.get("user-id", DEFAULT_USER_ID), headers.get("session-id", DEFAULT_SESSION_ID)

{aixtools-0.2.6 → aixtools-0.2.8}/aixtools.egg-info/SOURCES.txt

@@ -22,7 +22,6 @@ aixtools/.chainlit/translations/zh-CN.json
 aixtools/a2a/app.py
 aixtools/a2a/utils.py
 aixtools/a2a/google_sdk/__init__.py
-aixtools/a2a/google_sdk/card.py
 aixtools/a2a/google_sdk/remote_agent_connection.py
 aixtools/a2a/google_sdk/utils.py
 aixtools/a2a/google_sdk/pydantic_ai_adapter/agent_executor.py

aixtools-0.2.6/aixtools/a2a/google_sdk/card.py

@@ -1,27 +0,0 @@
-import httpx
-from a2a.client import A2ACardResolver
-from a2a.types import AgentCard
-
-from aixtools.logging.logging_config import get_logger
-
-logger = get_logger(__name__)
-
-
-async def get_agent_card(httpx_client: httpx.AsyncClient, agent_url: str) -> AgentCard:
-    resolver = A2ACardResolver(
-        httpx_client=httpx_client,
-        base_url=agent_url,
-    )
-
-    try:
-        _public_card = await resolver.get_agent_card()  # Fetches from default public path
-        logger.info("Successfully fetched public agent card:")
-        logger.info(_public_card.model_dump_json(indent=2, exclude_none=True))
-        final_agent_card_to_use = _public_card
-    except Exception as e:
-        logger.error(f"Critical error fetching public agent card: {e}", exc_info=True)
-        raise RuntimeError("Failed to fetch the public agent card. Cannot continue.") from e
-
-    # Set the URL which is accessible from the container
-    final_agent_card_to_use.url = agent_url
-    return final_agent_card_to_use

aixtools-0.2.6/aixtools/a2a/google_sdk/utils.py

@@ -1,59 +0,0 @@
-import asyncio
-
-import httpx
-from a2a.client import A2ACardResolver, ClientConfig, ClientFactory
-from a2a.server.agent_execution import RequestContext
-from a2a.types import AgentCard
-from a2a.utils import AGENT_CARD_WELL_KNOWN_PATH, PREV_AGENT_CARD_WELL_KNOWN_PATH
-
-from aixtools.a2a.google_sdk.remote_agent_connection import RemoteAgentConnection
-from aixtools.context import DEFAULT_SESSION_ID, DEFAULT_USER_ID, SessionIdTuple
-
-
-class AgentCardLoadFailedError(Exception):
-    pass
-
-
-class _AgentCardResolver:
-    def __init__(self, client: httpx.AsyncClient):
-        self._httpx_client = client
-        self._a2a_client_factory = ClientFactory(ClientConfig(httpx_client=self._httpx_client))
-        self.clients: dict[str, RemoteAgentConnection] = {}
-
-    def register_agent_card(self, card: AgentCard):
-        remote_connection = RemoteAgentConnection(card, self._a2a_client_factory.create(card))
-        self.clients[card.name] = remote_connection
-
-    async def retrieve_card(self, address: str):
-        for card_path in [AGENT_CARD_WELL_KNOWN_PATH, PREV_AGENT_CARD_WELL_KNOWN_PATH]:
-            try:
-                card_resolver = A2ACardResolver(self._httpx_client, address, card_path)
-                card = await card_resolver.get_agent_card()
-                card.url = address
-                self.register_agent_card(card)
-                return
-            except Exception as e:
-                print(f"Error retrieving agent card from {address} at path {card_path}: {e}")
-
-        raise AgentCardLoadFailedError(f"Failed to load agent card from {address}")
-
-    async def get_a2a_clients(self, agent_hosts: list[str]) -> dict[str, RemoteAgentConnection]:
-        async with asyncio.TaskGroup() as task_group:
-            for address in agent_hosts:
-                task_group.create_task(self.retrieve_card(address))
-
-        return self.clients
-
-
-async def get_a2a_clients(ctx: SessionIdTuple, agent_hosts: list[str]) -> dict[str, RemoteAgentConnection]:
-    headers = {
-        "user-id": ctx[0],
-        "session-id": ctx[1],
-    }
-    httpx_client = httpx.AsyncClient(headers=headers, timeout=60.0)
-    return await _AgentCardResolver(httpx_client).get_a2a_clients(agent_hosts)
-
-
-def get_session_id_tuple(context: RequestContext) -> SessionIdTuple:
-    headers = context.call_context.state.get("headers", {})
-    return headers.get("user-id", DEFAULT_USER_ID), headers.get("session-id", DEFAULT_SESSION_ID)