open_source/semantic_telemetry.py

#!/usr/bin/env python3
"""
AICoevolution Semantic Telemetry (Production)
=============================================
A lightweight tool to measure semantic dynamics in human-AI conversations.
This version is optimized for production use with the AICoevolution Cloud SDK.

Usage:
    python semantic_telemetry_prod.py --api-key aic_...
    python semantic_telemetry_prod.py --api-key aic_... --hosted-ai

Requirements:
    pip install requests
"""

import argparse
import json
import os
import sys
import time
import uuid
from dataclasses import dataclass
from typing import Any, Dict, List, Optional

# =============================================================================
# CONFIGURATION
# =============================================================================

DEFAULT_SDK_URL = "https://sdk.aicoevolution.com"

# ANSI colors for terminal output
class Colors:
    HEADER = '\033[95m'
    BLUE = '\033[94m'
    CYAN = '\033[96m'
    GREEN = '\033[92m'
    YELLOW = '\033[93m'
    RED = '\033[91m'
    ENDC = '\033[0m'
    BOLD = '\033[1m'
    UNDERLINE = '\033[4m'

def _disable_colors():
    """Disable ANSI colors (prints become plain text)."""
    for k in list(Colors.__dict__.keys()):
        if k.isupper():
            setattr(Colors, k, "")

def _init_console_colors(enable: bool) -> None:
    """
    Ensure colors render on Windows terminals.
    If color support isn't available, fall back to plain text.
    """
    if not enable or os.getenv("NO_COLOR") or os.getenv("AIC_NO_COLOR"):
        _disable_colors()
        return

    if os.name == "nt":
        try:
            import colorama  # type: ignore
            # Translates ANSI escapes for Windows consoles.
            try:
                colorama.just_fix_windows_console()
            except Exception:
                colorama.init()
        except Exception:
            _disable_colors()

# =============================================================================
# DATA STRUCTURES
# =============================================================================

@dataclass
class TelemetryMetrics:
    """Standardized metrics from SDK response."""
    sgi: Optional[float]
    velocity: Optional[float]
    context_phase: str
    context_mass: int
    attractor_count: int
    context_drift: float
    processing_time_ms: int

@dataclass
class CoevolutionIndex:
    """Computed Coevolution Index (CI)."""
    coevolution_index: float
    tier: str  # BASIC | ELEVATED | HIGH
    horizontal_score: float
    vertical_score: float
    
    # Components
    coherence_region_occupancy: float
    dyadic_coherence_index: float
    context_stability: float
    symbolic_entropy: float
    path_transformation_density: float
    domain_balance_index: float

# =============================================================================
# SDK CLIENT
# =============================================================================

class SemanticTelemetryClient:
    """Client for interacting with the AICoevolution SDK."""
    
    def __init__(self, api_key: str, base_url: str = DEFAULT_SDK_URL):
        self.api_key = api_key
        self.base_url = base_url.rstrip("/")
        self.conversation_id = str(uuid.uuid4())
        self.message_count = 0
        self.messages = []  # Local history for hosted AI context
        
        # Validate connection on init
        try:
            import requests
            self.session = requests.Session()
            if api_key:
                self.session.headers.update({"Authorization": f"Bearer {api_key}"})
        except ImportError:
            print("Error: 'requests' library not found.")
            print("Please install it: pip install requests")
            sys.exit(1)

    def ingest_message(self, role: str, text: str) -> Optional[Dict[str, Any]]:
        """Send a message to the SDK for telemetry analysis."""
        url = f"{self.base_url}/v0/ingest"
        payload = {
            "conversation_id": self.conversation_id,
            "role": role,
            "text": text,
            "timestamp_ms": int(time.time() * 1000)
        }
        
        try:
            response = self.session.post(url, json=payload, timeout=10)
            if response.status_code == 401:
                # FastAPI typically returns JSON {"detail": ...}; include body when present.
                body = (response.text or "").strip()
                if body:
                    body = body[:800] + ("..." if len(body) > 800 else "")
                    print(f"\n{Colors.RED}[SDK Error] Invalid API Key :: {body}{Colors.ENDC}")
                else:
                    print(f"\n{Colors.RED}[SDK Error] Invalid API Key.{Colors.ENDC}")
                return None
            response.raise_for_status()
            self.message_count += 1
            return response.json()
        except Exception as e:
            # Surface server-provided details where possible.
            resp = getattr(e, "response", None)
            if resp is not None:
                body = (resp.text or "").strip()
                body = body[:800] + ("..." if len(body) > 800 else "")
                if body:
                    print(f"\n{Colors.RED}[SDK Error] Connection failed: {e} :: {body}{Colors.ENDC}")
                    return None
            print(f"\n{Colors.RED}[SDK Error] Connection failed: {e}{Colors.ENDC}")
            return None

    def hosted_chat(self, user_message: str) -> Optional[Dict[str, Any]]:
        """Send message to hosted AI endpoint (paid tier only)."""
        url = f"{self.base_url}/v0/chat"
        payload = {
            "message": user_message,
            "conversation_id": self.conversation_id,
            "messages": self.messages[-10:]  # Send recent context
        }
        
        try:
            # Hosted AI can take longer (LLM generation)
            response = self.session.post(url, json=payload, timeout=60)
            
            if response.status_code == 401:
                body = (response.text or "").strip()
                if body:
                    body = body[:800] + ("..." if len(body) > 800 else "")
                    print(f"\n{Colors.RED}[SDK Error] Unauthorized :: {body}{Colors.ENDC}")
                else:
                    print(f"\n{Colors.RED}[SDK Error] Unauthorized. Hosted AI requires a paid API key.{Colors.ENDC}")
                return None
            elif response.status_code == 402:
                body = (response.text or "").strip()
                if body:
                    body = body[:800] + ("..." if len(body) > 800 else "")
                    print(f"\n{Colors.RED}[SDK Error] Payment required :: {body}{Colors.ENDC}")
                else:
                    print(f"\n{Colors.RED}[SDK Error] Payment required. Upgrade to a paid tier for Hosted AI.{Colors.ENDC}")
                return None
                
            response.raise_for_status()
            self.message_count += 2  # User + Assistant
            return response.json()
        except Exception as e:
            resp = getattr(e, "response", None)
            if resp is not None:
                body = (resp.text or "").strip()
                body = body[:800] + ("..." if len(body) > 800 else "")
                if body:
                    print(f"\n{Colors.RED}[SDK Error] Chat request failed: {e} :: {body}{Colors.ENDC}")
                    return None
            print(f"\n{Colors.RED}[SDK Error] Chat request failed: {e}{Colors.ENDC}")
            return None

    def extract_metrics(self, response: Dict[str, Any]) -> TelemetryMetrics:
        """Extract standardized metrics from SDK response.
        
        Paper 03 canonical metrics:
        - SGI: turn_pair_sgi_latest (or fallback to sgi_latest)
        - Velocity: orbital_velocity_latest (turn-pair, ~25-45°)
          Fallback: angular_velocity_latest (per-message, ~75-180°)
        
        Turn-pair metrics have lower variance and are the canonical choice.
        The SDK now exposes these at top level for easy access.
        """
        # Paper 03: Prefer turn-pair SGI when available (now at top level)
        sgi = (
            response.get("turn_pair_sgi_latest")
            or response.get("sgi_latest")
        )
        
        # Paper 03: Prefer orbital velocity (turn-pair, ~25-45°) over angular (per-message, ~75-180°)
        velocity = (
            response.get("orbital_velocity_latest")
            or response.get("angular_velocity_latest")
        )
        
        return TelemetryMetrics(
            sgi=sgi,
            velocity=velocity,
            context_phase=response.get("context_phase", "stable"),
            context_mass=response.get("context_mass", 0),
            attractor_count=response.get("attractor_count", 1),
            context_drift=response.get("context_drift", 0.0),
            processing_time_ms=response.get("processing_time_ms", 0)
        )

# =============================================================================
# COEVOLUTION TRACKER (Client-Side Logic)
# =============================================================================

class CoevolutionTracker:
    """Tracks session dynamics to compute the Coevolution Index."""
    
    def __init__(self):
        self.turns: List[TelemetryMetrics] = []
        self.sgi_history: List[float] = []
        self.velocity_history: List[float] = []
        
    def add_turn(self, metrics: TelemetryMetrics):
        self.turns.append(metrics)
        if metrics.sgi is not None:
            self.sgi_history.append(metrics.sgi)
        if metrics.velocity is not None:
            self.velocity_history.append(metrics.velocity)
            
    def compute_index(self) -> CoevolutionIndex:
        """Compute the Coevolution Index based on accumulated history."""
        if not self.turns:
            return CoevolutionIndex(0, "BASIC", 0, 0, 0, 0, 0, 0, 0, 0)
            
        # 1. Horizontal Score (Hs) - Dynamics
        # Coherence Region: SGI > 0.6 AND Velocity < 30 deg
        coherence_count = sum(1 for s, v in zip(self.sgi_history, self.velocity_history) 
                            if s > 0.6 and v < 30.0)
        coherence_occupancy = coherence_count / len(self.turns) if self.turns else 0
        
        # Dyadic Coherence: Mean SGI
        dyadic_coherence = sum(self.sgi_history) / len(self.sgi_history) if self.sgi_history else 0
        
        # Context Stability: 1.0 - normalized drift
        avg_drift = sum(t.context_drift for t in self.turns) / len(self.turns) if self.turns else 0
        context_stability = max(0.0, 1.0 - (avg_drift / 100.0))
        
        hs = (coherence_occupancy * 0.4) + (dyadic_coherence * 0.4) + (context_stability * 0.2)
        
        # 2. Vertical Score (Vs) - Depth (Simplified for Prod)
        # In production script without S64/Stage1, we use placeholders or simplified proxies
        # For now, we fix these to baseline values as full S64 is in the Dev script
        symbolic_entropy = 0.5 
        path_density = 0.0
        domain_balance = 0.5
        
        vs = (symbolic_entropy * 0.3) + (path_density * 0.4) + (domain_balance * 0.3)
        
        # 3. Coevolution Index
        ci = (hs * 0.6) + (vs * 0.4)
        
        # Tier
        if ci >= 0.7: tier = "HIGH"
        elif ci >= 0.4: tier = "ELEVATED"
        else: tier = "BASIC"
        
        return CoevolutionIndex(
            coevolution_index=ci,
            tier=tier,
            horizontal_score=hs,
            vertical_score=vs,
            coherence_region_occupancy=coherence_occupancy,
            dyadic_coherence_index=dyadic_coherence,
            context_stability=context_stability,
            symbolic_entropy=symbolic_entropy,
            path_transformation_density=path_density,
            domain_balance_index=domain_balance
        )

# =============================================================================
# UI HELPERS
# =============================================================================

def print_header():
    print(f"\n{Colors.CYAN}{Colors.BOLD}")
    print("╔══════════════════════════════════════════════════════════════╗")
    print("║           AICoevolution Semantic Telemetry (v1.0)            ║")
    print("╚══════════════════════════════════════════════════════════════╝")
    print(f"{Colors.ENDC}")

def print_metrics(m: TelemetryMetrics):
    print(f"{Colors.BLUE}  Metrics:{Colors.ENDC}")
    
    # SGI
    sgi_color = Colors.GREEN if (m.sgi or 0) > 0.7 else Colors.YELLOW if (m.sgi or 0) > 0.4 else Colors.RED
    print(f"    SGI:           {sgi_color}{m.sgi:.3f}{Colors.ENDC}" if m.sgi is not None else "    SGI:           N/A")
    
    # Velocity
    vel_color = Colors.GREEN if (m.velocity or 0) < 15 else Colors.YELLOW if (m.velocity or 0) < 45 else Colors.RED
    print(f"    Velocity:      {vel_color}{m.velocity:.1f}°{Colors.ENDC}" if m.velocity is not None else "    Velocity:      N/A")
    
    # Context
    print(f"    Context Phase: {m.context_phase}")
    print(f"    Context Mass:  {m.context_mass}")

def print_ci(ci: CoevolutionIndex):
    tier_color = Colors.GREEN if ci.tier == "HIGH" else Colors.YELLOW if ci.tier == "ELEVATED" else Colors.RED
    print(f"\n{Colors.BOLD}──────────────────────── COEVOLUTION INDEX ─────────────────────────{Colors.ENDC}")
    print(f"  CI: {tier_color}{ci.coevolution_index:.3f} [{ci.tier}]{Colors.ENDC}")
    print(f"  Horizontal Score: {ci.horizontal_score:.3f}")
    print(f"  Vertical Score:   {ci.vertical_score:.3f} (Limited in Prod)")
    print(f"{Colors.BOLD}────────────────────────────────────────────────────────────────────{Colors.ENDC}")

# =============================================================================
# MAIN LOOP
# =============================================================================

def run_session(client: SemanticTelemetryClient, turns: int, hosted_ai: bool):
    print_header()
    print(f"Session ID: {client.conversation_id}")
    print(f"Target:     {client.base_url}")
    print(f"Mode:       {'Hosted AI' if hosted_ai else 'Manual Entry'}")
    print("\nType 'quit' to exit.\n")
    
    tracker = CoevolutionTracker()
    
    for i in range(turns):
        print(f"\n{Colors.BOLD}--- Turn {i+1}/{turns} ---{Colors.ENDC}")
        
        # User Input
        try:
            user_text = input(f"{Colors.GREEN}[YOU]:{Colors.ENDC} ").strip()
        except (KeyboardInterrupt, EOFError):
            break
            
        if user_text.lower() in ('quit', 'exit'):
            break
        if not user_text:
            continue
            
        # Process Turn
        if hosted_ai:
            print(f"{Colors.CYAN}  ... generating response ...{Colors.ENDC}")
            client.messages.append({"role": "user", "content": user_text})
            
            data = client.hosted_chat(user_text)
            if not data: continue
            
            reply = data.get("reply", "")
            sdk_data = data.get("sdk", {})
            quota = data.get("quota") if isinstance(data, dict) else None
            turns_left = None
            try:
                if isinstance(quota, dict) and isinstance(quota.get("remaining"), int):
                    turns_left = max(0, int(quota["remaining"]) // 2)
            except Exception:
                turns_left = None
            client.messages.append({"role": "assistant", "content": reply})
            
            print(f"{Colors.BLUE}[AI]:{Colors.ENDC} {reply}\n")
            
            metrics = client.extract_metrics(sdk_data)
            print_metrics(metrics)
            tracker.add_turn(metrics)
            print_ci(tracker.compute_index())
            if turns_left is not None:
                print(f"{Colors.CYAN}  Turns left this week: {turns_left}{Colors.ENDC}")
            
        else:
            # Manual Mode
            print(f"{Colors.CYAN}  ... ingesting ...{Colors.ENDC}")
            resp = client.ingest_message("user", user_text)
            if resp:
                m = client.extract_metrics(resp)
                sgi_str = f"{m.sgi:.2f}" if m.sgi is not None else "N/A"
                print(f"  [SDK] User turn ingested (SGI={sgi_str})")
            
            try:
                ai_text = input(f"{Colors.BLUE}[AI]:{Colors.ENDC} ").strip()
            except (KeyboardInterrupt, EOFError):
                break
                
            if not ai_text: ai_text = "(no response)"
            
            print(f"{Colors.CYAN}  ... ingesting ...{Colors.ENDC}")
            resp = client.ingest_message("assistant", ai_text)
            if resp:
                metrics = client.extract_metrics(resp)
                print_metrics(metrics)
                tracker.add_turn(metrics)
                print_ci(tracker.compute_index())

# =============================================================================
# CLI ENTRY POINT
# =============================================================================

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="AICoevolution Semantic Telemetry (Production)")
    parser.add_argument("--api-key", required=True, help="Your AICoevolution API Key")
    parser.add_argument("--url", help=f"Custom SDK URL (default: {DEFAULT_SDK_URL})")
    parser.add_argument("--hosted-ai", action="store_true", help="Use Hosted AI for responses")
    parser.add_argument("--turns", type=int, default=10, help="Number of turns")
    parser.add_argument("--no-color", action="store_true", help="Disable colored output")
    
    args = parser.parse_args()
    _init_console_colors(enable=not args.no_color)
    
    client = SemanticTelemetryClient(args.api_key, base_url=(args.url or DEFAULT_SDK_URL))
    run_session(client, args.turns, args.hosted_ai)