kalibr 1.1.2a0__py3-none-any.whl → 1.2.0__py3-none-any.whl

kalibr/__init__.py

@@ -1,36 +1,24 @@
-"""Kalibr SDK v1.1.0 - Unified LLM Observability & Multi-Model AI Integration Framework
-
-This SDK combines:
-1. Full LLM Observability with tracing, cost tracking, and analytics
-2. Multi-Model AI Integration (GPT, Claude, Gemini, Copilot)
-3. One-line deployment with Docker and runtime router
-4. Schema generation for all major AI platforms
-5. **NEW in 1.1.0**: Auto-instrumentation of LLM SDKs (OpenAI, Anthropic, Google)
+"""Kalibr SDK v1.2.0 - LLM Observability & Tracing Framework
 
 Features:
 - **Auto-Instrumentation**: Zero-config tracing of OpenAI, Anthropic, Google SDK calls
 - **OpenTelemetry**: OTel-compatible spans with OTLP export
 - **Tracing**: Complete telemetry with @trace decorator
 - **Cost Tracking**: Multi-vendor cost calculation (OpenAI, Anthropic, etc.)
-- **Deployment**: One-command deployment to Fly.io, Render, or local
-- **Schema Generation**: Auto-generate schemas for GPT Actions, Claude MCP, Gemini, Copilot
 - **Error Handling**: Automatic error capture with stack traces
 - **Analytics**: ClickHouse-backed analytics and alerting
 
-Usage - Auto-Instrumentation (NEW):
-    from kalibr import Kalibr
+Usage - Auto-Instrumentation:
+    from kalibr import auto_instrument
     import openai  # Automatically instrumented!
 
-    app = Kalibr(title="My API")
+    auto_instrument(["openai", "anthropic", "google"])
 
-    @app.action("chat", "Chat with GPT")
-    def chat(message: str):
-        # This OpenAI call is automatically traced!
-        response = openai.chat.completions.create(
-            model="gpt-4",
-            messages=[{"role": "user", "content": message}]
-        )
-        return response.choices[0].message.content
+    # All LLM calls are now traced automatically
+    response = openai.chat.completions.create(
+        model="gpt-4",
+        messages=[{"role": "user", "content": "Hello!"}]
+    )
 
 Usage - Manual Tracing:
     from kalibr import trace
@@ -44,13 +32,11 @@ Usage - Manual Tracing:
         return response
 
 CLI Usage:
-    kalibr serve my_app.py              # Run locally
-    kalibr deploy my_app.py --runtime fly  # Deploy to Fly.io
     kalibr run my_app.py                # Run with auto-tracing
     kalibr version                       # Show version
 """
 
-__version__ = "1.1.0-alpha"
+__version__ = "1.2.0"
 
 # Auto-instrument LLM SDKs on import (can be disabled via env var)
 import os
@@ -79,25 +65,22 @@ from .cost_adapter import (
 )
 from .instrumentation import auto_instrument, get_instrumented_providers
 
-# ============================================================================
-# SDK & DEPLOYMENT (from 1.0.30)
-# ============================================================================
-from .kalibr import Kalibr
-from .kalibr_app import KalibrApp
 from .models import EventData, TraceConfig
-from .schemas import (
-    generate_copilot_schema,
-    generate_gemini_schema,
-    generate_mcp_schema,
-    get_base_url,
-    get_supported_models,
-)
 from .simple_tracer import trace
 from .trace_capsule import TraceCapsule, get_or_create_capsule
 from .tracer import SpanContext, Tracer
-from .types import FileUpload, Session
 from .utils import load_config_from_env
 
+# ============================================================================
+# INTELLIGENCE & OUTCOME ROUTING (v1.2.0)
+# ============================================================================
+from .intelligence import (
+    KalibrIntelligence,
+    get_policy,
+    report_outcome,
+    get_recommendation,
+)
+
 if os.getenv("KALIBR_AUTO_INSTRUMENT", "true").lower() == "true":
     # Setup OpenTelemetry collector
     try:
@@ -145,21 +128,6 @@ __all__ = [
     # Utils
     "load_config_from_env",
     # ========================================================================
-    # SDK & DEPLOYMENT
-    # ========================================================================
-    # SDK Classes
-    "Kalibr",
-    "KalibrApp",
-    # Types
-    "FileUpload",
-    "Session",
-    # Schema Generation
-    "get_base_url",
-    "generate_mcp_schema",
-    "generate_gemini_schema",
-    "generate_copilot_schema",
-    "get_supported_models",
-    # ========================================================================
     # PHASE 1: SDK INSTRUMENTATION & OPENTELEMETRY (v1.1.0)
     # ========================================================================
     # Auto-instrumentation
@@ -169,4 +137,11 @@ __all__ = [
     "setup_collector",
     "get_tracer_provider",
     "is_collector_configured",
+    # ========================================================================
+    # INTELLIGENCE & OUTCOME ROUTING (v1.2.0)
+    # ========================================================================
+    "KalibrIntelligence",
+    "get_policy",
+    "report_outcome",
+    "get_recommendation",
 ]

kalibr/cli/capsule_cmd.py

@@ -23,7 +23,7 @@ def capsule(
         None,
         "--api-url",
         "-u",
-        help="Kalibr API base URL (default: from env KALIBR_API_URL or http://localhost:8001)",
+        help="Kalibr API base URL (default: from env KALIBR_API_URL or https://api.kalibr.systems)",
         envvar="KALIBR_API_URL",
     ),
     output: Optional[Path] = typer.Option(
@@ -63,10 +63,10 @@ def capsule(
         kalibr capsule abc-123-def --export --output capsule.json
 
         # Specify custom API URL
-        kalibr capsule abc-123-def -u https://api.kalibr.io
+        kalibr capsule abc-123-def -u https://api.kalibr.systems
     """
     # Determine API base URL
-    base_url = api_url or "http://localhost:8001"
+    base_url = api_url or "https://api.kalibr.systems"
     base_url = base_url.rstrip("/")
 
     # Build endpoint URL

kalibr/cli/main.py

@@ -30,9 +30,9 @@ def version():
     from kalibr import __version__
 
     console.print(f"[bold]Kalibr SDK version:[/bold] {__version__}")
-    console.print("Enhanced multi-model AI integration framework")
-    console.print("Supports: GPT Actions, Claude MCP, Gemini Extensions, Copilot Plugins")
-    console.print("GitHub: https://github.com/devonakelley/kalibr-sdk")
+    console.print("LLM Observability & Execution Intelligence")
+    console.print("Auto-instrumentation for OpenAI, Anthropic, Google AI")
+    console.print("GitHub: https://github.com/kalibr-ai/kalibr-sdk-python")
 
 
 @app.command()

kalibr/cli/run.py

@@ -47,7 +47,7 @@ def run(
         kalibr run weather.py --runtime fly.io
 
         # Custom backend
-        kalibr run weather.py --backend-url https://api.kalibr.io
+        kalibr run weather.py --backend-url https://api.kalibr.systems
     """
     # Validate file exists
     agent_path = Path(file_path).resolve()
@@ -56,7 +56,7 @@ def run(
         raise typer.Exit(1)
 
     # Configure backend
-    backend = backend_url or os.getenv("KALIBR_BACKEND_URL", "http://localhost:8001")
+    backend = backend_url or os.getenv("KALIBR_BACKEND_URL", "https://api.kalibr.systems")
     api_key = os.getenv("KALIBR_API_KEY")
     if not api_key:
         console.print("[yellow]⚠️  KALIBR_API_KEY not set. Set it for trace authentication.[/yellow]")

kalibr/client.py

@@ -70,7 +70,7 @@ class KalibrClient:
 
         self.api_key = api_key or env_config.get("auth_token", "")
         self.endpoint = endpoint or env_config.get(
-            "api_endpoint", "http://localhost:8001/api/v1/traces"
+            "api_endpoint", "https://api.kalibr.systems/api/v1/traces"
         )
         self.tenant_id = tenant_id or env_config.get("tenant_id", "default")
         self.environment = environment or env_config.get("environment", "prod")

kalibr/intelligence.py

@@ -0,0 +1,317 @@
+"""Kalibr Intelligence Client - Query execution intelligence and report outcomes.
+
+This module enables the outcome-conditioned routing loop:
+1. Before executing: query get_policy() to get the best path for your goal
+2. After executing: call report_outcome() to teach Kalibr what worked
+
+Example:
+    from kalibr import get_policy, report_outcome
+
+    # Before executing - get best path
+    policy = get_policy(goal="book_meeting")
+    model = policy["recommended_model"]  # Use this model
+
+    # After executing - report what happened
+    report_outcome(
+        trace_id=trace_id,
+        goal="book_meeting",
+        success=True
+    )
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Optional
+
+import httpx
+
+# Default intelligence API endpoint
+DEFAULT_INTELLIGENCE_URL = "https://kalibr-intelligence.fly.dev"
+
+
+class KalibrIntelligence:
+    """Client for Kalibr Intelligence API.
+
+    Provides methods to query execution policies and report outcomes
+    for the outcome-conditioned routing loop.
+
+    Args:
+        api_key: Kalibr API key (or set KALIBR_API_KEY env var)
+        tenant_id: Tenant identifier (or set KALIBR_TENANT_ID env var)
+        base_url: Intelligence API base URL (or set KALIBR_INTELLIGENCE_URL env var)
+        timeout: Request timeout in seconds
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        tenant_id: str | None = None,
+        base_url: str | None = None,
+        timeout: float = 10.0,
+    ):
+        self.api_key = api_key or os.getenv("KALIBR_API_KEY", "")
+        self.tenant_id = tenant_id or os.getenv("KALIBR_TENANT_ID", "")
+        self.base_url = (
+            base_url
+            or os.getenv("KALIBR_INTELLIGENCE_URL", DEFAULT_INTELLIGENCE_URL)
+        ).rstrip("/")
+        self.timeout = timeout
+        self._client = httpx.Client(timeout=timeout)
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        json: dict | None = None,
+    ) -> httpx.Response:
+        """Make authenticated request to intelligence API."""
+        headers = {
+            "X-API-Key": self.api_key,
+            "X-Tenant-ID": self.tenant_id,
+            "Content-Type": "application/json",
+        }
+
+        url = f"{self.base_url}{path}"
+        response = self._client.request(method, url, json=json, headers=headers)
+        response.raise_for_status()
+        return response
+
+    def get_policy(
+        self,
+        goal: str,
+        task_type: str | None = None,
+        constraints: dict | None = None,
+        window_hours: int = 168,
+    ) -> dict[str, Any]:
+        """Get execution policy for a goal.
+
+        Returns the historically best-performing path for achieving
+        the specified goal, based on outcome data.
+
+        Args:
+            goal: The goal to optimize for (e.g., "book_meeting", "resolve_ticket")
+            task_type: Optional task type filter (e.g., "code", "summarize")
+            constraints: Optional constraints dict with keys:
+                - max_cost_usd: Maximum cost per request
+                - max_latency_ms: Maximum latency
+                - min_quality: Minimum quality score (0-1)
+                - min_confidence: Minimum statistical confidence (0-1)
+                - max_risk: Maximum risk score (0-1)
+            window_hours: Time window for pattern analysis (default 1 week)
+
+        Returns:
+            dict with:
+                - goal: The goal queried
+                - recommended_model: Best model for this goal
+                - recommended_provider: Provider for the recommended model
+                - outcome_success_rate: Historical success rate (0-1)
+                - outcome_sample_count: Number of outcomes in the data
+                - confidence: Statistical confidence in recommendation
+                - risk_score: Risk score (lower is better)
+                - reasoning: Human-readable explanation
+                - alternatives: List of alternative models
+
+        Raises:
+            httpx.HTTPStatusError: If the API returns an error
+
+        Example:
+            policy = intelligence.get_policy(goal="book_meeting")
+            print(f"Use {policy['recommended_model']} - {policy['outcome_success_rate']:.0%} success rate")
+        """
+        response = self._request(
+            "POST",
+            "/api/v1/intelligence/policy",
+            json={
+                "goal": goal,
+                "task_type": task_type,
+                "constraints": constraints,
+                "window_hours": window_hours,
+            },
+        )
+        return response.json()
+
+    def report_outcome(
+        self,
+        trace_id: str,
+        goal: str,
+        success: bool,
+        score: float | None = None,
+        failure_reason: str | None = None,
+        metadata: dict | None = None,
+    ) -> dict[str, Any]:
+        """Report execution outcome for a goal.
+
+        This is the feedback loop that teaches Kalibr what works.
+        Call this after your agent completes (or fails) a task.
+
+        Args:
+            trace_id: The trace ID from the execution
+            goal: The goal this execution was trying to achieve
+            success: Whether the goal was achieved
+            score: Optional quality score (0-1) for more granular feedback
+            failure_reason: Optional reason for failure (helps with debugging)
+            metadata: Optional additional context as a dict
+
+        Returns:
+            dict with:
+                - status: "accepted" if successful
+                - trace_id: The trace ID recorded
+                - goal: The goal recorded
+
+        Raises:
+            httpx.HTTPStatusError: If the API returns an error
+
+        Example:
+            # Success case
+            report_outcome(trace_id="abc123", goal="book_meeting", success=True)
+
+            # Failure case with reason
+            report_outcome(
+                trace_id="abc123",
+                goal="book_meeting",
+                success=False,
+                failure_reason="calendar_conflict"
+            )
+        """
+        response = self._request(
+            "POST",
+            "/api/v1/intelligence/report-outcome",
+            json={
+                "trace_id": trace_id,
+                "goal": goal,
+                "success": success,
+                "score": score,
+                "failure_reason": failure_reason,
+                "metadata": metadata,
+            },
+        )
+        return response.json()
+
+    def get_recommendation(
+        self,
+        task_type: str,
+        goal: str | None = None,
+        optimize_for: str = "balanced",
+        constraints: dict | None = None,
+        window_hours: int = 168,
+    ) -> dict[str, Any]:
+        """Get model recommendation for a task type.
+
+        This is the original recommendation endpoint. For goal-based
+        optimization, prefer get_policy() instead.
+
+        Args:
+            task_type: Type of task (e.g., "summarize", "code", "qa")
+            goal: Optional goal for outcome-based optimization
+            optimize_for: Optimization target - one of:
+                - "cost": Minimize cost
+                - "quality": Maximize output quality
+                - "latency": Minimize response time
+                - "balanced": Balance all factors (default)
+                - "cost_efficiency": Maximize quality-per-dollar
+                - "outcome": Optimize for goal success rate
+            constraints: Optional constraints dict
+            window_hours: Time window for pattern analysis
+
+        Returns:
+            dict with recommendation, alternatives, stats, reasoning
+        """
+        response = self._request(
+            "POST",
+            "/api/v1/intelligence/recommend",
+            json={
+                "task_type": task_type,
+                "goal": goal,
+                "optimize_for": optimize_for,
+                "constraints": constraints,
+                "window_hours": window_hours,
+            },
+        )
+        return response.json()
+
+    def close(self):
+        """Close the HTTP client."""
+        self._client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+
+# Module-level singleton for convenience functions
+_intelligence_client: KalibrIntelligence | None = None
+
+
+def _get_intelligence_client() -> KalibrIntelligence:
+    """Get or create the singleton intelligence client."""
+    global _intelligence_client
+    if _intelligence_client is None:
+        _intelligence_client = KalibrIntelligence()
+    return _intelligence_client
+
+
+def get_policy(goal: str, tenant_id: str | None = None, **kwargs) -> dict[str, Any]:
+    """Get execution policy for a goal.
+
+    Convenience function that uses the default intelligence client.
+    See KalibrIntelligence.get_policy for full documentation.
+
+    Args:
+        goal: The goal to optimize for
+        tenant_id: Optional tenant ID override (default: uses KALIBR_TENANT_ID env var)
+        **kwargs: Additional arguments (task_type, constraints, window_hours)
+
+    Returns:
+        Policy dict with recommended_model, outcome_success_rate, etc.
+
+    Example:
+        from kalibr import get_policy
+
+        policy = get_policy(goal="book_meeting")
+        model = policy["recommended_model"]
+    """
+    client = _get_intelligence_client()
+    if tenant_id:
+        # Create a new client with the specified tenant_id
+        client = KalibrIntelligence(tenant_id=tenant_id)
+    return client.get_policy(goal, **kwargs)
+
+
+def report_outcome(trace_id: str, goal: str, success: bool, tenant_id: str | None = None, **kwargs) -> dict[str, Any]:
+    """Report execution outcome for a goal.
+
+    Convenience function that uses the default intelligence client.
+    See KalibrIntelligence.report_outcome for full documentation.
+
+    Args:
+        trace_id: The trace ID from the execution
+        goal: The goal this execution was trying to achieve
+        success: Whether the goal was achieved
+        tenant_id: Optional tenant ID override (default: uses KALIBR_TENANT_ID env var)
+        **kwargs: Additional arguments (score, failure_reason, metadata)
+
+    Returns:
+        Response dict with status confirmation
+
+    Example:
+        from kalibr import report_outcome
+
+        report_outcome(trace_id="abc123", goal="book_meeting", success=True)
+    """
+    client = _get_intelligence_client()
+    if tenant_id:
+        # Create a new client with the specified tenant_id
+        client = KalibrIntelligence(tenant_id=tenant_id)
+    return client.report_outcome(trace_id, goal, success, **kwargs)
+
+
+def get_recommendation(task_type: str, **kwargs) -> dict[str, Any]:
+    """Get model recommendation for a task type.
+
+    Convenience function that uses the default intelligence client.
+    See KalibrIntelligence.get_recommendation for full documentation.
+    """
+    return _get_intelligence_client().get_recommendation(task_type, **kwargs)

kalibr/middleware/auto_tracer.py

@@ -54,7 +54,7 @@ class AutoTracerMiddleware(BaseHTTPMiddleware):
 
         # Collector config
         self.collector_url = collector_url or os.getenv(
-            "KALIBR_COLLECTOR_URL", "http://localhost:8001/api/ingest"
+            "KALIBR_COLLECTOR_URL", "https://api.kalibr.systems/api/ingest"
         )
         self.api_key = api_key or os.getenv("KALIBR_API_KEY", "")
         self.tenant_id = tenant_id or os.getenv("KALIBR_TENANT_ID", "default")

kalibr/simple_tracer.py

@@ -53,7 +53,7 @@ def send_event(payload: dict):
         print("[Kalibr SDK] ❌ requests library not available")
         return
 
-    url = os.getenv("KALIBR_COLLECTOR_URL", "http://localhost:8001/api/ingest")
+    url = os.getenv("KALIBR_COLLECTOR_URL", "https://api.kalibr.systems/api/ingest")
     api_key = os.getenv("KALIBR_API_KEY")
     if not api_key:
         print("[Kalibr SDK] ⚠️  KALIBR_API_KEY not set, traces will not be sent")
@@ -123,7 +123,7 @@ def trace(
             parent_span_id = kwargs.pop("parent_span_id", None)  # None or base62 string
 
             # Load environment config
-            tenant_id = os.getenv("KALIBR_TENANT_ID", "emergent")
+            tenant_id = os.getenv("KALIBR_TENANT_ID", "default")
             workflow_id = os.getenv("KALIBR_WORKFLOW_ID", "multi_agent_demo")
             sandbox_id = os.getenv("SANDBOX_ID", "vercel_vm_001")
             runtime_env = os.getenv("RUNTIME_ENV", "vercel_vm")

kalibr/utils.py

@@ -38,8 +38,8 @@ def load_config_from_env() -> Dict[str, str]:
         "workflow_id": os.getenv("KALIBR_WORKFLOW_ID", "default-workflow"),
         "sandbox_id": os.getenv("SANDBOX_ID", "local"),
         "runtime_env": os.getenv("RUNTIME_ENV", "local"),
-        "api_endpoint": os.getenv("KALIBR_API_ENDPOINT", "http://localhost:8001/api/v1/traces"),
-        "collector_url": os.getenv("KALIBR_COLLECTOR_URL", "http://localhost:8080/api/ingest"),
+        "api_endpoint": os.getenv("KALIBR_API_ENDPOINT", "https://api.kalibr.systems/api/v1/traces"),
+        "collector_url": os.getenv("KALIBR_COLLECTOR_URL", "https://api.kalibr.systems/api/ingest"),
     }
     return config