traia-iatp 0.1.2__py3-none-any.whl → 0.1.67__py3-none-any.whl

traia_iatp/server/templates/agent_executor.py.j2

@@ -17,23 +17,25 @@ from a2a.server.agent_execution import AgentExecutor, RequestContext
 from a2a.server.events.event_queue import EventQueue
 from a2a.types import Message, TextPart
 from a2a.utils import new_agent_text_message
-from crewai import Task
+from crewai import Task, LLM
 from traia_iatp.mcp import MCPServerConfig, MCPAgentBuilder, run_with_mcp_tools, MCPServerInfo
 
 # Import AgentOps for operation tracking
-try:
-    import agentops
-    from agentops.sdk.decorators import operation
-    AGENTOPS_AVAILABLE = True
-except ImportError:
-    AGENTOPS_AVAILABLE = False
-    agentops = None
-    # Create a no-op decorator if AgentOps is not available
-    def operation(func):
-        return func
+import agentops
+
+
+
+DEFAULT_LLM = LLM(
+    model=os.getenv("LLM_MODEL", "openai/gpt-4o-mini"),  # Better model for tool execution
+    temperature=float(os.getenv("LLM_MODEL_TEMPERATURE", "0.1")),
+    api_key=os.getenv("OPENAI_API_KEY")
+)
+current_time = datetime.utcnow()
 
 logger = logging.getLogger(__name__)
 
+logger.info(f"Current LLM model used: {os.getenv('LLM_MODEL', 'openai/gpt-4o-mini')}")
+
 # Create a thread pool for CPU-bound CrewAI operations
 executor = ThreadPoolExecutor(max_workers=10)
 
@@ -68,7 +70,14 @@ class CustomEvent:
 
 
 class {{ class_name }}AgentExecutor(AgentExecutor):
-    """Agent executor for {{ agent_name }}."""
+    """Agent executor for {{ agent_name }}.
+    
+    This executor supports:
+    - ✅ Concurrent requests from multiple clients (each gets fresh agent/task)
+    - ✅ Memory-enabled agents for better MCP tool usage learning
+    - ✅ D402 payment enforcement per request
+    - ✅ Streaming and non-streaming modes
+    """
     
     def __init__(self, mcp_config: MCPServerConfig, supports_streaming: bool = False):
         self.mcp_config = mcp_config
@@ -84,7 +93,6 @@ class {{ class_name }}AgentExecutor(AgentExecutor):
             tags=mcp_config.metadata.get("tags", [])
         )
     
-    @operation
     async def execute(self, context: RequestContext, event_queue: EventQueue) -> None:
         """Process a request using the {{ agent_name }} capabilities."""
         try:
@@ -94,7 +102,7 @@ class {{ class_name }}AgentExecutor(AgentExecutor):
                 # Send empty response with task ID if available
                 msg = new_agent_text_message("No user message provided")
                 if hasattr(context, 'task_id') and context.task_id:
-                    msg.taskId = context.task_id
+                    msg.task_id = context.task_id
                 await event_queue.enqueue_event(msg)
                 return
             
@@ -114,10 +122,9 @@ class {{ class_name }}AgentExecutor(AgentExecutor):
             logger.error(f"Error processing request: {e}")
             msg = new_agent_text_message(f"Error processing request: {str(e)}")
             if hasattr(context, 'task_id') and context.task_id:
-                msg.taskId = context.task_id
+                msg.task_id = context.task_id
             await event_queue.enqueue_event(msg)
     
-    @operation
     async def _execute_standard(self, context: RequestContext, event_queue: EventQueue, request_text: str) -> None:
         """Execute standard (non-streaming) request."""
         # Get additional context if provided
@@ -126,16 +133,27 @@ class {{ class_name }}AgentExecutor(AgentExecutor):
             task_context = context.metadata or {}
         
         # Create an agent for this request
+        # Note: Each request gets a fresh agent to support concurrent requests
+        # Memory is enabled to help the agent learn MCP tool usage patterns
         agent = MCPAgentBuilder.create_agent(
-            role=f"{{ agent_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}"
+            role=f"{{ agent_name }} Tool Executor",
+            goal=f"EXECUTE tools from {self.mcp_config.name} to get REAL data. Never respond without calling tools first.",
+            backstory=f"You are a tool execution specialist for {self.mcp_config.name}. {self.mcp_config.description}. "
+                      f"CRITICAL RULES: "
+                      f"1. ALWAYS call the appropriate tool to get real data "
+                      f"2. NEVER answer based on assumptions or knowledge "
+                      f"3. If no tool can answer the request, explicitly state 'No suitable tool found in {self.mcp_config.name}' "
+                      f"4. Base your response ONLY on actual tool execution results",
+            llm=DEFAULT_LLM,
+            verbose=True,  # Enable verbose mode for better debugging
+            memory=True,  # Enable memory for learning MCP server usage
+            max_iter=25  # Allow sufficient iterations to execute tools
         )
         
-        # Create a task
+        # Create a task with explicit tool requirement
         task = Task(
-            description=request_text,
-            expected_output="The processed result based on the request",
+            description=f"{request_text}\n\nIMPORTANT: You MUST use the available tools to get this data. Do not provide answers without calling tools.",
+            expected_output="Real data obtained by executing the appropriate tool. If no tool can provide this data, state 'No suitable tool available'.",
             agent=agent
         )
         
@@ -163,10 +181,9 @@ class {{ class_name }}AgentExecutor(AgentExecutor):
         # Send the result as agent message with task ID if available
         msg = new_agent_text_message(str(result))
         if hasattr(context, 'task_id') and context.task_id:
-            msg.taskId = context.task_id
+            msg.task_id = context.task_id
         await event_queue.enqueue_event(msg)
     
-    @operation
     async def _execute_streaming(self, context: RequestContext, event_queue: EventQueue, request_text: str) -> None:
         """Execute streaming request using SSE."""
         try:
@@ -217,7 +234,6 @@ class {{ class_name }}AgentExecutor(AgentExecutor):
                 })
             )
     
-    @operation
     async def _stream_mcp_response(self, request_text: str, context: RequestContext) -> AsyncGenerator[str, None]:
         """
         Stream responses from MCP server.
@@ -233,8 +249,10 @@ class {{ class_name }}AgentExecutor(AgentExecutor):
         
         agent = MCPAgentBuilder.create_agent(
             role=f"{{ agent_name }} Streaming Specialist",
-            goal=f"Process the streaming request using {self.mcp_config.name} capabilities",
-            backstory=f"You are an expert at using {self.mcp_config.name} for streaming data. {self.mcp_config.description}"
+            goal=f"Process the streaming request using {self.mcp_config.name} for streaming data",
+            backstory=f"You are an expert at using {self.mcp_config.name} for streaming data. {self.mcp_config.description}",
+            verbose=True,  # Enable verbose mode
+            memory=True  # Enable memory for learning MCP server usage
         )
         
         task = Task(

traia_iatp/server/templates/env.example.j2

@@ -9,12 +9,15 @@ HOST=0.0.0.0
 AGENTOPS_API_KEY=your-agentops-api-key-here
 
 # Language Model Configuration
-LLM_MODEL=openai/gpt-4.1
+LLM_MODEL=openai/gpt-4.1-nano
+LLM_MODEL_TEMPERATURE=0.7
+EMBEDDINGS_OPENAI_MODEL_NAME=text-embedding-3-small
+
 # You can also use other models:
 # LLM_MODEL=vertex_ai/gemini-2.0-flash
-# LLM_MODEL=anthropic/claude-4-sonnetf
+# LLM_MODEL=anthropic/claude-3-5-sonnet-20241022
 
-# API Keys (add as needed based on your LLM choice)
+# API Keys (populated by run_local_docker.sh from runtime environment)
 # OPENAI_API_KEY=your-openai-key-here
 # ANTHROPIC_API_KEY=your-anthropic-key-here
 # GOOGLE_API_KEY=your-google-key-here
@@ -22,7 +25,8 @@ LLM_MODEL=openai/gpt-4.1
 # VERTEX_LOCATION=us-central1
 
 # MCP Server Configuration
-MCP_SERVER_URL={{ mcp_server_url }}
+# Note: localhost is auto-replaced with host.docker.internal for Docker compatibility
+MCP_SERVER_URL={{ mcp_server_url.replace('localhost', 'host.docker.internal') }}
 {% if requires_api_key and api_keys %}
 # MCP Server API Keys (REQUIRED - The MCP server requires authentication)
 # Set one of the following environment variables:
@@ -64,6 +68,30 @@ LOG_LEVEL=INFO
 {% endfor %}
 {% endif %}
 
+{% if d402_enabled %}
+# D402 Payment Configuration
+UTILITY_AGENT_CONTRACT_ADDRESS={{ d402_contract_address }}
+UTILITY_AGENT_OPERATOR_PRIVATE_KEY={{ d402_operator_private_key }}
+D402_ENABLED=true
+D402_PRICE_USD={{ d402_price_usd }}
+D402_TOKEN_SYMBOL={{ d402_token_symbol }}
+D402_TOKEN_ADDRESS={{ d402_token_address }}
+D402_TOKEN_DECIMALS={{ d402_token_decimals }}
+D402_NETWORK={{ d402_network }}
+D402_FACILITATOR_URL={{ d402_facilitator_url.replace('localhost', 'host.docker.internal') }}
+D402_TESTING_MODE={{ d402_testing_mode }}
+{% else %}
+# D402 Payment Configuration (disabled)f
+# D402_ENABLED=false
+# D402_PRICE_USD=0.01
+# D402_TOKEN_SYMBOL=USDC
+# D402_TOKEN_ADDRESS=
+# D402_TOKEN_DECIMALS=6
+# D402_NETWORK=sepolia
+# D402_FACILITATOR_URL=http://localhost:7070
+# D402_TESTING_MODE=false
+{% endif %}
+
 # Additional custom environment variables
 {% for env_var in environment_variables %}
 # {{ env_var.name }}={{ env_var.value }}

traia_iatp/server/templates/gitignore.j2

@@ -53,6 +53,13 @@ uv.lock
 # Docker
 *.pid
 docker-compose.override.yml
+.docker-iatp/  # Local IATP copy for Docker builds
+pyproject.toml.backup  # Backup during local IATP builds
+pyproject.toml.tmp  # Temporary sed file
+
+# Test results
+test_results.log
+*.md  # Test reports
 
 # {{ agent_name }} specific
 {% if additional_ignores %}

traia_iatp/server/templates/pyproject.toml.j2

@@ -5,19 +5,21 @@ description = "{{ agent_description }}"
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
-    "crewai>=0.130.0",
-    "crewai-tools[mcp]>=0.47.1",
-    "agentops>=0.3.0",
+    "crewai>=0.203.1",
+    "crewai-tools[mcp]>=0.76.0",
+    "agentops>=0.4.21",
     "a2a-sdk>=0.2.6",
-    "fastmcp>=2.8.1",
+    "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.46.2",  # For SSE streaming support
-    "sse-starlette>=2.3.6",  # Server-Sent Events support
-    "pydantic>=2.11.0",
-    "python-dotenv>=1.1.0",
-    "pymongo>=4.13.0",  # Required for MCP registry
-    "traia-iatp",  # Core IATP functionality - always use latest version
+    "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.67",  # Core IATP functionality with d402 and RPC fallback support
+    "eth-account>=0.11.0",  # For x402 signing
+    "web3>=6.15.0",  # For x402 blockchain interaction
     {% for dep in additional_dependencies %}
     "{{ dep }}",
     {% endfor %}
@@ -30,8 +32,7 @@ grpc = [
     "grpcio-reflection>=1.71.0",
 ]
 
-[tool.uv]
-dev-dependencies = [
+dev = [
     "pytest>=7.0.0",
     "pytest-asyncio>=0.21.0",
     "black>=23.0.0",

traia_iatp/server/templates/run_local_docker.sh.j2

@@ -11,17 +11,73 @@ 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
+# Create .env from .env.example if it doesn't exist
+if [ ! -f .env ]; then
+    if [ -f .env.example ]; then
+        echo -e "${BLUE}📋 Creating .env from .env.example...${NC}"
+        cp .env.example .env
+        echo -e "${GREEN}✅ Created .env file${NC}"
+    else
+        echo -e "${RED}❌ No .env.example file found${NC}"
+        exit 1
+    fi
 else
-    echo -e "${YELLOW}⚠️  No .env file found. Using defaults.${NC}"
-    echo -e "${YELLOW}   Copy .env.example to .env and configure as needed.${NC}"
+    echo -e "${GREEN}✅ .env file already exists${NC}"
 fi
 
+# Populate missing secrets from runtime environment or main repo .env
+populate_secrets() {
+    echo -e "${BLUE}🔍 Populating secrets from runtime environment...${NC}"
+    
+    # List of secret env vars to populate (prioritize runtime env, fallback to repo .env)
+    secret_vars=("OPENAI_API_KEY" "ANTHROPIC_API_KEY" "GOOGLE_API_KEY" "AGENTOPS_API_KEY")
+    
+    for var in "${secret_vars[@]}"; do
+        # Check if variable is missing or commented out in local .env
+        if ! grep -q "^${var}=" .env 2>/dev/null; then
+            # First try to get value from current runtime environment
+            value="${!var:-}"
+            
+            # If not in runtime env, try to find main repo .env file
+            if [ -z "$value" ]; then
+                local repo_env=""
+                if [ -f "../../../../.env" ]; then
+                    repo_env="../../../../.env"
+                elif [ -f "../../../.env" ]; then
+                    repo_env="../../../.env"
+                elif [ -f "../../.env" ]; then
+                    repo_env="../../.env"
+                fi
+                
+                if [ -n "$repo_env" ] && [ -f "$repo_env" ]; then
+                    value=$(grep "^${var}=" "$repo_env" 2>/dev/null | cut -d'=' -f2-)
+                fi
+            fi
+            
+            # If we found a value (from either source), add it to .env
+            if [ -n "$value" ]; then
+                echo -e "${GREEN}  ✅ Adding ${var}${NC}"
+                # Replace commented placeholder with actual value
+                sed -i.bak "s|^# ${var}=.*|${var}=${value}|" .env
+            else
+                echo -e "${YELLOW}  ⚠️  ${var} not found in runtime env or repo .env${NC}"
+            fi
+        else
+            echo -e "${GREEN}  ✅ ${var} already set in .env${NC}"
+        fi
+    done
+}
+
+# Load environment variables from .env
+echo -e "${BLUE}📋 Loading environment variables from .env file...${NC}"
+
+# Populate secrets before loading (from runtime env or repo .env)
+populate_secrets
+
+set -a  # Export all variables
+source .env
+set +a  # Stop exporting
+
 # Configuration with defaults
 IMAGE_NAME="{{ agent_id }}"
 CONTAINER_NAME="{{ agent_id }}-local"
@@ -45,10 +101,86 @@ if docker ps -a | grep -q $CONTAINER_NAME; then
     docker rm $CONTAINER_NAME >/dev/null 2>&1 || true
 fi
 
+#  Temporarily modify pyproject.toml to use /tmp/IATP for Docker build (if in development mode)
+# Check for local IATP path
+IATP_PATH=""
+for possible_iatp in "../../../../IATP" "../../../IATP" "../../IATP"; do
+    if [ -d "$possible_iatp" ] && [ -f "$possible_iatp/pyproject.toml" ]; then
+        IATP_PATH="$possible_iatp"
+        break
+    fi
+done
+
+if [ -n "$IATP_PATH" ]; then
+    echo -e "${BLUE}📦 Found local IATP at: $IATP_PATH${NC}"
+    echo -e "${BLUE}🔧 Preparing for local IATP build...${NC}"
+    
+    # Backup pyproject.toml
+    cp pyproject.toml pyproject.toml.backup
+    
+    # Modify to use /tmp/IATP (Docker internal path)
+    sed -i.tmp 's|"traia-iatp>=0\.1[^"]*"|"traia-iatp @ file:///tmp/IATP"|g' pyproject.toml
+    rm -f pyproject.toml.tmp
+    echo -e "${GREEN}✅ pyproject.toml configured for local IATP build${NC}"
+fi
+
 # Build the Docker image
 echo -e "${BLUE}🔨 Building Docker image...${NC}"
+
+# Check if pyproject.toml uses local IATP path (for local development)
+if grep -q "file:///tmp/IATP" pyproject.toml 2>/dev/null; then
+    # Extract IATP path from pyproject.toml
+    IATP_PATH_FROM_TOML=$(grep "file://" pyproject.toml | sed -E 's|.*file://([^"]+).*|\1|' | head -1)
+    
+    # If path is /tmp/IATP (Docker path), find the actual local IATP path
+    if [ "$IATP_PATH_FROM_TOML" = "/tmp/IATP" ] || [ ! -d "$IATP_PATH_FROM_TOML" ]; then
+        # Try to find local IATP path (common locations)
+        if [ -d "/Users/eitanlavi/workspace/traia/IATP" ]; then
+            IATP_PATH="/Users/eitanlavi/workspace/traia/IATP"
+        elif [ -d "$(dirname $(pwd))/IATP" ]; then
+            IATP_PATH="$(dirname $(pwd))/IATP"
+        elif [ -d "$HOME/workspace/traia/IATP" ]; then
+            IATP_PATH="$HOME/workspace/traia/IATP"
+        elif [ -n "$LOCAL_IATP_PATH" ] && [ -d "$LOCAL_IATP_PATH" ]; then
+            IATP_PATH="$LOCAL_IATP_PATH"
+        else
+            IATP_PATH=""
+        fi
+    else
+        IATP_PATH="$IATP_PATH_FROM_TOML"
+    fi
+    
+    if [ -n "$IATP_PATH" ] && [ -d "$IATP_PATH" ]; then
+        echo -e "${BLUE}📦 Using local IATP package: $IATP_PATH${NC}"
+        # Copy IATP into build context for Docker (exclude .venv to save space!)
+        mkdir -p .docker-iatp
+        
+        # Use rsync if available (much better), otherwise cp with find
+        if command -v rsync &> /dev/null; then
+            rsync -a --exclude='.venv' --exclude='__pycache__' --exclude='.git' --exclude='build' --exclude='dist' --exclude='*.egg-info' "$IATP_PATH/" .docker-iatp/IATP/
+            echo -e "${BLUE}   Copied IATP to build context (excluded .venv, ${GREEN}saved ~900MB${BLUE})${NC}"
+        else
+            # Fallback: use cp but warn about size
+            cp -r "$IATP_PATH" .docker-iatp/IATP
+            echo -e "${YELLOW}   ⚠️  rsync not found, copied full IATP (install rsync to save ~900MB)${NC}"
+        fi
+    else
+        echo -e "${YELLOW}⚠️  Local IATP path not found: $IATP_PATH_FROM_TOML${NC}"
+        echo -e "${YELLOW}   Docker build will use published package${NC}"
+    fi
+fi
+
 docker build -t $IMAGE_NAME .
 
+# Cleanup .docker-iatp after build
+rm -rf .docker-iatp
+
+# Restore original pyproject.toml if we modified it
+if [ -f pyproject.toml.backup ]; then
+    mv pyproject.toml.backup pyproject.toml
+    echo -e "${BLUE}🔄 Restored original pyproject.toml${NC}"
+fi
+
 # Run the container
 echo -e "${BLUE}🏃 Starting container...${NC}"
 docker run -d \
@@ -78,7 +210,7 @@ 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 "   Agent Info:       ${GREEN}http://localhost:${HOST_PORT}/.well-known/agent-card.json${NC}"
 echo -e "   Container Name:   ${GREEN}${CONTAINER_NAME}${NC}"
 echo -e "   Container ID:     ${GREEN}${CONTAINER_ID:0:12}${NC}"
 echo
@@ -91,13 +223,13 @@ 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
+if curl -s -o /dev/null -w "%{http_code}" "http://localhost:${HOST_PORT}/.well-known/agent-card.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"
+    curl -s "http://localhost:${HOST_PORT}/.well-known/agent-card.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