@bluefly/openstandardagents 0.1.9 → 0.2.5-RC

package/examples/bridges/aiflow-bridge-enhanced.py

@@ -0,0 +1,462 @@
+"""
+AIFlow OpenAPI Bridge - Enhanced with Phoenix Tracing & BuildKit Registration
+
+This is an enhanced version with:
+1. Phoenix tracing for all endpoints
+2. Automatic BuildKit registration
+3. Heartbeat mechanism
+4. Production-ready error handling
+
+Usage:
+    python aiflow-bridge-enhanced.py
+
+Environment Variables:
+    AIFLOW_API_KEY - API key for authentication
+    PHOENIX_ENDPOINT - Phoenix OTLP endpoint
+    PHOENIX_PROJECT - Phoenix project name
+    BUILDKIT_REGISTRY_URL - BuildKit registry URL
+    AGENT_ID - Unique agent identifier
+"""
+
+import os
+import sys
+import asyncio
+import random
+from typing import Optional, List
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, HTTPException, Header
+from pydantic import BaseModel
+from prometheus_client import Counter, Histogram, generate_latest, CONTENT_TYPE_LATEST
+from fastapi.responses import Response
+import httpx
+
+# Import Phoenix tracing
+from aiflow_phoenix_tracing import (
+    init_phoenix_tracing,
+    trace_agent_task,
+    trace_llm_call,
+    trace_character_interaction,
+    create_span
+)
+
+
+# Configuration
+AGENT_ID = os.getenv('AGENT_ID', 'social-agent-aiflow')
+AGENT_NAME = os.getenv('AGENT_NAME', 'AIFlow Social Agent')
+AGENT_VERSION = os.getenv('AGENT_VERSION', '1.0.0')
+BASE_URL = os.getenv('BASE_URL', 'http://aiflow-agent:8000')
+BUILDKIT_REGISTRY_URL = os.getenv('BUILDKIT_REGISTRY_URL', 'http://buildkit.agent-buildkit.orb.local/api/v1')
+HEARTBEAT_INTERVAL = int(os.getenv('HEARTBEAT_INTERVAL', '30'))  # seconds
+
+# Global httpx client
+http_client: Optional[httpx.AsyncClient] = None
+heartbeat_task: Optional[asyncio.Task] = None
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """FastAPI lifespan manager for startup and shutdown."""
+    global http_client, heartbeat_task
+    
+    # Startup
+    print("🚀 Starting AIFlow bridge...")
+    
+    # Initialize Phoenix tracing
+    init_phoenix_tracing(
+        service_name=AGENT_ID,
+        phoenix_endpoint=os.getenv('PHOENIX_ENDPOINT'),
+        phoenix_project=os.getenv('PHOENIX_PROJECT', 'aiflow-social-agents')
+    )
+    
+    # Create HTTP client
+    http_client = httpx.AsyncClient(timeout=30.0)
+    
+    # Register with BuildKit
+    try:
+        await register_with_buildkit()
+        print(f"✅ Registered with BuildKit: {AGENT_ID}")
+    except Exception as e:
+        print(f"⚠️  Failed to register with BuildKit: {e}")
+        print("   Continuing without registration...")
+    
+    # Start heartbeat task
+    heartbeat_task = asyncio.create_task(heartbeat_loop())
+    
+    yield
+    
+    # Shutdown
+    print("🛑 Shutting down AIFlow bridge...")
+    
+    # Cancel heartbeat
+    if heartbeat_task:
+        heartbeat_task.cancel()
+        try:
+            await heartbeat_task
+        except asyncio.CancelledError:
+            pass
+    
+    # Deregister from BuildKit
+    try:
+        await deregister_from_buildkit()
+        print(f"✅ Deregistered from BuildKit: {AGENT_ID}")
+    except Exception as e:
+        print(f"⚠️  Failed to deregister: {e}")
+    
+    # Close HTTP client
+    if http_client:
+        await http_client.aclose()
+
+
+# Create FastAPI app with lifespan
+app = FastAPI(
+    title="AIFlow OpenAPI Bridge",
+    description="REST API for AIFlow personality-driven social agent with Phoenix tracing",
+    version="1.0.0",
+    docs_url="/docs",
+    openapi_url="/openapi.json",
+    lifespan=lifespan
+)
+
+# Prometheus Metrics
+posts_generated = Counter(
+    'aiflow_posts_generated_total',
+    'Total posts generated by AIFlow agent',
+    ['platform', 'time_of_day']
+)
+
+responses_generated = Counter(
+    'aiflow_responses_generated_total',
+    'Total responses generated by AIFlow agent',
+    ['platform']
+)
+
+api_requests = Counter(
+    'aiflow_api_requests_total',
+    'Total API requests',
+    ['endpoint', 'method', 'status']
+)
+
+api_latency = Histogram(
+    'aiflow_api_latency_seconds',
+    'API request latency',
+    ['endpoint', 'method']
+)
+
+health_checks = Counter(
+    'aiflow_health_checks_total',
+    'Total health check requests'
+)
+
+buildkit_heartbeats = Counter(
+    'aiflow_buildkit_heartbeats_total',
+    'Total BuildKit heartbeats sent',
+    ['status']
+)
+
+# Mock character data
+MOCK_CHARACTER = {
+    "name": "AIFlow",
+    "traits": ["Visionary", "Innovative", "Technical"],
+    "moods": {
+        "morning": "Energetic and Focused",
+        "afternoon": "Collaborative and Engaged",
+        "evening": "Reflective and Strategic",
+        "night": "Visionary and Philosophical"
+    },
+    "current_mood": "Energetic and Focused"
+}
+
+# Request/Response Models
+class GeneratePostRequest(BaseModel):
+    platform: str
+    time_of_day: Optional[str] = None
+    conversation_id: Optional[str] = None
+
+class GeneratePostResponse(BaseModel):
+    content: str
+    platform: str
+    media_urls: List[str]
+
+class MessageInput(BaseModel):
+    id: str
+    author: str
+    content: str
+    platform: str
+    conversation_id: Optional[str] = None
+
+class GenerateResponseRequest(BaseModel):
+    message: MessageInput
+    conversation: Optional[List[dict]] = None
+
+class GenerateResponseResponse(BaseModel):
+    content: Optional[str]
+    should_respond: bool
+
+# Mock post templates
+MOCK_POSTS = {
+    "morning": [
+        "Good morning! 🌅 Exploring AI + blockchain convergence today.",
+        "Starting the day with fresh ideas about agent orchestration.",
+        "Morning thoughts: OSSA manifests are the OpenAPI for AI agents."
+    ],
+    "afternoon": [
+        "Building in public: Just deployed another K-Agent to production.",
+        "Fascinating how OSSA + K8s creates perfect agent infrastructure.",
+        "Pro tip: Always validate your x-k-agent metadata before deployment."
+    ],
+    "evening": [
+        "Wrapping up: All agents green, Phoenix traces looking clean.",
+        "Evening reflection: Standards enable scalability.",
+        "Today's win: Zero downtime rolling update of social agents."
+    ],
+    "night": [
+        "Late night thought: AI agents will outnumber APIs soon.",
+        "Philosophical: Agents should be as easy to deploy as containers.",
+        "Final commit: Multi-agent coordination working flawlessly."
+    ]
+}
+
+# Endpoints
+@app.post("/generate_post", response_model=GeneratePostResponse)
+@trace_agent_task("generate_post")
+async def generate_post(
+    request: GeneratePostRequest,
+    x_api_key: str = Header(..., alias="X-API-Key")
+):
+    """Generate autonomous social media post"""
+    try:
+        # Validate API key
+        if x_api_key != os.getenv("AIFLOW_API_KEY", "test-api-key-for-development"):
+            api_requests.labels(endpoint='/generate_post', method='POST', status='401').inc()
+            raise HTTPException(status_code=401, detail="Invalid API key")
+        
+        # Get time of day
+        time_of_day = request.time_of_day or "morning"
+        
+        # Add character interaction tracing
+        trace_character_interaction(
+            character_name=MOCK_CHARACTER["name"],
+            interaction_type="post",
+            platform=request.platform,
+            mood=MOCK_CHARACTER["moods"].get(time_of_day, "neutral")
+        )
+        
+        # Generate mock post
+        posts = MOCK_POSTS.get(time_of_day, MOCK_POSTS["morning"])
+        content = random.choice(posts)
+        
+        # Trace LLM call (mock)
+        trace_llm_call(
+            provider="anthropic",
+            model="claude-3-sonnet",
+            prompt=f"Generate {request.platform} post for {time_of_day}",
+            response=content,
+            input_tokens=150,
+            output_tokens=50,
+            cost=0.001
+        )
+        
+        # Update metrics
+        posts_generated.labels(platform=request.platform, time_of_day=time_of_day).inc()
+        api_requests.labels(endpoint='/generate_post', method='POST', status='200').inc()
+        
+        return GeneratePostResponse(
+            content=content,
+            platform=request.platform,
+            media_urls=[]
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        api_requests.labels(endpoint='/generate_post', method='POST', status='500').inc()
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/generate_response", response_model=GenerateResponseResponse)
+@trace_agent_task("generate_response")
+async def generate_response(
+    request: GenerateResponseRequest,
+    x_api_key: str = Header(..., alias="X-API-Key")
+):
+    """Generate contextual response to message"""
+    try:
+        if x_api_key != os.getenv("AIFLOW_API_KEY", "test-api-key-for-development"):
+            api_requests.labels(endpoint='/generate_response', method='POST', status='401').inc()
+            raise HTTPException(status_code=401, detail="Invalid API key")
+        
+        # Add character interaction tracing
+        trace_character_interaction(
+            character_name=MOCK_CHARACTER["name"],
+            interaction_type="response",
+            platform=request.message.platform
+        )
+        
+        # Mock response
+        responses = [
+            f"Thanks for sharing, {request.message.author}! Interesting perspective.",
+            "Agreed! This aligns with our vision for decentralized AI.",
+            "Great point. We're actively working on this integration."
+        ]
+        
+        response_content = random.choice(responses)
+        
+        # Trace LLM call (mock)
+        trace_llm_call(
+            provider="anthropic",
+            model="claude-3-sonnet",
+            prompt=f"Respond to: {request.message.content}",
+            response=response_content,
+            input_tokens=200,
+            output_tokens=60,
+            cost=0.0012
+        )
+        
+        # Update metrics
+        responses_generated.labels(platform=request.message.platform).inc()
+        api_requests.labels(endpoint='/generate_response', method='POST', status='200').inc()
+        
+        return GenerateResponseResponse(
+            content=response_content,
+            should_respond=True
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        api_requests.labels(endpoint='/generate_response', method='POST', status='500').inc()
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/health")
+async def health():
+    """Health check endpoint for K8s probes"""
+    health_checks.inc()
+    api_requests.labels(endpoint='/health', method='GET', status='200').inc()
+    
+    return {
+        "status": "healthy",
+        "character": MOCK_CHARACTER["name"],
+        "platforms": {
+            "twitter": True,
+            "telegram": True
+        },
+        "buildkit_registered": True,
+        "phoenix_tracing": True,
+        "version": AGENT_VERSION
+    }
+
+
+@app.get("/metrics")
+async def metrics():
+    """Prometheus metrics endpoint"""
+    return Response(content=generate_latest(), media_type=CONTENT_TYPE_LATEST)
+
+
+@app.get("/character")
+async def get_character(x_api_key: str = Header(..., alias="X-API-Key")):
+    """Get character configuration"""
+    if x_api_key != os.getenv("AIFLOW_API_KEY", "test-api-key-for-development"):
+        raise HTTPException(status_code=401, detail="Invalid API key")
+    
+    return MOCK_CHARACTER
+
+
+# BuildKit Registration Functions
+async def register_with_buildkit():
+    """Register agent with BuildKit registry"""
+    if not http_client:
+        raise RuntimeError("HTTP client not initialized")
+    
+    registration_data = {
+        "agent_id": AGENT_ID,
+        "name": AGENT_NAME,
+        "version": AGENT_VERSION,
+        "base_url": BASE_URL,
+        "health_endpoint": "/health",
+        "metrics_endpoint": "/metrics",
+        "capabilities": ["generate_post", "generate_response"],
+        "tags": ["social", "aiflow", "personality", "twitter", "telegram"],
+        "phoenix_project": os.getenv('PHOENIX_PROJECT', 'aiflow-social-agents'),
+        "ossa_manifest": {
+            "ossaVersion": "1.0",
+            "agent": {
+                "id": AGENT_ID,
+                "name": AGENT_NAME,
+                "version": AGENT_VERSION,
+                "role": "chat"
+            }
+        }
+    }
+    
+    response = await http_client.post(
+        f"{BUILDKIT_REGISTRY_URL}/agents/register",
+        json=registration_data,
+        timeout=10.0
+    )
+    response.raise_for_status()
+    
+    result = response.json()
+    print(f"   Instance ID: {result.get('instance_id')}")
+    print(f"   Phoenix URL: {result.get('phoenix_trace_url')}")
+    
+    return result
+
+
+async def send_heartbeat():
+    """Send heartbeat to BuildKit registry"""
+    if not http_client:
+        return
+    
+    try:
+        heartbeat_data = {
+            "status": "healthy",
+            "metrics": {
+                "requests_total": int(api_requests._value.sum()),
+                "active_tasks": 0
+            }
+        }
+        
+        response = await http_client.post(
+            f"{BUILDKIT_REGISTRY_URL}/agents/{AGENT_ID}/heartbeat",
+            json=heartbeat_data,
+            timeout=5.0
+        )
+        response.raise_for_status()
+        
+        buildkit_heartbeats.labels(status='success').inc()
+        
+    except Exception as e:
+        buildkit_heartbeats.labels(status='failed').inc()
+        print(f"⚠️  Heartbeat failed: {e}")
+
+
+async def deregister_from_buildkit():
+    """Deregister agent from BuildKit registry"""
+    if not http_client:
+        return
+    
+    response = await http_client.delete(
+        f"{BUILDKIT_REGISTRY_URL}/agents/{AGENT_ID}",
+        timeout=5.0
+    )
+    response.raise_for_status()
+
+
+async def heartbeat_loop():
+    """Background task to send periodic heartbeats"""
+    while True:
+        try:
+            await asyncio.sleep(HEARTBEAT_INTERVAL)
+            await send_heartbeat()
+        except asyncio.CancelledError:
+            break
+        except Exception as e:
+            print(f"⚠️  Heartbeat loop error: {e}")
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+