distributed-a2a 0.1.1__tar.gz

distributed_a2a-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

distributed_a2a-0.1.1/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md
+include LICENSE

distributed_a2a-0.1.1/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: distributed_a2a
+Version: 0.1.1
+Summary: A library for building A2A agents with routing capabilities
+Home-page: https://github.com/Barra-Technologies/distributed-a2a
+Author: Fabian Bell
+Author-email: Fabian Bell <fabian.bell@barrabytes.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Barra-Technologies/distributed-a2a
+Project-URL: Repository, https://github.com/Barra-Technologies/distributed-a2a
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+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: pydantic>=2.0.0
+Requires-Dist: boto3>=1.28.0
+Requires-Dist: a2a>=0.1.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# A2A Agent Library
+
+A Python library for building A2A (Agent-to-Agent) agents with routing capabilities, DynamoDB-backed registry, and LangChain integration.
+
+## Features
+
+- **StatusAgent**: Base agent implementation with status tracking and structured responses
+- **RoutingAgentExecutor**: Agent executor with intelligent routing capabilities
+- **DynamoDB Registry**: Dynamic agent card registry with heartbeat mechanism
+- **Server Utilities**: FastAPI application builder with A2A protocol support
+- **LangChain Integration**: Built on LangChain for flexible model integration
+
+## Installation
+
+```bash
+pip install distributed-a2a
+```
+
+## Quick Start
+
+```python
+from distributed_a2a import load_app
+from a2a.types import AgentSkill
+
+# Define your agent's skills
+skills = [
+    AgentSkill(
+        id='example_skill',
+        name='Example Skill',
+        description='An example skill',
+        tags=['example']
+    )
+]
+
+# Create your agent application
+app = load_app(
+    name="MyAgent",
+    description="My specialized agent",
+    skills=skills,
+    api_key="your-api-key",
+    system_prompt="You are a helpful assistant...",
+    host="http://localhost:8000"
+)
+```
+
+## Components
+
+### StatusAgent
+
+A base agent class that provides status tracking and structured responses:
+
+```python
+from distributed_a2a import StatusAgent, StringResponse
+
+agent = StatusAgent[StringResponse](
+    system_prompt="Your system prompt",
+    name="AgentName",
+    api_key="your-api-key",
+    is_routing=False,
+    tools=[]
+)
+
+response = await agent("User message", context_id="context-123")
+```
+
+### RoutingAgentExecutor
+
+An executor that can handle requests directly or route them to specialized agents:
+
+```python
+from distributed_a2a import RoutingAgentExecutor
+
+executor = RoutingAgentExecutor(
+    api_key="your-api-key",
+    system_prompt="Your system prompt",
+    routing_tool=routing_tool
+)
+```
+
+### DynamoDB Registry
+
+Dynamic agent registry with automatic heartbeat and expiration:
+
+```python
+from distributed_a2a import DynamoDbRegistryLookup
+
+registry = DynamoDbRegistryLookup(agent_card_tabel="agent-cards")
+tool = registry.as_tool()
+```
+
+## Requirements
+
+- Python 3.10+
+- langchain
+- langchain-core
+- langchain-openai
+- langgraph
+- pydantic
+- boto3
+- a2a
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

distributed_a2a-0.1.1/README.md

@@ -0,0 +1,108 @@
+# A2A Agent Library
+
+A Python library for building A2A (Agent-to-Agent) agents with routing capabilities, DynamoDB-backed registry, and LangChain integration.
+
+## Features
+
+- **StatusAgent**: Base agent implementation with status tracking and structured responses
+- **RoutingAgentExecutor**: Agent executor with intelligent routing capabilities
+- **DynamoDB Registry**: Dynamic agent card registry with heartbeat mechanism
+- **Server Utilities**: FastAPI application builder with A2A protocol support
+- **LangChain Integration**: Built on LangChain for flexible model integration
+
+## Installation
+
+```bash
+pip install distributed-a2a
+```
+
+## Quick Start
+
+```python
+from distributed_a2a import load_app
+from a2a.types import AgentSkill
+
+# Define your agent's skills
+skills = [
+    AgentSkill(
+        id='example_skill',
+        name='Example Skill',
+        description='An example skill',
+        tags=['example']
+    )
+]
+
+# Create your agent application
+app = load_app(
+    name="MyAgent",
+    description="My specialized agent",
+    skills=skills,
+    api_key="your-api-key",
+    system_prompt="You are a helpful assistant...",
+    host="http://localhost:8000"
+)
+```
+
+## Components
+
+### StatusAgent
+
+A base agent class that provides status tracking and structured responses:
+
+```python
+from distributed_a2a import StatusAgent, StringResponse
+
+agent = StatusAgent[StringResponse](
+    system_prompt="Your system prompt",
+    name="AgentName",
+    api_key="your-api-key",
+    is_routing=False,
+    tools=[]
+)
+
+response = await agent("User message", context_id="context-123")
+```
+
+### RoutingAgentExecutor
+
+An executor that can handle requests directly or route them to specialized agents:
+
+```python
+from distributed_a2a import RoutingAgentExecutor
+
+executor = RoutingAgentExecutor(
+    api_key="your-api-key",
+    system_prompt="Your system prompt",
+    routing_tool=routing_tool
+)
+```
+
+### DynamoDB Registry
+
+Dynamic agent registry with automatic heartbeat and expiration:
+
+```python
+from distributed_a2a import DynamoDbRegistryLookup
+
+registry = DynamoDbRegistryLookup(agent_card_tabel="agent-cards")
+tool = registry.as_tool()
+```
+
+## Requirements
+
+- Python 3.10+
+- langchain
+- langchain-core
+- langchain-openai
+- langgraph
+- pydantic
+- boto3
+- a2a
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

distributed_a2a-0.1.1/distributed_a2a/__init__.py

@@ -0,0 +1,5 @@
+from .server import load_app
+
+__all__ = [
+    "load_app"
+]

distributed_a2a-0.1.1/distributed_a2a/agent.py

@@ -0,0 +1,58 @@
+from typing import Literal
+
+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 pydantic import BaseModel, Field
+
+from .model import get_model
+
+
+class AgentResponse(BaseModel):
+    status: Literal[TaskState.rejected, TaskState.completed, TaskState.rejected, TaskState.failed] = Field(
+        description=(
+            f'You should select status as {TaskState.rejected} for requests that fall outside your area of expertise.'
+            f'You should select status as {TaskState.completed} if the request is fully addressed and no further input is needed. '
+            f'You should select status as {TaskState.input_required} if you need more information from the user or are asking a clarifying question. '
+            f'You should select status as {TaskState.failed} if an error occurred or the request cannot be fulfilled.'
+        )
+    )
+
+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]):
+        response_format: type[AgentResponse]
+        if is_routing:
+            response_format = RoutingResponse
+        else:
+            response_format = StringResponse
+
+        self.agent = create_agent(
+            get_model(api_key),
+            tools=tools,
+            checkpointer=MemorySaver(),  # TODO replace by dynamodb
+            system_prompt=system_prompt,
+            response_format=response_format,
+            name=name
+        )
+
+    async def __call__(self, message: str, context_id: str = None) -> ResponseT:
+        config: RunnableConfig = RunnableConfig(configurable={'thread_id': context_id})
+        response = await self.agent.ainvoke(LangGraphMessage(message), config)
+        return response['structured_response']
+
+
+class LangGraphMessage(BaseModel):
+    messages: list[tuple[Literal['user'], str]]
+
+    def __init__(self, messages: str):
+        super().__init__(messages=[("user", messages)])

distributed_a2a-0.1.1/distributed_a2a/executors.py

@@ -0,0 +1,77 @@
+import json
+import logging
+
+from a2a.server.agent_execution import AgentExecutor, RequestContext
+from a2a.server.events import EventQueue
+from a2a.types import TaskStatusUpdateEvent, TaskStatus, TaskState, TaskArtifactUpdateEvent, Artifact
+from a2a.utils import new_text_artifact
+from langchain_core.tools import BaseTool
+
+from .agent import StatusAgent, RoutingResponse, StringResponse
+
+logger = logging.getLogger(__name__)
+
+ROUTING_SYSTEM_PROMPT = """
+You are a helpful routing assistant which routes user requests to specialized remote agents. Your main task is to:
+1. look up available agents via their A2A agent cards
+2. select the best matching agent for the user query
+3. return the matching agent card for that agent."""
+
+
+class RoutingAgentExecutor(AgentExecutor):
+
+    def __init__(self, api_key: str, system_prompt: str, routing_tool: BaseTool, tools: list[BaseTool] | None = None):
+        super().__init__()
+        self.agent = StatusAgent[StringResponse](
+            system_prompt=system_prompt,
+            name="Router",
+            api_key=api_key,
+            is_routing=False,
+            tools=[] if tools is None else tools,
+        )
+        self.routing_agent = StatusAgent[RoutingResponse](
+            system_prompt=ROUTING_SYSTEM_PROMPT,
+            name="Router",
+            api_key=api_key,
+            is_routing=True,
+            tools=[routing_tool]
+        )
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue) -> None:
+        raise NotImplementedError
+
+    async def execute(self, context: RequestContext, event_queue: EventQueue) -> None:
+        # set status to processing
+        await event_queue.enqueue_event(TaskStatusUpdateEvent(status=TaskStatus(state=TaskState.working),
+                                                              final=False,
+                                                              context_id=context.context_id,
+                                                              task_id=context.task_id))
+        agent_response: StringResponse = await self.agent(message=context.get_user_input(),
+                                                          context_id=context.context_id)
+
+        artifact: Artifact
+        if agent_response.status == TaskState.rejected:
+            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"]
+            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})
+            artifact = new_text_artifact(name='target_agent', description='New target agent for request.',
+                                         text=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.',
+                                         text=agent_response.response)
+
+        # publish actual result
+        await event_queue.enqueue_event(TaskArtifactUpdateEvent(append=False,
+                                                                context_id=context.context_id,
+                                                                task_id=context.task_id,
+                                                                last_chunk=True,
+                                                                artifact=artifact))
+        # set and publish the final status
+        await event_queue.enqueue_event(TaskStatusUpdateEvent(status=TaskStatus(
+            state=TaskState(agent_response.status)),
+            final=True,
+            context_id=context.context_id,
+            task_id=context.task_id))

distributed_a2a-0.1.1/distributed_a2a/model.py

@@ -0,0 +1,11 @@
+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"
+    )

distributed_a2a-0.1.1/distributed_a2a/registry.py

@@ -0,0 +1,18 @@
+import boto3
+from langchain_core.tools import StructuredTool
+
+
+class DynamoDbRegistryLookup:
+    def __init__(self, agent_card_tabel: str):
+        dynamo = boto3.resource("dynamodb", region_name="eu-central-1")
+        self.table = dynamo.Table(agent_card_tabel)
+
+    def get_agent_cards(self) -> list[str]:
+
+        items = self.table.scan().get("Items", [])
+        cards: list[str] = [it["card"] for it in items]
+        return cards
+
+    def as_tool(self) -> StructuredTool:
+        return StructuredTool.from_function(func=lambda: self.get_agent_cards(), name="agent_card_lookup",
+                                            description="Gets all available agent cards")

distributed_a2a-0.1.1/distributed_a2a/server.py

@@ -0,0 +1,75 @@
+import asyncio
+import time
+from contextlib import asynccontextmanager
+
+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
+from fastapi import FastAPI
+
+from .executors import RoutingAgentExecutor
+from .registry import DynamoDbRegistryLookup
+
+CAPABILITIES = AgentCapabilities(streaming=False, push_notifications=False)
+
+HEART_BEAT_INTERVAL_SEC = 5
+MAX_HEART_BEAT_MISSES = 3
+
+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):
+    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:
+        await asyncio.sleep(HEART_BEAT_INTERVAL_SEC)
+        table.update_item(
+            Key={"id": name},
+            UpdateExpression="SET expireAt = :expire_at",
+            ExpressionAttributeValues={":expire_at": get_expire_at()}
+        )
+
+
+def load_app(name: str, description: str, skills: list[AgentSkill], api_key: str, system_prompt: str,
+             host: str) -> FastAPI:
+
+    routing_skill = 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
+    )
+
+
+    executor = RoutingAgentExecutor(api_key=api_key, system_prompt=system_prompt, 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))
+        yield
+
+
+    return A2ARESTFastAPIApplication(
+        agent_card=agent_card,
+        http_handler=DefaultRequestHandler(
+            agent_executor=executor,
+            task_store=InMemoryTaskStore()
+        )
+    ).build(title=name, lifespan=lifespan)

distributed_a2a-0.1.1/distributed_a2a.egg-info/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: distributed_a2a
+Version: 0.1.1
+Summary: A library for building A2A agents with routing capabilities
+Home-page: https://github.com/Barra-Technologies/distributed-a2a
+Author: Fabian Bell
+Author-email: Fabian Bell <fabian.bell@barrabytes.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Barra-Technologies/distributed-a2a
+Project-URL: Repository, https://github.com/Barra-Technologies/distributed-a2a
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+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: pydantic>=2.0.0
+Requires-Dist: boto3>=1.28.0
+Requires-Dist: a2a>=0.1.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# A2A Agent Library
+
+A Python library for building A2A (Agent-to-Agent) agents with routing capabilities, DynamoDB-backed registry, and LangChain integration.
+
+## Features
+
+- **StatusAgent**: Base agent implementation with status tracking and structured responses
+- **RoutingAgentExecutor**: Agent executor with intelligent routing capabilities
+- **DynamoDB Registry**: Dynamic agent card registry with heartbeat mechanism
+- **Server Utilities**: FastAPI application builder with A2A protocol support
+- **LangChain Integration**: Built on LangChain for flexible model integration
+
+## Installation
+
+```bash
+pip install distributed-a2a
+```
+
+## Quick Start
+
+```python
+from distributed_a2a import load_app
+from a2a.types import AgentSkill
+
+# Define your agent's skills
+skills = [
+    AgentSkill(
+        id='example_skill',
+        name='Example Skill',
+        description='An example skill',
+        tags=['example']
+    )
+]
+
+# Create your agent application
+app = load_app(
+    name="MyAgent",
+    description="My specialized agent",
+    skills=skills,
+    api_key="your-api-key",
+    system_prompt="You are a helpful assistant...",
+    host="http://localhost:8000"
+)
+```
+
+## Components
+
+### StatusAgent
+
+A base agent class that provides status tracking and structured responses:
+
+```python
+from distributed_a2a import StatusAgent, StringResponse
+
+agent = StatusAgent[StringResponse](
+    system_prompt="Your system prompt",
+    name="AgentName",
+    api_key="your-api-key",
+    is_routing=False,
+    tools=[]
+)
+
+response = await agent("User message", context_id="context-123")
+```
+
+### RoutingAgentExecutor
+
+An executor that can handle requests directly or route them to specialized agents:
+
+```python
+from distributed_a2a import RoutingAgentExecutor
+
+executor = RoutingAgentExecutor(
+    api_key="your-api-key",
+    system_prompt="Your system prompt",
+    routing_tool=routing_tool
+)
+```
+
+### DynamoDB Registry
+
+Dynamic agent registry with automatic heartbeat and expiration:
+
+```python
+from distributed_a2a import DynamoDbRegistryLookup
+
+registry = DynamoDbRegistryLookup(agent_card_tabel="agent-cards")
+tool = registry.as_tool()
+```
+
+## Requirements
+
+- Python 3.10+
+- langchain
+- langchain-core
+- langchain-openai
+- langgraph
+- pydantic
+- boto3
+- a2a
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

distributed_a2a-0.1.1/distributed_a2a.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+requirements.txt
+setup.py
+distributed_a2a/__init__.py
+distributed_a2a/agent.py
+distributed_a2a/executors.py
+distributed_a2a/model.py
+distributed_a2a/registry.py
+distributed_a2a/server.py
+distributed_a2a.egg-info/PKG-INFO
+distributed_a2a.egg-info/SOURCES.txt
+distributed_a2a.egg-info/dependency_links.txt
+distributed_a2a.egg-info/requires.txt
+distributed_a2a.egg-info/top_level.txt

distributed_a2a-0.1.1/distributed_a2a.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

distributed_a2a-0.1.1/distributed_a2a.egg-info/requires.txt

@@ -0,0 +1,7 @@
+langchain>=0.1.0
+langchain-core>=0.1.0
+langchain-openai>=0.0.5
+langgraph>=0.0.20
+pydantic>=2.0.0
+boto3>=1.28.0
+a2a>=0.1.0

distributed_a2a-0.1.1/distributed_a2a.egg-info/top_level.txt

@@ -0,0 +1 @@
+distributed_a2a

distributed_a2a-0.1.1/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "distributed_a2a"
+version = "0.1.1"
+description = "A library for building A2A agents with routing capabilities"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [
+    {name = "Fabian Bell", email = "fabian.bell@barrabytes.com"}
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dynamic = ["dependencies"]
+
+[tool.setuptools.dynamic]
+dependencies = {file = ["requirements.txt"]}
+
+[project.urls]
+Homepage = "https://github.com/Barra-Technologies/distributed-a2a"
+Repository = "https://github.com/Barra-Technologies/distributed-a2a"

distributed_a2a-0.1.1/requirements.txt

@@ -0,0 +1,7 @@
+langchain>=0.1.0
+langchain-core>=0.1.0
+langchain-openai>=0.0.5
+langgraph>=0.0.20
+pydantic>=2.0.0
+boto3>=1.28.0
+a2a>=0.1.0

distributed_a2a-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

distributed_a2a-0.1.1/setup.py

@@ -0,0 +1,31 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+with open("requirements.txt", "r", encoding="utf-8") as fh:
+    requirements = [line.strip() for line in fh if line.strip() and not line.startswith("#")]
+
+setup(
+    name="distributed_a2a",
+    version="0.1.1",
+    author="Fabian Bell",
+    author_email="fabian.bell@barrabytes.com",
+    description="A library for building A2A agents with routing capabilities",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/Barra-Technologies/distributed-a2a",
+    packages=find_packages(),
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+    ],
+    python_requires=">=3.10",
+    install_requires=requirements,
+)