traia-iatp 0.1.29__py3-none-any.whl

traia_iatp/server/templates/pyproject.toml.j2

@@ -0,0 +1,78 @@
+[project]
+name = "{{ package_name }}"
+version = "{{ agent_version }}"
+description = "{{ agent_description }}"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "crewai>=0.203.1",
+    "crewai-tools[mcp]>=0.76.0",
+    "agentops>=0.4.21",
+    "a2a-sdk>=0.2.6",
+    "fastmcp>=2.12.5",
+    "hypercorn>=0.17.3",  # HTTP/2 support via h2 dependency
+    "httpx[http2]>=0.28.1",  # HTTP/2 support with http2 extra
+    "starlette>=0.48.0",  # For SSE streaming support
+    "sse-starlette>=3.0.2",  # Server-Sent Events support
+    "pydantic>=2.12.2",
+    "python-dotenv>=1.1.1",
+    "pymongo>=4.15.3",  # Required for MCP registry
+    "traia-iatp>=0.1.27",  # Core IATP functionality with d402 support
+    "eth-account>=0.11.0",  # For x402 signing
+    "web3>=6.15.0",  # For x402 blockchain interaction
+    {% for dep in additional_dependencies %}
+    "{{ dep }}",
+    {% endfor %}
+]
+
+[project.optional-dependencies]
+grpc = [
+    "grpcio>=1.73.0",
+    "grpcio-tools>=1.71.0",
+    "grpcio-reflection>=1.71.0",
+]
+
+dev = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.21.0",
+    "black>=23.0.0",
+    "ruff>=0.1.0",
+    "mypy>=1.0.0",
+]
+
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.black]
+line-length = 100
+target-version = ['py312']
+include = '\.pyi?$'
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+select = [
+    "E",  # pycodestyle errors
+    "W",  # pycodestyle warnings
+    "F",  # pyflakes
+    "I",  # isort
+    "B",  # flake8-bugbear
+    "C4", # flake8-comprehensions
+    "UP", # pyupgrade
+]
+ignore = [
+    "E501", # line too long
+    "B008", # do not perform function calls in argument defaults
+    "C901", # too complex
+]
+
+[tool.ruff.isort]
+known-first-party = ["{{ package_name }}"]
+
+[tool.mypy]
+python_version = "3.12"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+ignore_missing_imports = true 

traia_iatp/server/templates/run_local_docker.sh.j2

@@ -0,0 +1,103 @@
+#!/bin/bash
+
+# Script to build and run the {{ agent_name }} locally in Docker
+
+set -e  # Exit on error
+
+# Color codes for output
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+NC='\033[0m' # No Color
+
+# Load environment variables from .env if it exists
+if [ -f .env ]; then
+    echo -e "${BLUE}📋 Loading environment variables from .env file...${NC}"
+    set -a  # Export all variables
+    source .env
+    set +a  # Stop exporting
+else
+    echo -e "${YELLOW}⚠️  No .env file found. Using defaults.${NC}"
+    echo -e "${YELLOW}   Copy .env.example to .env and configure as needed.${NC}"
+fi
+
+# Configuration with defaults
+IMAGE_NAME="{{ agent_id }}"
+CONTAINER_NAME="{{ agent_id }}-local"
+HOST_PORT=${PORT:-8000}
+CONTAINER_PORT=${PORT:-8000}
+
+echo -e "${BLUE}🚀 Building and running {{ agent_name }}...${NC}"
+echo -e "${BLUE}   Using port: ${HOST_PORT}${NC}"
+echo
+
+# Check if Docker is installed
+if ! command -v docker &> /dev/null; then
+    echo -e "${RED}❌ Docker is not installed. Please install Docker first.${NC}"
+    exit 1
+fi
+
+# Stop and remove existing container if it exists
+if docker ps -a | grep -q $CONTAINER_NAME; then
+    echo -e "${YELLOW}🛑 Stopping existing container...${NC}"
+    docker stop $CONTAINER_NAME >/dev/null 2>&1 || true
+    docker rm $CONTAINER_NAME >/dev/null 2>&1 || true
+fi
+
+# Build the Docker image
+echo -e "${BLUE}🔨 Building Docker image...${NC}"
+docker build -t $IMAGE_NAME .
+
+# Run the container
+echo -e "${BLUE}🏃 Starting container...${NC}"
+docker run -d \
+    --name $CONTAINER_NAME \
+    -p $HOST_PORT:$CONTAINER_PORT \
+    --env-file .env \
+    -e DEBUG_PROTOCOL=${DEBUG_PROTOCOL:-false} \
+    $IMAGE_NAME
+
+# Wait for the server to start
+echo -e "${YELLOW}⏳ Waiting for server to start...${NC}"
+sleep 3
+
+# Check if container is running
+if ! docker ps | grep -q $CONTAINER_NAME; then
+    echo -e "${RED}❌ Container failed to start. Checking logs:${NC}"
+    docker logs $CONTAINER_NAME
+    exit 1
+fi
+
+# Get container info
+CONTAINER_ID=$(docker ps -q -f name=$CONTAINER_NAME)
+
+# Output connection information
+echo
+echo -e "${GREEN}✅ {{ agent_name }} is running!${NC}"
+echo
+echo -e "${BLUE}📍 Connection Information:${NC}"
+echo -e "   A2A Endpoint:     ${GREEN}http://localhost:${HOST_PORT}/a2a${NC}"
+echo -e "   Agent Info:       ${GREEN}http://localhost:${HOST_PORT}/.well-known/agent.json${NC}"
+echo -e "   Container Name:   ${GREEN}${CONTAINER_NAME}${NC}"
+echo -e "   Container ID:     ${GREEN}${CONTAINER_ID:0:12}${NC}"
+echo
+echo -e "${BLUE}📝 Useful commands:${NC}"
+echo -e "   View logs:        ${YELLOW}docker logs -f ${CONTAINER_NAME}${NC}"
+echo -e "   Stop server:      ${YELLOW}docker stop ${CONTAINER_NAME}${NC}"
+echo -e "   Remove container: ${YELLOW}docker rm ${CONTAINER_NAME}${NC}"
+echo -e "   Shell access:     ${YELLOW}docker exec -it ${CONTAINER_NAME} /bin/bash${NC}"
+echo
+
+# Check if the server is responding
+echo -e "${YELLOW}🔍 Checking server health...${NC}"
+if curl -s -o /dev/null -w "%{http_code}" "http://localhost:${HOST_PORT}/.well-known/agent.json" | grep -q "200"; then
+    echo -e "${GREEN}✅ Server is healthy!${NC}"
+    
+    # Get and display agency info
+    echo
+    echo -e "${BLUE}📋 Agency Information:${NC}"
+    curl -s "http://localhost:${HOST_PORT}/.well-known/agent.json" | python -m json.tool || echo "Could not fetch agency info"
+else
+    echo -e "${YELLOW}⚠️  Server may still be starting up. Check logs with: docker logs -f ${CONTAINER_NAME}${NC}"
+fi 

traia_iatp/server/templates/server.py.j2

@@ -0,0 +1,243 @@
+"""
+{{ agent_name }} - A2A Server Implementation
+
+Auto-generated utility agent that exposes {{ mcp_server_name }} via A2A protocol.
+This is a simplified all-in-one implementation.
+"""
+
+import asyncio
+import json
+import logging
+import os
+from typing import Dict, Any, Optional
+from a2a.server.apps import A2AStarletteApplication
+from a2a.server.agent_execution import AgentExecutor, RequestContext
+from a2a.server.events.event_queue import EventQueue
+from a2a.server.tasks import InMemoryTaskStore
+from a2a.server.request_handlers import DefaultRequestHandler
+from a2a.types import AgentCard, AgentSkill, AgentCapabilities
+from a2a.utils import new_agent_text_message
+import uvicorn
+from crewai import Task
+from fastapi import Request
+
+# Import the MCP agent builder and run function
+from traia_iatp.mcp import MCPServerConfig, MCPAgentBuilder, run_with_mcp_tools, MCPServerInfo
+
+# Import D402 payment support
+from traia_iatp.x402 import (
+    D402Config,
+    D402ServicePrice,
+    require_iatp_payment,
+    add_x402_info_to_agent_card
+)
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Load agent configuration
+with open("agent_config.json", "r") as f:
+    config = json.load(f)
+
+# Create MCP configuration
+mcp_config = MCPServerConfig(
+    name=config["mcp_server"]["name"],
+    url=config["mcp_server"]["url"],
+    description=config["mcp_server"]["description"],
+    server_type=config["mcp_server"].get("server_type", "streamable-http"),
+    capabilities=config["mcp_server"].get("capabilities", []),
+    metadata=config["mcp_server"].get("metadata", {})
+)
+
+# Create MCP server info for use with run_with_mcp_tools
+mcp_server_info = MCPServerInfo(
+    id="",  # Not needed for direct usage
+    name=mcp_config.name,
+    url=mcp_config.url,
+    description=mcp_config.description,
+    server_type=mcp_config.server_type,
+    capabilities=mcp_config.capabilities,
+    metadata=mcp_config.metadata,
+    tags=mcp_config.metadata.get("tags", [])
+)
+
+# Get MCP server API key if required
+{% if requires_api_key %}
+# Check for API keys required by the MCP server
+MCP_API_KEY = None
+{% for api_key_name in api_keys %}
+if not MCP_API_KEY and os.getenv("{{ api_key_name }}"):
+    MCP_API_KEY = os.getenv("{{ api_key_name }}")
+    logger.info(f"Using API key from {{ api_key_name }} environment variable")
+{% endfor %}
+
+if not MCP_API_KEY:
+    logger.warning("No API key found for MCP server authentication.")
+    logger.warning("The MCP server requires one of these environment variables to be set:")
+    {% for api_key_name in api_keys %}
+    logger.warning("  - {{ api_key_name }}")
+    {% endfor %}
+{% else %}
+MCP_API_KEY = None
+{% endif %}
+
+# D402 Configuration (if enabled)
+x402_enabled = os.getenv("D402_ENABLED", "false").lower() == "true"
+x402_config = None
+
+if x402_enabled:
+    logger.info("D402 payments enabled")
+    
+    contract_address = os.getenv("UTILITY_AGENT_CONTRACT_ADDRESS")
+    if not contract_address:
+        logger.error("D402 enabled but UTILITY_AGENT_CONTRACT_ADDRESS not set!")
+        x402_enabled = False
+    else:
+        x402_config = D402Config(
+            enabled=True,
+            pay_to_address=contract_address,
+            default_price=D402ServicePrice(
+                usd_amount=os.getenv("D402_PRICE_USD", "0.01"),
+                network=os.getenv("D402_NETWORK", "sepolia"),
+                asset_address=os.getenv("D402_TOKEN_ADDRESS", ""),
+                max_timeout_seconds=300
+            ),
+            facilitator_url=os.getenv("D402_FACILITATOR_URL", "http://localhost:8080"),
+            service_description=config["description"],
+            protected_paths=["*"]  # Protect all paths except .well-known
+        )
+        logger.info(f"D402 configured: ${x402_config.default_price.usd_amount} per request")
+
+
+class {{ class_name }}AgentExecutor(AgentExecutor):
+    """Agent executor for {{ agency_name }}."""
+    
+    def __init__(self):
+        self.mcp_config = mcp_config
+        self.mcp_server_info = mcp_server_info
+    
+    async def execute(self, context: RequestContext, event_queue: EventQueue) -> None:
+        """Process a request using the {{ agency_name }} capabilities."""
+        try:
+            # Get the user's request from context
+            request_text = context.get_user_input()
+            if not request_text:
+                await event_queue.enqueue_event(
+                    new_agent_text_message("No user message provided")
+                )
+                return
+            
+            # Get additional context if provided
+            task_context = {}
+            if hasattr(context, 'metadata'):
+                task_context = context.metadata or {}
+            
+            # Create an agent for this request
+            agent = MCPAgentBuilder.create_agent(
+                role=f"{config['name']} Specialist",
+                goal=f"Process the request using {self.mcp_config.name} capabilities",
+                backstory=f"You are an expert at using {self.mcp_config.name}. {self.mcp_config.description}"
+            )
+            
+            # Create a task
+            task = Task(
+                description=request_text,
+                expected_output="The processed result based on the request",
+                agent=agent
+            )
+            
+            # Run with MCP tools
+            result = run_with_mcp_tools(
+                tasks=[task],
+                mcp_server=self.mcp_server_info,
+                inputs=task_context,
+                skip_health_check=True,  # Skip for production usage
+                api_key=MCP_API_KEY  # Pass the API key if available
+            )
+            
+            # Send the result as agent message
+            await event_queue.enqueue_event(
+                new_agent_text_message(str(result))
+            )
+            
+        except Exception as e:
+            logger.error(f"Error processing request: {e}")
+            await event_queue.enqueue_event(
+                new_agent_text_message(f"Error processing request: {str(e)}")
+            )
+
+
+def create_app():
+    """Create the A2A application."""
+    # Create agent skill
+    skill = AgentSkill(
+        id="process_request",
+        name=f"Process request using {config['name']}",
+        description=config["description"],
+        examples=config.get("a2a_config", {}).get("skill_examples", [
+            "Help me with this request",
+            "Process this data"
+        ])
+    )
+    
+    # Create capabilities
+    capabilities = AgentCapabilities(
+        streaming=False,
+        pushNotifications=False,
+        stateTransitionHistory=False
+    )
+    
+    # Create agent card
+    agent_card_dict = {
+        "name": config["agency_id"],
+        "description": config["description"],
+        "url": f"http://0.0.0.0:{os.environ.get('PORT', 8000)}",
+        "version": config["version"],
+        "capabilities": capabilities.model_dump(),
+        "skills": [skill.model_dump()]
+    }
+    
+    # Add x402 payment info to agent card if enabled
+    if x402_enabled and x402_config:
+        import asyncio
+        agent_card_dict = asyncio.run(add_x402_info_to_agent_card(agent_card_dict, x402_config))
+    
+    # Create agent card from dict
+    agent_card = AgentCard(**agent_card_dict)
+    
+    # Create executor
+    executor = {{ class_name }}AgentExecutor()
+    
+    # Create task store and request handler
+    task_store = InMemoryTaskStore()
+    request_handler = DefaultRequestHandler(
+        agent_executor=executor,
+        task_store=task_store
+    )
+    
+    # Create the A2A application
+    app = A2AStarletteApplication(
+        agent_card=agent_card,
+        http_handler=request_handler
+    )
+    
+    # Add x402 middleware if enabled
+    if x402_enabled and x402_config:
+        logger.info("Adding x402 payment middleware")
+        
+        @app.middleware("http")
+        async def payment_middleware(request: Request, call_next):
+            middleware = require_iatp_payment(x402_config)
+            return await middleware(request, call_next)
+    
+    return app
+
+
+if __name__ == "__main__":
+    # Get port from environment variable (for Cloud Run compatibility)
+    port = int(os.environ.get("PORT", 8000))
+    logger.info(f"Starting {config['name']} on port {port}")
+    
+    # Create and run the app
+    app = create_app()
+    uvicorn.run(app.build(), host="0.0.0.0", port=port) 

traia_iatp/special_agencies/__init__.py

@@ -0,0 +1,4 @@
+"""Special pre-built agencies for common IATP use cases."""
+
+# Module for special agencies - currently empty
+__all__ = []