distributed-a2a 0.1.6rc6__tar.gz → 0.1.6rc8__tar.gz

{distributed_a2a-0.1.6rc6/distributed_a2a.egg-info → distributed_a2a-0.1.6rc8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: distributed_a2a
-Version: 0.1.6rc6
+Version: 0.1.6rc8
 Summary: A library for building A2A agents with routing capabilities
 Home-page: https://github.com/Barra-Technologies/distributed-a2a
 Author: Fabian Bell

{distributed_a2a-0.1.6rc6 → distributed_a2a-0.1.6rc8}/distributed_a2a/agent.py

@@ -1,4 +1,4 @@
-from typing import Literal
+from typing import Literal, Optional
 
 from a2a.types import TaskState
 from langchain.agents import create_agent
@@ -7,7 +7,7 @@ from langchain_core.tools import BaseTool
 from langgraph_dynamodb_checkpoint import DynamoDBSaver
 from pydantic import BaseModel, Field
 
-from .model import get_model, AgentConfig, LLMConfig
+from .model import get_model, LLMConfig
 
 
 class AgentResponse(BaseModel):
@@ -58,10 +58,10 @@ class StatusAgent[ResponseT: AgentResponse]:
             name=name
         )
 
-    async def __call__(self, message: str, context_id: str = None) -> ResponseT:
+    async def __call__(self, message: str, context_id: Optional[str] = None) -> ResponseT:
         config: RunnableConfig = RunnableConfig(configurable={'thread_id': context_id})
-        response = await self.agent.ainvoke(LangGraphMessage(message), config)
-        return response['structured_response']
+        response = await self.agent.ainvoke({"messages": [("user", message)]}, config)  # type: ignore[arg-type]
+        return response['structured_response']  # type: ignore[no-any-return]
 
 
 class LangGraphMessage(BaseModel):

{distributed_a2a-0.1.6rc6 → distributed_a2a-0.1.6rc8}/distributed_a2a/client.py

@@ -16,6 +16,11 @@ class RemoteAgentConnection:
     """A class to hold the connections to the remote agents."""
 
     def __init__(self, agent_card: AgentCard, client: httpx.AsyncClient):
+        if agent_card.preferred_transport is None:
+            raise ValueError("Agent card preferred transport must be provided.")
+        if agent_card.capabilities.streaming is None:
+            raise ValueError("Agent card streaming capability must be provided.")
+
         client_config = ClientConfig(
             httpx_client=client,
             supported_transports=[agent_card.preferred_transport],
@@ -29,7 +34,8 @@ class RemoteAgentConnection:
 
         responses: list[ClientEvent] = []
         async for response in self.agent_client.send_message(message_request):
-            responses.append(response)
+            if isinstance(response, tuple):
+                responses.append(response)
 
         task_response: Task | None = None
         match responses:
@@ -44,8 +50,8 @@ class RemoteAgentConnection:
         response: Task = await self.agent_client.get_task(query_params)
         return response
 
-    async def send_message(self, message_to_send: str, context_id, task_id: None | str = None,
-                           count=0) -> str | AgentCard:
+    async def send_message(self, message_to_send: str, context_id: str, task_id: None | str = None,
+                           count: int = 0) -> str | AgentCard:
         message: Message = create_text_message_object(content=message_to_send)
         message.message_id = str(uuid4())
         message.context_id = context_id
@@ -87,7 +93,7 @@ class RoutingA2AClient:
         self.client = httpx.AsyncClient()
         self.current_card: AgentCard | None = None
 
-    async def fetch_current_card(self):
+    async def fetch_current_card(self) -> None:
         card_resolver = A2ACardResolver(
             self.client, self.url
         )
@@ -100,6 +106,9 @@ class RoutingA2AClient:
             raise Exception("Maximum recursion depth exceeded. This is likely due to an infinite loop in your agent.")
         if self.current_card is None:
             await self.fetch_current_card()
+        
+        if self.current_card is None:
+            raise ValueError("Failed to fetch current agent card.")
 
         agent_connection = RemoteAgentConnection(self.current_card, self.client)
 

{distributed_a2a-0.1.6rc6 → distributed_a2a-0.1.6rc8}/distributed_a2a/executors.py

@@ -25,6 +25,9 @@ class RoutingAgentExecutor(AgentExecutor):
     def __init__(self, agent_config: AgentConfig, routing_tool: BaseTool, tools: list[BaseTool] | None = None):
         super().__init__()
         api_key = os.environ.get(agent_config.agent.llm.api_key_env)
+        if api_key is None:
+            raise ValueError("No API key found for LLM.")
+
         self.agent = StatusAgent[StringResponse](
             llm_config=agent_config.agent.llm,
             system_prompt=agent_config.agent.system_prompt,
@@ -46,6 +49,9 @@ class RoutingAgentExecutor(AgentExecutor):
         raise NotImplementedError
 
     async def execute(self, context: RequestContext, event_queue: EventQueue) -> None:
+        if context.context_id is None or context.task_id is None:
+            raise ValueError("Context ID and Task ID must be provided.")
+
         # set status to processing
         await event_queue.enqueue_event(TaskStatusUpdateEvent(status=TaskStatus(state=TaskState.working),
                                                               final=False,
@@ -56,13 +62,13 @@ class RoutingAgentExecutor(AgentExecutor):
 
         artifact: Artifact
         if agent_response.status == TaskState.rejected:
-            agent_response: RoutingResponse = await self.routing_agent(message=context.get_user_input(),
+            routing_agent_response: RoutingResponse = await self.routing_agent(message=context.get_user_input(),
                                                                        context_id=context.context_id)
-            agent_name: str = json.loads(agent_response.agent_card)["name"]
+            agent_name: str = json.loads(routing_agent_response.agent_card)["name"]
             logger.info(f"Request with id {context.context_id} got rejected and will be rerouted to a '{agent_name}'.",
-                        extra={"card": agent_response.agent_card})
+                        extra={"card": routing_agent_response.agent_card})
             artifact = new_text_artifact(name='target_agent', description='New target agent for request.',
-                                         text=agent_response.agent_card)
+                                         text=routing_agent_response.agent_card)
         else:
             logger.info(f"Request with id {context.context_id} was successfully processed by agent.")
             artifact = new_text_artifact(name='current_result', description='Result of request to agent.',
@@ -86,6 +92,9 @@ class RoutingExecutor(AgentExecutor):
     def __init__(self, router_config: RouterConfig, routing_tool: BaseTool) -> None:
         super().__init__()
         api_key = os.environ.get(router_config.router.llm.api_key_env)
+        if api_key is None:
+            raise ValueError("No API key found for LLM.")
+
         self.routing_agent = StatusAgent[RoutingResponse](
             llm_config=router_config.router.llm,
             system_prompt=ROUTING_SYSTEM_PROMPT,
@@ -99,6 +108,9 @@ class RoutingExecutor(AgentExecutor):
         raise NotImplementedError
 
     async def execute(self, context: RequestContext, event_queue: EventQueue) -> None:
+        if context.context_id is None or context.task_id is None:
+            raise ValueError("Context ID and Task ID must be provided.")
+
         await event_queue.enqueue_event(TaskStatusUpdateEvent(status=TaskStatus(state=TaskState.working),
                                                               final=False,
                                                               context_id=context.context_id,

{distributed_a2a-0.1.6rc6 → distributed_a2a-0.1.6rc8}/distributed_a2a/model.py

@@ -59,8 +59,8 @@ class RouterConfig(BaseModel):
 
 def get_model(api_key: str, model: str, base_url: str, reasoning_effort: str) -> BaseChatModel:
     return ChatOpenAI(
-        model=model,
-        base_url=base_url,
-        api_key=lambda: api_key,
+        model_name=model,
+        openai_api_base=base_url,
+        openai_api_key=lambda: api_key,
         reasoning_effort=reasoning_effort
     )

{distributed_a2a-0.1.6rc6 → distributed_a2a-0.1.6rc8}/distributed_a2a/server.py

@@ -1,7 +1,7 @@
 import asyncio
 import time
 from contextlib import asynccontextmanager
-from typing import Any
+from typing import Any, AsyncGenerator
 
 import boto3
 from a2a.server.apps import A2ARESTFastAPIApplication
@@ -25,7 +25,7 @@ AGENT_CARD_TABLE = "agent-cards"
 def get_expire_at() -> int:
     return int(time.time() + MAX_HEART_BEAT_MISSES * HEART_BEAT_INTERVAL_SEC)
 
-async def heart_beat(name: str, agent_card_table: str, agent_card: AgentCard):
+async def heart_beat(name: str, agent_card_table: str, agent_card: AgentCard) -> None:
     table = boto3.resource("dynamodb", region_name="eu-central-1").Table(agent_card_table)
     table.put_item(Item={"id": name, "card": agent_card.model_dump_json(), "expireAt": get_expire_at()})
     while True:
@@ -39,9 +39,9 @@ async def heart_beat(name: str, agent_card_table: str, agent_card: AgentCard):
 
 
 
-def load_app(agent_config: dict[str, Any]) -> FastAPI:
+def load_app(agent_config: Any) -> FastAPI:
 
-    agent_config= AgentConfig.model_validate(agent_config)
+    agent_config= AgentConfig.model_validate(obj=agent_config)
 
     skills = [AgentSkill(
         id=skill.id,
@@ -73,7 +73,7 @@ def load_app(agent_config: dict[str, Any]) -> FastAPI:
                                     routing_tool=DynamoDbRegistryLookup(agent_card_tabel=AGENT_CARD_TABLE).as_tool())
 
     @asynccontextmanager
-    async def lifespan(_: FastAPI):
+    async def lifespan(_: FastAPI) -> AsyncGenerator[None, Any]:
         asyncio.create_task(heart_beat(name=agent_card.name, agent_card_table=AGENT_CARD_TABLE, agent_card=agent_card))
         yield
 

{distributed_a2a-0.1.6rc6 → distributed_a2a-0.1.6rc8/distributed_a2a.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: distributed_a2a
-Version: 0.1.6rc6
+Version: 0.1.6rc8
 Summary: A library for building A2A agents with routing capabilities
 Home-page: https://github.com/Barra-Technologies/distributed-a2a
 Author: Fabian Bell

{distributed_a2a-0.1.6rc6 → distributed_a2a-0.1.6rc8}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "distributed_a2a"
-version = "0.1.6rc6"
+version = "0.1.6rc8"
 description = "A library for building A2A agents with routing capabilities"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.14"
 license = {text = "MIT"}
 authors = [
     {name = "Fabian Bell", email = "fabian.bell@barrabytes.com"}
@@ -30,3 +30,14 @@ dependencies = {file = ["requirements.txt"]}
 [project.urls]
 Homepage = "https://github.com/Barra-Technologies/distributed-a2a"
 Repository = "https://github.com/Barra-Technologies/distributed-a2a"
+
+[tool.mypy]
+python_version = "3.14"
+strict = true
+ignore_missing_imports = true
+plugins = ["pydantic.mypy"]
+
+[tool.pydantic-mypy]
+init_forbid_extra = true
+init_typed = true
+warn_required_dynamic_aliases = true