@intentsolutionsio/jeremy-adk-orchestrator 2.1.0

package/skills/adk-deployment-specialist/scripts/deploy-agent.sh

@@ -0,0 +1,157 @@
+#!/bin/bash
+# deploy-agent.sh - Deploy ADK agent to Vertex AI Agent Engine
+# Uses the Python SDK (vertexai.Client) since there is no gcloud CLI for Agent Engine.
+
+set -euo pipefail
+
+# Colors
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+NC='\033[0m'
+
+# Configuration
+AGENT_DIR="${1:-}"
+PROJECT_ID="${2:-${GCP_PROJECT_ID:-}}"
+REGION="${3:-us-central1}"
+DISPLAY_NAME="${4:-}"
+
+usage() {
+    cat <<EOF
+Usage: $0 <AGENT_DIR> [PROJECT_ID] [REGION] [DISPLAY_NAME]
+
+Deploy ADK agent to Vertex AI Agent Engine using the Python SDK.
+
+NOTE: There is no gcloud CLI for Agent Engine. This script uses the
+vertexai Python SDK (vertexai.Client.agent_engines.create).
+
+Arguments:
+    AGENT_DIR     Directory containing agent code (must have agent.py)
+    PROJECT_ID    GCP project ID (default: \$GCP_PROJECT_ID)
+    REGION        GCP region (default: us-central1)
+    DISPLAY_NAME  Agent display name (default: directory name)
+
+Example:
+    $0 ./my-agent my-project us-central1 my-agent
+    GCP_PROJECT_ID=my-project $0 ./agent
+
+Requirements:
+    pip install google-adk>=1.15.1 google-cloud-aiplatform>=1.120.0
+
+EOF
+    exit 1
+}
+
+if [[ -z "$AGENT_DIR" ]]; then
+    echo "Error: AGENT_DIR is required"
+    usage
+fi
+
+if [[ ! -d "$AGENT_DIR" ]]; then
+    echo -e "${RED}Error: Agent directory not found: $AGENT_DIR${NC}"
+    exit 1
+fi
+
+if [[ -z "$PROJECT_ID" ]]; then
+    echo "Error: PROJECT_ID is required (set GCP_PROJECT_ID env var or provide as argument)"
+    usage
+fi
+
+# Default display name to directory basename
+if [[ -z "$DISPLAY_NAME" ]]; then
+    DISPLAY_NAME=$(basename "$AGENT_DIR")
+fi
+
+echo -e "${GREEN}Deploying ADK Agent to Vertex AI Agent Engine${NC}"
+echo "Agent Dir: $AGENT_DIR"
+echo "Project: $PROJECT_ID"
+echo "Region: $REGION"
+echo "Display Name: $DISPLAY_NAME"
+echo ""
+
+# Check Python SDK is installed
+if ! python3 -c "import vertexai" 2>/dev/null; then
+    echo -e "${YELLOW}Vertex AI SDK not found. Installing...${NC}"
+    pip install google-cloud-aiplatform[agent_engines]>=1.120.0 google-adk>=1.15.1
+fi
+
+# Validate agent files
+echo "Validating agent directory..."
+if [[ ! -f "$AGENT_DIR/agent.py" ]]; then
+    echo -e "${RED}Error: agent.py not found in $AGENT_DIR${NC}"
+    exit 1
+fi
+
+if ! python3 -m py_compile "$AGENT_DIR/agent.py"; then
+    echo -e "${RED}Error: agent.py has syntax errors${NC}"
+    exit 1
+fi
+echo -e "${GREEN}Agent files valid${NC}"
+
+# Check for requirements.txt
+REQUIREMENTS_FILE="$AGENT_DIR/requirements.txt"
+if [[ ! -f "$REQUIREMENTS_FILE" ]]; then
+    echo -e "${YELLOW}Warning: No requirements.txt found. Using default ADK dependencies.${NC}"
+fi
+
+# Deploy using Python SDK
+echo ""
+echo "Deploying agent via vertexai.Client.agent_engines.create()..."
+echo ""
+
+python3 -c "
+import sys
+sys.path.insert(0, '${AGENT_DIR}')
+
+import vertexai
+
+# Import the agent from the agent directory
+from agent import root_agent
+
+# Initialize client
+client = vertexai.Client(project='${PROJECT_ID}', location='${REGION}')
+
+# Read requirements if available
+requirements = ['google-adk>=1.15.1']
+try:
+    with open('${REQUIREMENTS_FILE}', 'r') as f:
+        requirements = [
+            line.strip() for line in f
+            if line.strip() and not line.startswith('#')
+        ]
+except FileNotFoundError:
+    pass
+
+# Deploy to Agent Engine
+print('Creating reasoning engine...')
+remote_agent = client.agent_engines.create(
+    agent_engine=root_agent,
+    requirements=requirements,
+    display_name='${DISPLAY_NAME}',
+)
+
+print()
+print('Agent deployed successfully!')
+print(f'Resource Name: {remote_agent.resource_name}')
+print()
+print('To query this agent:')
+print(f\"  python3 -c \\\"import vertexai; c = vertexai.Client(project='{PROJECT_ID}', location='{REGION}'); a = c.agent_engines.get(name='{{}}'.format(remote_agent.resource_name)); print(a.query(input='Hello'))\\\"\")
+print()
+print('To list all agents:')
+print(f\"  python3 -c \\\"import vertexai; c = vertexai.Client(project='{PROJECT_ID}', location='{REGION}'); [print(a.display_name, a.resource_name) for a in c.agent_engines.list()]\\\"\")
+"
+
+DEPLOY_STATUS=$?
+
+if [[ $DEPLOY_STATUS -eq 0 ]]; then
+    echo ""
+    echo -e "${GREEN}Deployment complete${NC}"
+else
+    echo ""
+    echo -e "${RED}Deployment failed (exit code: $DEPLOY_STATUS)${NC}"
+    echo "Check logs for details. Common issues:"
+    echo "  - Missing IAM roles (need roles/aiplatform.admin)"
+    echo "  - Quota exceeded (default: 10 reasoning engines per project)"
+    echo "  - Invalid agent definition (check tool function signatures)"
+    exit 1
+fi

package/skills/adk-deployment-specialist/scripts/test-a2a-protocol.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+"""
+test-a2a-protocol.py - Test A2A protocol endpoints for deployed ADK agent
+
+Tests:
+- AgentCard retrieval
+- Task submission
+- Status polling
+- Protocol compliance
+"""
+
+import json
+import sys
+import time
+from typing import Dict, Optional
+import subprocess
+
+
+def get_access_token() -> str:
+    """Get GCP access token"""
+    result = subprocess.run(
+        ["gcloud", "auth", "print-access-token"],
+        capture_output=True,
+        text=True
+    )
+    return result.stdout.strip()
+
+
+def test_agent_card(agent_url: str, token: str) -> Dict:
+    """Test AgentCard endpoint"""
+    import urllib.request
+    import urllib.error
+
+    print("Testing AgentCard endpoint...")
+    agent_card_url = f"{agent_url}/.well-known/agent-card"
+
+    try:
+        req = urllib.request.Request(
+            agent_card_url,
+            headers={"Authorization": f"Bearer {token}"}
+        )
+        with urllib.request.urlopen(req, timeout=10) as response:
+            agent_card = json.loads(response.read().decode())
+
+        print("✓ AgentCard retrieved successfully")
+        print(f"  Name: {agent_card.get('name', 'unknown')}")
+        print(f"  Description: {agent_card.get('description', 'unknown')}")
+        print(f"  Version: {agent_card.get('version', 'unknown')}")
+
+        # Validate required fields
+        required_fields = ["name", "description", "capabilities"]
+        missing = [f for f in required_fields if f not in agent_card]
+
+        if missing:
+            print(f"⚠ Missing required fields: {', '.join(missing)}")
+            return {"status": "partial", "card": agent_card, "missing": missing}
+
+        print("✓ All required fields present")
+        return {"status": "success", "card": agent_card}
+
+    except urllib.error.HTTPError as e:
+        print(f"✗ AgentCard request failed: {e.code} {e.reason}")
+        return {"status": "failed", "error": str(e)}
+    except Exception as e:
+        print(f"✗ Error retrieving AgentCard: {e}")
+        return {"status": "failed", "error": str(e)}
+
+
+def test_task_submission(agent_url: str, token: str, message: str) -> Optional[str]:
+    """Test task submission"""
+    import urllib.request
+    import urllib.error
+
+    print("\nTesting Task Submission API (A2A JSON-RPC)...")
+    task_url = agent_url  # A2A uses a single endpoint with JSON-RPC methods
+
+    payload = {
+        "jsonrpc": "2.0",
+        "method": "tasks/send",
+        "params": {
+            "id": f"test-task-{int(time.time())}",
+            "message": {
+                "role": "user",
+                "parts": [{"text": message}],
+            },
+        },
+        "id": f"req-{int(time.time())}",
+    }
+
+    try:
+        req = urllib.request.Request(
+            task_url,
+            data=json.dumps(payload).encode(),
+            headers={
+                "Authorization": f"Bearer {token}",
+                "Content-Type": "application/json"
+            },
+            method="POST"
+        )
+
+        with urllib.request.urlopen(req, timeout=30) as response:
+            result = json.loads(response.read().decode())
+
+        task_id = result.get("task_id")
+        print(f"✓ Task submitted successfully")
+        print(f"  Task ID: {task_id}")
+        print(f"  Status: {result.get('status', 'unknown')}")
+
+        return task_id
+
+    except urllib.error.HTTPError as e:
+        print(f"✗ Task submission failed: {e.code} {e.reason}")
+        try:
+            error_body = e.read().decode()
+            print(f"  Error details: {error_body}")
+        except Exception:
+            pass
+        return None
+    except Exception as e:
+        print(f"✗ Error submitting task: {e}")
+        return None
+
+
+def test_task_status(agent_url: str, token: str, task_id: str, max_wait: int = 60) -> bool:
+    """Test task status polling"""
+    import urllib.request
+    import urllib.error
+
+    print("\nTesting Task Status API (A2A JSON-RPC tasks/get)...")
+    status_url = agent_url  # A2A uses single endpoint with JSON-RPC methods
+
+    start_time = time.time()
+
+    while time.time() - start_time < max_wait:
+        try:
+            status_payload = json.dumps({
+                "jsonrpc": "2.0",
+                "method": "tasks/get",
+                "params": {"id": task_id},
+                "id": f"status-{int(time.time())}",
+            }).encode()
+
+            req = urllib.request.Request(
+                status_url,
+                data=status_payload,
+                headers={
+                    "Authorization": f"Bearer {token}",
+                    "Content-Type": "application/json",
+                },
+                method="POST",
+            )
+
+            with urllib.request.urlopen(req, timeout=10) as response:
+                result = json.loads(response.read().decode())
+
+            # A2A task statuses: submitted, working, input-required, completed, failed, canceled
+            task_result = result.get("result", {})
+            status = task_result.get("status", {}).get("state", "unknown")
+
+            print(f"  Status: {status}")
+
+            if status == "completed":
+                print("Task completed successfully")
+                artifacts = task_result.get("artifacts", [])
+                if artifacts:
+                    first_part = artifacts[0].get("parts", [{}])[0].get("text", "")
+                    if first_part:
+                        print(f"  Response: {first_part[:100]}...")
+                return True
+
+            elif status == "failed":
+                error_msg = task_result.get("status", {}).get("message", "unknown error")
+                print(f"Task failed: {error_msg}")
+                return False
+
+            elif status in ["submitted", "working"]:
+                time.sleep(5)
+                continue
+
+            else:
+                print(f"Unknown status: {status}")
+                time.sleep(5)
+
+        except urllib.error.HTTPError as e:
+            print(f"✗ Status check failed: {e.code} {e.reason}")
+            return False
+        except Exception as e:
+            print(f"✗ Error checking status: {e}")
+            return False
+
+    print(f"⚠ Timeout waiting for task completion ({max_wait}s)")
+    return False
+
+
+def run_protocol_tests(agent_url: str, test_message: str = "Hello, test message"):
+    """Run all A2A protocol tests"""
+    print("=" * 70)
+    print("A2A Protocol Compliance Test")
+    print("=" * 70)
+    print(f"Agent URL: {agent_url}")
+    print(f"Test Message: {test_message}")
+    print("=" * 70)
+    print()
+
+    # Get access token
+    token = get_access_token()
+    if not token:
+        print("✗ Failed to get access token")
+        sys.exit(1)
+
+    # Test 1: AgentCard
+    card_result = test_agent_card(agent_url, token)
+
+    # Test 2: Task Submission
+    task_id = test_task_submission(agent_url, token, test_message)
+
+    # Test 3: Status Polling (if task was submitted)
+    status_success = False
+    if task_id:
+        status_success = test_task_status(agent_url, token, task_id)
+
+    # Summary
+    print("\n" + "=" * 70)
+    print("Test Summary")
+    print("=" * 70)
+
+    tests_passed = 0
+    tests_total = 3
+
+    if card_result.get("status") == "success":
+        print("✓ AgentCard Test: PASSED")
+        tests_passed += 1
+    else:
+        print("✗ AgentCard Test: FAILED")
+
+    if task_id:
+        print("✓ Task Submission Test: PASSED")
+        tests_passed += 1
+    else:
+        print("✗ Task Submission Test: FAILED")
+
+    if status_success:
+        print("✓ Task Status Test: PASSED")
+        tests_passed += 1
+    else:
+        print("✗ Task Status Test: FAILED")
+
+    print(f"\nResult: {tests_passed}/{tests_total} tests passed")
+
+    if tests_passed == tests_total:
+        print("🟢 A2A Protocol: COMPLIANT")
+        sys.exit(0)
+    elif tests_passed >= 2:
+        print("🟡 A2A Protocol: PARTIALLY COMPLIANT")
+        sys.exit(1)
+    else:
+        print("🔴 A2A Protocol: NOT COMPLIANT")
+        sys.exit(2)
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: test-a2a-protocol.py <AGENT_URL> [TEST_MESSAGE]")
+        print("\nTest A2A protocol compliance for deployed ADK agent")
+        print("\nExample:")
+        print("  test-a2a-protocol.py https://my-agent-xyz.run.app")
+        print("  test-a2a-protocol.py https://my-agent-xyz.run.app 'Deploy a GKE cluster'")
+        sys.exit(1)
+
+    agent_url = sys.argv[1].rstrip("/")
+    test_message = sys.argv[2] if len(sys.argv) > 2 else "Hello, this is a test message"
+
+    run_protocol_tests(agent_url, test_message)
+
+
+if __name__ == "__main__":
+    main()