distributed-a2a 0.1.4__tar.gz → 0.1.5__tar.gz

{distributed_a2a-0.1.4/distributed_a2a.egg-info → distributed_a2a-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: distributed_a2a
-Version: 0.1.4
+Version: 0.1.5
 Summary: A library for building A2A agents with routing capabilities
 Home-page: https://github.com/Barra-Technologies/distributed-a2a
 Author: Fabian Bell
@@ -23,9 +23,12 @@ Requires-Dist: langchain>=0.1.0
 Requires-Dist: langchain-core>=0.1.0
 Requires-Dist: langchain-openai>=0.0.5
 Requires-Dist: langgraph>=0.0.20
+Requires-Dist: langgraph-dynamodb-checkpoint>=0.2.6.4
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: boto3>=1.28.0
 Requires-Dist: a2a>=0.1.0
+Requires-Dist: build>=1.4.0
+Requires-Dist: twine>=6.2.0
 Dynamic: author
 Dynamic: home-page
 Dynamic: license-file

{distributed_a2a-0.1.4 → distributed_a2a-0.1.5}/distributed_a2a/agent.py

@@ -4,10 +4,10 @@ from a2a.types import TaskState
 from langchain.agents import create_agent
 from langchain_core.runnables import RunnableConfig
 from langchain_core.tools import BaseTool
-from langgraph.checkpoint.memory import MemorySaver
+from langgraph_dynamodb_checkpoint import DynamoDBSaver
 from pydantic import BaseModel, Field
 
-from .model import get_model
+from .model import get_model, AgentConfig, LLMConfig
 
 
 class AgentResponse(BaseModel):
@@ -20,26 +20,39 @@ class AgentResponse(BaseModel):
         )
     )
 
+
 class RoutingResponse(AgentResponse):
     agent_card: str = Field(description="The stringified json of the agent card to be returned to the user")
 
+
 class StringResponse(AgentResponse):
     response: str = Field(description="The main response to be returned to the user")
 
 
 class StatusAgent[ResponseT: AgentResponse]:
 
-    def __init__(self, system_prompt: str, name: str, api_key: str, is_routing: bool, tools: list[BaseTool]):
+    def __init__(self, llm_config: LLMConfig, name: str, system_prompt: str, api_key: str, is_routing: bool,
+                 tools: list[BaseTool]):
         response_format: type[AgentResponse]
         if is_routing:
             response_format = RoutingResponse
         else:
             response_format = StringResponse
 
+
+        saver = DynamoDBSaver(
+            table_name=f"checkpoint_saver_{name}",
+            max_read_request_units=20,  ## TODO find correct value for app
+            max_write_request_units=20,  ## TODO find correct value for app
+            ttl_seconds=86400
+        )
         self.agent = create_agent(
-            get_model(api_key),
+            get_model(api_key=api_key,
+                      model=llm_config.model,
+                      base_url=llm_config.base_url,
+                      reasoning_effort=llm_config.reasoning_effort),
             tools=tools,
-            checkpointer=MemorySaver(),  # TODO replace by dynamodb
+            checkpointer=saver,
             system_prompt=system_prompt,
             response_format=response_format,
             name=name

{distributed_a2a-0.1.4 → distributed_a2a-0.1.5}/distributed_a2a/executors.py

@@ -1,5 +1,6 @@
 import json
 import logging
+import os
 
 from a2a.server.agent_execution import AgentExecutor, RequestContext
 from a2a.server.events import EventQueue
@@ -8,6 +9,7 @@ from a2a.utils import new_text_artifact
 from langchain_core.tools import BaseTool
 
 from .agent import StatusAgent, RoutingResponse, StringResponse
+from .model import AgentConfig
 
 logger = logging.getLogger(__name__)
 
@@ -20,16 +22,19 @@ You are a helpful routing assistant which routes user requests to specialized re
 
 class RoutingAgentExecutor(AgentExecutor):
 
-    def __init__(self, api_key: str, system_prompt: str, routing_tool: BaseTool, tools: list[BaseTool] | None = None):
+    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)
         self.agent = StatusAgent[StringResponse](
-            system_prompt=system_prompt,
-            name="Router",
+            llm_config=agent_config.agent.llm,
+            system_prompt=agent_config.agent.system_prompt,
+            name=agent_config.agent.card.name,
             api_key=api_key,
             is_routing=False,
             tools=[] if tools is None else tools,
         )
         self.routing_agent = StatusAgent[RoutingResponse](
+            llm_config=agent_config.agent.llm,
             system_prompt=ROUTING_SYSTEM_PROMPT,
             name="Router",
             api_key=api_key,

distributed_a2a-0.1.5/distributed_a2a/model.py

@@ -0,0 +1,59 @@
+import os
+from typing import List, Any
+
+from langchain_core.language_models import BaseChatModel
+from langchain_openai import ChatOpenAI
+from pydantic import BaseModel, Field
+
+
+class SkillConfig(BaseModel):
+    id: str = Field(description="The id of the skill e.g. weather")
+    name: str = Field(description="The name of the skill e.g. weather")
+    description: str = Field(description="A short description of the skill")
+    tags: List[str] = Field(description="The tags associated with the skill")
+
+
+class LLMConfig(BaseModel):
+    base_url: str = Field(description="The base url of the LLM provider")
+    model: str = Field(description="The model to use for the LLM e.g. gpt-3.5-turbo")
+    api_key_env: str = Field(description="The environment variable containing the api key for the LLM provider")
+    reasoning_effort: str  = Field(description="The reasoning effort to use for the LLM e.g. high", default="high")
+
+
+class CardConfig(BaseModel):
+    name: str = Field(description="The name of the agent" )
+    description: str = Field(description="A short description of the agent")
+    version: str = Field(description="The version of the agent")
+    default_input_modes: List[str]  = Field(description="The default input modes supported by the agent", default=["text","text/plaintext"])
+    default_output_modes: List[str] = Field(description="The default output modes supported by the agent", default=["text","text/plaintext"])
+    preferred_transport_protocol: str = Field(description="The preferred transport protocol for the agent", default="HTTP+JSON")
+    url: str = Field(description="The url of the agent")
+    skills: List[SkillConfig] = Field(description="The skills supported by the agent", default=[])
+
+
+class AgentItem(BaseModel):
+    card: CardConfig = Field(description="The agent card configuration node")
+    llm: LLMConfig = Field(description="The LLM configuration node")
+    system_prompt: str = Field(description="The system prompt to use for the LLM or a path to a file containing the system prompt")
+
+    def __init__(self, /, **data: Any) -> None:
+        prompt_or_path= data['system_prompt']
+        if os.path.exists(prompt_or_path):
+            with open(prompt_or_path, "r", encoding="utf-8") as f:
+                data['system_prompt'] =  f.read()
+
+        super().__init__(**data)
+
+
+class AgentConfig(BaseModel):
+    agent: AgentItem = Field(description="The agent configuration node")
+
+
+
+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,
+        reasoning_effort=reasoning_effort
+    )

{distributed_a2a-0.1.4 → distributed_a2a-0.1.5}/distributed_a2a/server.py

@@ -1,16 +1,18 @@
 import asyncio
 import time
 from contextlib import asynccontextmanager
+from typing import Any
 
 import boto3
 from a2a.server.apps import A2ARESTFastAPIApplication
 from a2a.server.request_handlers import DefaultRequestHandler
 from a2a.server.tasks import InMemoryTaskStore
 from a2a.types import AgentSkill, \
-    AgentCapabilities, AgentCard, TransportProtocol
+    AgentCapabilities, AgentCard
 from fastapi import FastAPI
 
 from .executors import RoutingAgentExecutor
+from .model import AgentConfig
 from .registry import DynamoDbRegistryLookup
 
 CAPABILITIES = AgentCapabilities(streaming=False, push_notifications=False)
@@ -35,34 +37,44 @@ async def heart_beat(name: str, agent_card_table: str, agent_card: AgentCard):
         )
 
 
-def load_app(name: str, description: str, skills: list[AgentSkill], api_key: str, system_prompt: str,
-             host: str) -> FastAPI:
 
-    routing_skill = AgentSkill(
+
+def load_app(agent_config: dict[str, Any]) -> FastAPI:
+
+    agent_config= AgentConfig.model_validate(agent_config)
+
+    skills = [AgentSkill(
+        id=skill.id,
+        name=skill.name,
+        description=skill.description,
+        tags=skill.tags)
+    for skill in agent_config.agent.card.skills]
+    skills.append(AgentSkill(
         id='routing',
         name='Agent routing',
         description='Identifies the most suitable agent for the given task and returns the agent card',
         tags=['agent', 'routing']
-    )
+    ))
 
     agent_card = AgentCard(
-        name=name,
-        description=description,
-        url=host,
-        version='1.0.0',
-        default_input_modes=['text', 'text/plain'],
-        default_output_modes=['text', 'text/plain'],
-        capabilities=CAPABILITIES,
-        skills=skills + [routing_skill],
-        preferred_transport=TransportProtocol.http_json
+        name=agent_config.agent.card.name,
+        description=agent_config.agent.card.description,
+        url=agent_config.agent.card.url,
+        version=agent_config.agent.card.version,
+        default_input_modes=agent_config.agent.card.default_input_modes,
+        default_output_modes=agent_config.agent.card.default_output_modes,
+        skills=skills,
+        preferred_transport=agent_config.agent.card.preferred_transport_protocol,
+        capabilities=CAPABILITIES
     )
 
 
-    executor = RoutingAgentExecutor(api_key=api_key, system_prompt=system_prompt, routing_tool=DynamoDbRegistryLookup(agent_card_tabel=AGENT_CARD_TABLE).as_tool())
+    executor = RoutingAgentExecutor(agent_config=agent_config,
+                                    routing_tool=DynamoDbRegistryLookup(agent_card_tabel=AGENT_CARD_TABLE).as_tool())
 
     @asynccontextmanager
     async def lifespan(_: FastAPI):
-        asyncio.create_task(heart_beat(name=name, agent_card_table=AGENT_CARD_TABLE, agent_card=agent_card))
+        asyncio.create_task(heart_beat(name=agent_card.name, agent_card_table=AGENT_CARD_TABLE, agent_card=agent_card))
         yield
 
 
@@ -70,6 +82,6 @@ def load_app(name: str, description: str, skills: list[AgentSkill], api_key: str
         agent_card=agent_card,
         http_handler=DefaultRequestHandler(
             agent_executor=executor,
-            task_store=InMemoryTaskStore()
-        )
-    ).build(title=name, lifespan=lifespan)
+            task_store=InMemoryTaskStore() #TODO replace with dynamodb store
+
+        )).build(title=agent_card.name, lifespan=lifespan, root_path=f"/{agent_config.agent.card.name}") #TODO use extra parameter

{distributed_a2a-0.1.4 → distributed_a2a-0.1.5/distributed_a2a.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: distributed_a2a
-Version: 0.1.4
+Version: 0.1.5
 Summary: A library for building A2A agents with routing capabilities
 Home-page: https://github.com/Barra-Technologies/distributed-a2a
 Author: Fabian Bell
@@ -23,9 +23,12 @@ Requires-Dist: langchain>=0.1.0
 Requires-Dist: langchain-core>=0.1.0
 Requires-Dist: langchain-openai>=0.0.5
 Requires-Dist: langgraph>=0.0.20
+Requires-Dist: langgraph-dynamodb-checkpoint>=0.2.6.4
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: boto3>=1.28.0
 Requires-Dist: a2a>=0.1.0
+Requires-Dist: build>=1.4.0
+Requires-Dist: twine>=6.2.0
 Dynamic: author
 Dynamic: home-page
 Dynamic: license-file

{distributed_a2a-0.1.4 → distributed_a2a-0.1.5}/distributed_a2a.egg-info/requires.txt

@@ -2,6 +2,9 @@ langchain>=0.1.0
 langchain-core>=0.1.0
 langchain-openai>=0.0.5
 langgraph>=0.0.20
+langgraph-dynamodb-checkpoint>=0.2.6.4
 pydantic>=2.0.0
 boto3>=1.28.0
 a2a>=0.1.0
+build>=1.4.0
+twine>=6.2.0

{distributed_a2a-0.1.4 → distributed_a2a-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "distributed_a2a"
-version = "0.1.4"
+version = "0.1.5"
 description = "A library for building A2A agents with routing capabilities"
 readme = "README.md"
 requires-python = ">=3.10"

{distributed_a2a-0.1.4 → distributed_a2a-0.1.5}/requirements.txt

@@ -2,6 +2,9 @@ langchain>=0.1.0
 langchain-core>=0.1.0
 langchain-openai>=0.0.5
 langgraph>=0.0.20
+langgraph-dynamodb-checkpoint>=0.2.6.4
 pydantic>=2.0.0
 boto3>=1.28.0
 a2a>=0.1.0
+build>=1.4.0
+twine>=6.2.0

distributed_a2a-0.1.4/distributed_a2a/model.py

@@ -1,11 +0,0 @@
-from langchain_core.language_models import BaseChatModel
-from langchain_openai import ChatOpenAI
-
-
-def get_model(api_key: str) -> BaseChatModel:
-    return ChatOpenAI(
-        model="google/gemini-2.5-flash",
-        base_url="https://openrouter.ai/api/v1",
-        api_key=lambda: api_key,
-        reasoning_effort="medium"
-    )