kalibr 1.2.7__tar.gz → 1.2.8__tar.gz

{kalibr-1.2.7 → kalibr-1.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: kalibr
-Version: 1.2.7
+Version: 1.2.8
 Summary: Adaptive routing for AI agents. Learns which models work best and routes automatically.
 Author-email: Kalibr Team <support@kalibr.systems>
 License: Apache-2.0
@@ -123,6 +123,63 @@ paths = [
 ]
 ```
 
+## Advanced Path Configuration
+
+### Routing Between Parameters
+
+Kalibr can route between different parameter configurations of the same model:
+```python
+from kalibr import Router
+
+router = Router(
+    goal="creative_writing",
+    paths=[
+        {"model": "gpt-4o", "params": {"temperature": 0.3}},
+        {"model": "gpt-4o", "params": {"temperature": 0.9}},
+        {"model": "claude-sonnet-4-20250514", "params": {"temperature": 0.7}}
+    ]
+)
+
+response = router.completion(messages=[...])
+router.report(success=True)
+```
+
+Each unique `(model, params)` combination is tracked separately. Kalibr learns which configuration works best for your specific goal.
+
+### Routing Between Tools
+```python
+router = Router(
+    goal="research_task",
+    paths=[
+        {"model": "gpt-4o", "tools": ["web_search"]},
+        {"model": "gpt-4o", "tools": ["code_interpreter"]},
+        {"model": "claude-sonnet-4-20250514"}
+    ]
+)
+```
+
+### When to Use get_policy() Instead of Router
+
+For most use cases, use `Router`. It handles provider dispatching and response conversion automatically.
+
+Use `get_policy()` for advanced scenarios:
+- Integrating with frameworks like LangChain that wrap LLM calls
+- Custom retry logic or provider-specific features
+- Building tools that need fine-grained control
+```python
+from kalibr import get_policy, report_outcome
+
+policy = get_policy(goal="summarize")
+model = policy["recommended_model"]
+
+# You call the provider yourself
+if model.startswith("gpt"):
+    client = OpenAI()
+    response = client.chat.completions.create(model=model, messages=[...])
+
+report_outcome(trace_id=trace_id, goal="summarize", success=True)
+```
+
 ## Outcome Reporting
 
 ### Automatic (with success_when)

{kalibr-1.2.7 → kalibr-1.2.8}/README.md

@@ -56,6 +56,63 @@ paths = [
 ]
 ```
 
+## Advanced Path Configuration
+
+### Routing Between Parameters
+
+Kalibr can route between different parameter configurations of the same model:
+```python
+from kalibr import Router
+
+router = Router(
+    goal="creative_writing",
+    paths=[
+        {"model": "gpt-4o", "params": {"temperature": 0.3}},
+        {"model": "gpt-4o", "params": {"temperature": 0.9}},
+        {"model": "claude-sonnet-4-20250514", "params": {"temperature": 0.7}}
+    ]
+)
+
+response = router.completion(messages=[...])
+router.report(success=True)
+```
+
+Each unique `(model, params)` combination is tracked separately. Kalibr learns which configuration works best for your specific goal.
+
+### Routing Between Tools
+```python
+router = Router(
+    goal="research_task",
+    paths=[
+        {"model": "gpt-4o", "tools": ["web_search"]},
+        {"model": "gpt-4o", "tools": ["code_interpreter"]},
+        {"model": "claude-sonnet-4-20250514"}
+    ]
+)
+```
+
+### When to Use get_policy() Instead of Router
+
+For most use cases, use `Router`. It handles provider dispatching and response conversion automatically.
+
+Use `get_policy()` for advanced scenarios:
+- Integrating with frameworks like LangChain that wrap LLM calls
+- Custom retry logic or provider-specific features
+- Building tools that need fine-grained control
+```python
+from kalibr import get_policy, report_outcome
+
+policy = get_policy(goal="summarize")
+model = policy["recommended_model"]
+
+# You call the provider yourself
+if model.startswith("gpt"):
+    client = OpenAI()
+    response = client.chat.completions.create(model=model, messages=[...])
+
+report_outcome(trace_id=trace_id, goal="summarize", success=True)
+```
+
 ## Outcome Reporting
 
 ### Automatic (with success_when)

{kalibr-1.2.7 → kalibr-1.2.8}/kalibr/collector.py

@@ -5,10 +5,13 @@ Configures OpenTelemetry tracer provider with multiple exporters:
 1. OTLP exporter for sending to OpenTelemetry collectors
 2. Kalibr HTTP exporter for sending to Kalibr backend
 3. File exporter for local JSONL fallback
+
+Thread-safe singleton pattern for collector setup.
 """
 
 import json
 import os
+import threading
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Optional
@@ -167,7 +170,6 @@ class KalibrHTTPSpanExporter(SpanExporter):
 
     def _convert_span(self, span) -> dict:
         """Convert OTel span to Kalibr event format"""
-        attrs = dict(span.attributes) if span.attributes else {}
 
         # Calculate duration from span times (nanoseconds to milliseconds)
         duration_ms = 0
@@ -236,6 +238,7 @@ class KalibrHTTPSpanExporter(SpanExporter):
 
 _tracer_provider: Optional[TracerProvider] = None
 _is_configured = False
+_collector_lock = threading.Lock()
 
 
 def setup_collector(
@@ -247,6 +250,8 @@ def setup_collector(
     """
     Setup OpenTelemetry collector with multiple exporters
 
+    Thread-safe: Uses double-checked locking to ensure single initialization.
+
     Args:
         service_name: Service name for the tracer provider
         otlp_endpoint: OTLP collector endpoint (e.g., "http://localhost:4317")
@@ -259,60 +264,67 @@ def setup_collector(
     """
     global _tracer_provider, _is_configured
 
+    # First check without lock (fast path)
     if _is_configured and _tracer_provider:
         return _tracer_provider
 
-    # Create resource with service name
-    resource = Resource(attributes={SERVICE_NAME: service_name})
-
-    # Create tracer provider
-    provider = TracerProvider(resource=resource)
-
-    # Add OTLP exporter if endpoint is configured
-    otlp_endpoint = otlp_endpoint or os.getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
-    if otlp_endpoint:
-        try:
-            otlp_exporter = OTLPSpanExporter(endpoint=otlp_endpoint)
-            provider.add_span_processor(BatchSpanProcessor(otlp_exporter))
-            print(f"✅ OTLP exporter configured: {otlp_endpoint}")
-        except Exception as e:
-            print(f"⚠️  Failed to configure OTLP exporter: {e}")
-
-    # Add Kalibr HTTP exporter if API key is configured
-    kalibr_api_key = os.getenv("KALIBR_API_KEY")
-    if kalibr_api_key:
-        try:
-            kalibr_exporter = KalibrHTTPSpanExporter()
-            provider.add_span_processor(BatchSpanProcessor(kalibr_exporter))
-            print(f"✅ Kalibr backend exporter configured: {kalibr_exporter.url}")
-        except Exception as e:
-            print(f"⚠️  Failed to configure Kalibr backend exporter: {e}")
-
-    # Add file exporter for local fallback
-    if file_export:
-        try:
-            file_exporter = FileSpanExporter("/tmp/kalibr_otel_spans.jsonl")
-            provider.add_span_processor(BatchSpanProcessor(file_exporter))
-            print("✅ File exporter configured: /tmp/kalibr_otel_spans.jsonl")
-        except Exception as e:
-            print(f"⚠️  Failed to configure file exporter: {e}")
-
-    # Add console exporter for debugging
-    if console_export:
-        try:
-            console_exporter = ConsoleSpanExporter()
-            provider.add_span_processor(BatchSpanProcessor(console_exporter))
-            print("✅ Console exporter configured")
-        except Exception as e:
-            print(f"⚠️  Failed to configure console exporter: {e}")
-
-    # Set as global tracer provider
-    trace.set_tracer_provider(provider)
-
-    _tracer_provider = provider
-    _is_configured = True
-
-    return provider
+    # Acquire lock for initialization
+    with _collector_lock:
+        # Double-check inside lock
+        if _is_configured and _tracer_provider:
+            return _tracer_provider
+
+        # Create resource with service name
+        resource = Resource(attributes={SERVICE_NAME: service_name})
+
+        # Create tracer provider
+        provider = TracerProvider(resource=resource)
+
+        # Add OTLP exporter if endpoint is configured
+        otlp_endpoint = otlp_endpoint or os.getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
+        if otlp_endpoint:
+            try:
+                otlp_exporter = OTLPSpanExporter(endpoint=otlp_endpoint)
+                provider.add_span_processor(BatchSpanProcessor(otlp_exporter))
+                print(f"✅ OTLP exporter configured: {otlp_endpoint}")
+            except Exception as e:
+                print(f"⚠️  Failed to configure OTLP exporter: {e}")
+
+        # Add Kalibr HTTP exporter if API key is configured
+        kalibr_api_key = os.getenv("KALIBR_API_KEY")
+        if kalibr_api_key:
+            try:
+                kalibr_exporter = KalibrHTTPSpanExporter()
+                provider.add_span_processor(BatchSpanProcessor(kalibr_exporter))
+                print(f"✅ Kalibr backend exporter configured: {kalibr_exporter.url}")
+            except Exception as e:
+                print(f"⚠️  Failed to configure Kalibr backend exporter: {e}")
+
+        # Add file exporter for local fallback
+        if file_export:
+            try:
+                file_exporter = FileSpanExporter("/tmp/kalibr_otel_spans.jsonl")
+                provider.add_span_processor(BatchSpanProcessor(file_exporter))
+                print("✅ File exporter configured: /tmp/kalibr_otel_spans.jsonl")
+            except Exception as e:
+                print(f"⚠️  Failed to configure file exporter: {e}")
+
+        # Add console exporter for debugging
+        if console_export:
+            try:
+                console_exporter = ConsoleSpanExporter()
+                provider.add_span_processor(BatchSpanProcessor(console_exporter))
+                print("✅ Console exporter configured")
+            except Exception as e:
+                print(f"⚠️  Failed to configure console exporter: {e}")
+
+        # Set as global tracer provider
+        trace.set_tracer_provider(provider)
+
+        _tracer_provider = provider
+        _is_configured = True
+
+        return provider
 
 
 def get_tracer_provider() -> Optional[TracerProvider]:
@@ -326,11 +338,15 @@ def is_configured() -> bool:
 
 
 def shutdown_collector():
-    """Shutdown the tracer provider and flush all spans"""
+    """Shutdown the tracer provider and flush all spans.
+
+    Thread-safe: Uses lock to protect shutdown operation.
+    """
     global _tracer_provider, _is_configured
 
-    if _tracer_provider:
-        _tracer_provider.shutdown()
-        _tracer_provider = None
-        _is_configured = False
-        print("✅ Tracer provider shutdown")
+    with _collector_lock:
+        if _tracer_provider:
+            _tracer_provider.shutdown()
+            _tracer_provider = None
+            _is_configured = False
+            print("✅ Tracer provider shutdown")

{kalibr-1.2.7 → kalibr-1.2.8}/kalibr/cost_adapter.py

@@ -10,6 +10,8 @@ Supports:
 - OpenAI (GPT-4, GPT-3.5, etc.)
 - Anthropic (Claude models)
 - Extensible for other vendors
+
+Note: All adapters now use centralized pricing from kalibr.pricing module.
 """
 
 import json
@@ -17,6 +19,8 @@ import os
 from abc import ABC, abstractmethod
 from typing import Dict, Optional
 
+from kalibr.pricing import get_pricing, normalize_model_name
+
 
 class BaseCostAdapter(ABC):
     """Base class for vendor cost adapters."""
@@ -42,43 +46,27 @@ class BaseCostAdapter(ABC):
 
 
 class OpenAICostAdapter(BaseCostAdapter):
-    """Cost adapter for OpenAI models."""
-
-    # OpenAI pricing as of 2025 (per 1M tokens)
-    # Source: https://openai.com/pricing
-    PRICING = {
-        "gpt-4": {
-            "input": 30.00,  # $30/1M input tokens
-            "output": 60.00,  # $60/1M output tokens
-        },
-        "gpt-4-turbo": {
-            "input": 10.00,
-            "output": 30.00,
-        },
-        "gpt-4o": {
-            "input": 2.50,
-            "output": 10.00,
-        },
-        "gpt-3.5-turbo": {
-            "input": 0.50,
-            "output": 1.50,
-        },
-        "gpt-4o-mini": {
-            "input": 0.15,
-            "output": 0.60,
-        },
-    }
+    """Cost adapter for OpenAI models.
+    
+    Uses centralized pricing from kalibr.pricing module.
+    """
 
     def get_vendor_name(self) -> str:
         return "openai"
 
     def compute_cost(self, model_name: str, tokens_in: int, tokens_out: int) -> float:
-        """Compute cost for OpenAI models."""
-        # Normalize model name
-        model_key = self._normalize_model_name(model_name)
-
-        # Get pricing (default to gpt-4 if unknown)
-        pricing = self.PRICING.get(model_key, self.PRICING["gpt-4"])
+        """Compute cost for OpenAI models.
+        
+        Args:
+            model_name: Model identifier (e.g., "gpt-4o", "gpt-4")
+            tokens_in: Input token count
+            tokens_out: Output token count
+            
+        Returns:
+            Cost in USD (rounded to 6 decimal places)
+        """
+        # Get pricing from centralized module
+        pricing, _ = get_pricing("openai", model_name)
 
         # Calculate cost (pricing is per 1M tokens)
         input_cost = (tokens_in / 1_000_000) * pricing["input"]
@@ -86,64 +74,29 @@ class OpenAICostAdapter(BaseCostAdapter):
 
         return round(input_cost + output_cost, 6)
 
-    def _normalize_model_name(self, model_name: str) -> str:
-        """Normalize model name to match pricing table."""
-        model_lower = model_name.lower()
-
-        # Direct matches
-        if model_lower in self.PRICING:
-            return model_lower
-
-        # Fuzzy matches
-        if "gpt-4o-mini" in model_lower:
-            return "gpt-4o-mini"
-        elif "gpt-4o" in model_lower:
-            return "gpt-4o"
-        elif "gpt-4-turbo" in model_lower:
-            return "gpt-4-turbo"
-        elif "gpt-4" in model_lower:
-            return "gpt-4"
-        elif "gpt-3.5" in model_lower:
-            return "gpt-3.5-turbo"
-
-        # Default to gpt-4 for unknown models
-        return "gpt-4"
-
 
 class AnthropicCostAdapter(BaseCostAdapter):
-    """Cost adapter for Anthropic Claude models."""
-
-    # Anthropic pricing as of 2025 (per 1M tokens)
-    # Source: https://www.anthropic.com/pricing
-    PRICING = {
-        "claude-3-opus": {
-            "input": 15.00,
-            "output": 75.00,
-        },
-        "claude-3-sonnet": {
-            "input": 3.00,
-            "output": 15.00,
-        },
-        "claude-3-haiku": {
-            "input": 0.25,
-            "output": 1.25,
-        },
-        "claude-3.5-sonnet": {
-            "input": 3.00,
-            "output": 15.00,
-        },
-    }
+    """Cost adapter for Anthropic Claude models.
+    
+    Uses centralized pricing from kalibr.pricing module.
+    """
 
     def get_vendor_name(self) -> str:
         return "anthropic"
 
     def compute_cost(self, model_name: str, tokens_in: int, tokens_out: int) -> float:
-        """Compute cost for Anthropic models."""
-        # Normalize model name
-        model_key = self._normalize_model_name(model_name)
-
-        # Get pricing (default to opus if unknown)
-        pricing = self.PRICING.get(model_key, self.PRICING["claude-3-opus"])
+        """Compute cost for Anthropic models.
+        
+        Args:
+            model_name: Model identifier (e.g., "claude-3-opus", "claude-3-5-sonnet")
+            tokens_in: Input token count
+            tokens_out: Output token count
+            
+        Returns:
+            Cost in USD (rounded to 6 decimal places)
+        """
+        # Get pricing from centralized module
+        pricing, _ = get_pricing("anthropic", model_name)
 
         # Calculate cost (pricing is per 1M tokens)
         input_cost = (tokens_in / 1_000_000) * pricing["input"]
@@ -151,27 +104,6 @@ class AnthropicCostAdapter(BaseCostAdapter):
 
         return round(input_cost + output_cost, 6)
 
-    def _normalize_model_name(self, model_name: str) -> str:
-        """Normalize model name to match pricing table."""
-        model_lower = model_name.lower()
-
-        # Direct matches
-        if model_lower in self.PRICING:
-            return model_lower
-
-        # Fuzzy matches
-        if "claude-3.5-sonnet" in model_lower or "claude-3-5-sonnet" in model_lower:
-            return "claude-3.5-sonnet"
-        elif "claude-3-opus" in model_lower:
-            return "claude-3-opus"
-        elif "claude-3-sonnet" in model_lower:
-            return "claude-3-sonnet"
-        elif "claude-3-haiku" in model_lower:
-            return "claude-3-haiku"
-
-        # Default to opus for unknown models
-        return "claude-3-opus"
-
 
 class CostAdapterFactory:
     """Factory to get appropriate cost adapter for a vendor."""

{kalibr-1.2.7 → kalibr-1.2.8}/kalibr/instrumentation/anthropic_instr.py

@@ -3,8 +3,11 @@ Anthropic SDK Instrumentation
 
 Monkey-patches the Anthropic SDK to automatically emit OpenTelemetry spans
 for all message API calls.
+
+Thread-safe singleton pattern using double-checked locking.
 """
 
+import threading
 import time
 from functools import wraps
 from typing import Any, Dict, Optional
@@ -15,50 +18,34 @@ from .base import BaseCostAdapter, BaseInstrumentation
 
 
 class AnthropicCostAdapter(BaseCostAdapter):
-    """Cost calculation adapter for Anthropic models"""
-
-    # Pricing per 1K tokens (USD) - Updated November 2025
-    PRICING = {
-        # Claude 4 models
-        "claude-4-opus": {"input": 0.015, "output": 0.075},
-        "claude-4-sonnet": {"input": 0.003, "output": 0.015},
-        # Claude 3 models (Sonnet 4 is actually Claude 3.7)
-        "claude-sonnet-4": {"input": 0.003, "output": 0.015},
-        "claude-3-7-sonnet": {"input": 0.003, "output": 0.015},
-        "claude-3-5-sonnet": {"input": 0.003, "output": 0.015},
-        "claude-3-opus": {"input": 0.015, "output": 0.075},
-        "claude-3-sonnet": {"input": 0.003, "output": 0.015},
-        "claude-3-haiku": {"input": 0.00025, "output": 0.00125},
-        # Claude 2 models
-        "claude-2.1": {"input": 0.008, "output": 0.024},
-        "claude-2.0": {"input": 0.008, "output": 0.024},
-        "claude-instant-1.2": {"input": 0.0008, "output": 0.0024},
-    }
-
-    def calculate_cost(self, model: str, usage: Dict[str, int]) -> float:
-        """Calculate cost in USD for an Anthropic API call"""
-        # Normalize model name
-        base_model = model.lower()
+    """Cost calculation adapter for Anthropic models.
+    
+    Uses centralized pricing from kalibr.pricing module.
+    """
 
-        # Try exact match first
-        pricing = self.get_pricing(base_model)
+    def get_vendor_name(self) -> str:
+        """Return vendor name for Anthropic."""
+        return "anthropic"
 
-        # Try fuzzy matching for versioned models
-        if not pricing:
-            for known_model in self.PRICING.keys():
-                if known_model in base_model or base_model in known_model:
-                    pricing = self.PRICING[known_model]
-                    break
-
-        if not pricing:
-            # Default to Claude 3 Sonnet pricing if unknown
-            pricing = {"input": 0.003, "output": 0.015}
+    def calculate_cost(self, model: str, usage: Dict[str, int]) -> float:
+        """Calculate cost in USD for an Anthropic API call.
+        
+        Args:
+            model: Model identifier (e.g., "claude-3-opus", "claude-3-5-sonnet-20240620")
+            usage: Token usage dict with input_tokens and output_tokens
+            
+        Returns:
+            Cost in USD (rounded to 6 decimal places)
+        """
+        # Get pricing from centralized module (handles normalization)
+        pricing = self.get_pricing_for_model(model)
 
         input_tokens = usage.get("input_tokens", 0)
         output_tokens = usage.get("output_tokens", 0)
 
-        input_cost = (input_tokens / 1000) * pricing["input"]
-        output_cost = (output_tokens / 1000) * pricing["output"]
+        # Calculate cost (pricing is per 1M tokens)
+        input_cost = (input_tokens / 1_000_000) * pricing["input"]
+        output_cost = (output_tokens / 1_000_000) * pricing["output"]
 
         return round(input_cost + output_cost, 6)
 
@@ -262,13 +249,20 @@ class AnthropicInstrumentation(BaseInstrumentation):
 
 # Singleton instance
 _anthropic_instrumentation = None
+_anthropic_lock = threading.Lock()
 
 
 def get_instrumentation() -> AnthropicInstrumentation:
-    """Get or create the Anthropic instrumentation singleton"""
+    """Get or create the Anthropic instrumentation singleton.
+    
+    Thread-safe singleton pattern using double-checked locking.
+    """
     global _anthropic_instrumentation
     if _anthropic_instrumentation is None:
-        _anthropic_instrumentation = AnthropicInstrumentation()
+        with _anthropic_lock:
+            # Double-check inside lock to prevent race condition
+            if _anthropic_instrumentation is None:
+                _anthropic_instrumentation = AnthropicInstrumentation()
     return _anthropic_instrumentation