kalibr 1.2.2__py3-none-any.whl → 1.2.4__py3-none-any.whl

kalibr/__init__.py

@@ -92,6 +92,7 @@ from .intelligence import (
     register_path,
     decide,
 )
+from .router import Router
 
 if os.getenv("KALIBR_AUTO_INSTRUMENT", "true").lower() == "true":
     # Setup OpenTelemetry collector
@@ -163,4 +164,5 @@ __all__ = [
     "get_recommendation",
     "register_path",
     "decide",
+    "Router",
 ]

kalibr/router.py

@@ -0,0 +1,370 @@
+"""
+Kalibr Router - Intelligent model routing with outcome learning.
+"""
+
+import os
+import logging
+from typing import Any, Callable, Dict, List, Optional, Union
+
+logger = logging.getLogger(__name__)
+
+# Type for paths - either string or dict
+PathSpec = Union[str, Dict[str, Any]]
+
+
+class Router:
+    """
+    Routes LLM requests to the best model based on learned outcomes.
+
+    Example:
+        router = Router(
+            goal="summarize",
+            paths=["gpt-4o", "claude-3-sonnet"],
+            success_when=lambda out: len(out) > 100
+        )
+        response = router.completion(messages=[...])
+    """
+
+    def __init__(
+        self,
+        goal: str,
+        paths: Optional[List[PathSpec]] = None,
+        success_when: Optional[Callable[[str], bool]] = None,
+        exploration_rate: Optional[float] = None,
+        auto_register: bool = True,
+    ):
+        """
+        Initialize router.
+
+        Args:
+            goal: Name of the goal (e.g., "book_meeting", "summarize")
+            paths: List of models or path configs. Examples:
+                   ["gpt-4o", "claude-3-sonnet"]
+                   [{"model": "gpt-4o", "tools": ["search"]}]
+            success_when: Optional function to auto-evaluate success from output
+            exploration_rate: Override exploration rate (0.0-1.0)
+            auto_register: If True, register paths on init
+        """
+        self.goal = goal
+        self.success_when = success_when
+        self.exploration_rate = exploration_rate
+        self._last_trace_id: Optional[str] = None
+        self._last_decision: Optional[dict] = None
+        self._outcome_reported = False
+
+        # Normalize paths to list of dicts
+        self._paths = self._normalize_paths(paths or ["gpt-4o"])
+
+        # Register paths if requested
+        if auto_register:
+            self._register_paths()
+
+    def _normalize_paths(self, paths: List[PathSpec]) -> List[Dict[str, Any]]:
+        """Convert paths to consistent format."""
+        normalized = []
+        for p in paths:
+            if isinstance(p, str):
+                normalized.append({"model": p, "tools": None, "params": None})
+            elif isinstance(p, dict):
+                normalized.append({
+                    "model": p.get("model") or p.get("model_id"),
+                    "tools": p.get("tools") or p.get("tool_id"),
+                    "params": p.get("params"),
+                })
+            else:
+                raise ValueError(f"Invalid path spec: {p}")
+        return normalized
+
+    def _register_paths(self):
+        """Register paths with intelligence service."""
+        from kalibr.intelligence import register_path
+
+        for path in self._paths:
+            try:
+                register_path(
+                    goal=self.goal,
+                    model_id=path["model"],
+                    tool_id=path["tools"][0] if isinstance(path["tools"], list) and path["tools"] else path["tools"],
+                    params=path["params"],
+                )
+            except Exception as e:
+                # Log but don't fail - path might already exist
+                logger.debug(f"Path registration note: {e}")
+
+    def completion(
+        self,
+        messages: List[Dict[str, str]],
+        force_model: Optional[str] = None,
+        **kwargs
+    ) -> Any:
+        """
+        Make a completion request with intelligent routing.
+
+        Args:
+            messages: OpenAI-format messages
+            force_model: Override routing and use this model
+            **kwargs: Additional args passed to provider
+
+        Returns:
+            OpenAI-compatible ChatCompletion response
+        """
+        from kalibr.intelligence import decide
+        from kalibr.context import get_trace_id
+
+        # Reset state for new request
+        self._outcome_reported = False
+
+        # Get routing decision (or use forced model)
+        if force_model:
+            model_id = force_model
+            tool_id = None
+            params = {}
+            self._last_decision = {"model_id": model_id, "forced": True}
+        else:
+            try:
+                decision = decide(goal=self.goal)
+                model_id = decision.get("model_id") or self._paths[0]["model"]
+                tool_id = decision.get("tool_id")
+                params = decision.get("params") or {}
+                self._last_decision = decision
+            except Exception as e:
+                # Fallback to first path if routing fails
+                logger.warning(f"Routing failed, using fallback: {e}")
+                model_id = self._paths[0]["model"]
+                tool_id = self._paths[0].get("tools")
+                params = self._paths[0].get("params") or {}
+                self._last_decision = {"model_id": model_id, "fallback": True, "error": str(e)}
+
+        # Dispatch to provider
+        try:
+            response = self._dispatch(model_id, messages, tool_id, **{**params, **kwargs})
+            self._last_trace_id = get_trace_id()
+
+            # Auto-report if success_when provided
+            if self.success_when and not self._outcome_reported:
+                try:
+                    output = response.choices[0].message.content or ""
+                    success = self.success_when(output)
+                    self.report(success=success)
+                except Exception as e:
+                    logger.warning(f"Auto-outcome evaluation failed: {e}")
+
+            return response
+
+        except Exception as e:
+            # Auto-report failure
+            self._last_trace_id = get_trace_id()
+            if not self._outcome_reported:
+                try:
+                    self.report(success=False, reason=f"provider_error: {type(e).__name__}")
+                except:
+                    pass
+            raise
+
+    def report(
+        self,
+        success: bool,
+        reason: Optional[str] = None,
+        score: Optional[float] = None,
+    ):
+        """
+        Report outcome for the last completion.
+
+        Args:
+            success: Whether the task succeeded
+            reason: Optional failure reason
+            score: Optional quality score (0.0-1.0)
+        """
+        if self._outcome_reported:
+            logger.warning("Outcome already reported for this request")
+            return
+
+        from kalibr.intelligence import report_outcome
+        from kalibr.context import get_trace_id
+
+        trace_id = self._last_trace_id or get_trace_id()
+        if not trace_id:
+            logger.warning("No trace_id available for outcome reporting")
+            return
+
+        try:
+            report_outcome(
+                trace_id=trace_id,
+                goal=self.goal,
+                success=success,
+                score=score,
+                failure_reason=reason,
+            )
+            self._outcome_reported = True
+        except Exception as e:
+            logger.warning(f"Failed to report outcome: {e}")
+
+    def add_path(
+        self,
+        model: str,
+        tools: Optional[List[str]] = None,
+        params: Optional[Dict] = None,
+    ):
+        """Add a new path dynamically."""
+        from kalibr.intelligence import register_path
+
+        path = {"model": model, "tools": tools, "params": params}
+        self._paths.append(path)
+
+        register_path(
+            goal=self.goal,
+            model_id=model,
+            tool_id=tools[0] if tools else None,
+            params=params,
+        )
+
+    def _dispatch(
+        self,
+        model_id: str,
+        messages: List[Dict],
+        tools: Optional[Any] = None,
+        **kwargs
+    ) -> Any:
+        """Dispatch to the appropriate provider."""
+        if model_id.startswith(("gpt-", "o1-", "o3-")):
+            return self._call_openai(model_id, messages, tools, **kwargs)
+        elif model_id.startswith("claude-"):
+            return self._call_anthropic(model_id, messages, tools, **kwargs)
+        elif model_id.startswith(("gemini-", "models/gemini")):
+            return self._call_google(model_id, messages, tools, **kwargs)
+        else:
+            # Default to OpenAI-compatible
+            logger.info(f"Unknown model prefix '{model_id}', trying OpenAI")
+            return self._call_openai(model_id, messages, tools, **kwargs)
+
+    def _call_openai(self, model: str, messages: List[Dict], tools: Any, **kwargs) -> Any:
+        """Call OpenAI API."""
+        try:
+            from openai import OpenAI
+        except ImportError:
+            raise ImportError("Install 'openai' package: pip install openai")
+
+        client = OpenAI()
+
+        call_kwargs = {"model": model, "messages": messages, **kwargs}
+        if tools:
+            call_kwargs["tools"] = tools
+
+        return client.chat.completions.create(**call_kwargs)
+
+    def _call_anthropic(self, model: str, messages: List[Dict], tools: Any, **kwargs) -> Any:
+        """Call Anthropic API and convert response to OpenAI format."""
+        try:
+            from anthropic import Anthropic
+        except ImportError:
+            raise ImportError("Install 'anthropic' package: pip install anthropic")
+
+        client = Anthropic()
+
+        # Convert messages (handle system message)
+        system = None
+        anthropic_messages = []
+        for m in messages:
+            if m["role"] == "system":
+                system = m["content"]
+            else:
+                anthropic_messages.append({"role": m["role"], "content": m["content"]})
+
+        call_kwargs = {"model": model, "messages": anthropic_messages, "max_tokens": kwargs.pop("max_tokens", 4096)}
+        if system:
+            call_kwargs["system"] = system
+        if tools:
+            call_kwargs["tools"] = tools
+        call_kwargs.update(kwargs)
+
+        response = client.messages.create(**call_kwargs)
+
+        # Convert to OpenAI format
+        return self._anthropic_to_openai_response(response, model)
+
+    def _call_google(self, model: str, messages: List[Dict], tools: Any, **kwargs) -> Any:
+        """Call Google API and convert response to OpenAI format."""
+        try:
+            import google.generativeai as genai
+        except ImportError:
+            raise ImportError("Install 'google-generativeai' package: pip install google-generativeai")
+
+        # Configure if API key available
+        api_key = os.environ.get("GOOGLE_API_KEY")
+        if api_key:
+            genai.configure(api_key=api_key)
+
+        # Convert messages to Google format
+        model_name = model.replace("models/", "") if model.startswith("models/") else model
+        gmodel = genai.GenerativeModel(model_name)
+
+        # Simple conversion - concatenate messages
+        prompt = "\n".join([f"{m['role']}: {m['content']}" for m in messages])
+
+        response = gmodel.generate_content(prompt)
+
+        # Convert to OpenAI format
+        return self._google_to_openai_response(response, model)
+
+    def _anthropic_to_openai_response(self, response: Any, model: str) -> Any:
+        """Convert Anthropic response to OpenAI format."""
+        from types import SimpleNamespace
+
+        content = ""
+        if response.content:
+            content = response.content[0].text if hasattr(response.content[0], "text") else str(response.content[0])
+
+        return SimpleNamespace(
+            id=response.id,
+            model=model,
+            choices=[
+                SimpleNamespace(
+                    index=0,
+                    message=SimpleNamespace(
+                        role="assistant",
+                        content=content,
+                    ),
+                    finish_reason=response.stop_reason,
+                )
+            ],
+            usage=SimpleNamespace(
+                prompt_tokens=response.usage.input_tokens,
+                completion_tokens=response.usage.output_tokens,
+                total_tokens=response.usage.input_tokens + response.usage.output_tokens,
+            ),
+        )
+
+    def _google_to_openai_response(self, response: Any, model: str) -> Any:
+        """Convert Google response to OpenAI format."""
+        from types import SimpleNamespace
+        import uuid
+
+        content = response.text if hasattr(response, "text") else str(response)
+
+        return SimpleNamespace(
+            id=f"google-{uuid.uuid4().hex[:8]}",
+            model=model,
+            choices=[
+                SimpleNamespace(
+                    index=0,
+                    message=SimpleNamespace(
+                        role="assistant",
+                        content=content,
+                    ),
+                    finish_reason="stop",
+                )
+            ],
+            usage=SimpleNamespace(
+                prompt_tokens=getattr(response, "usage_metadata", {}).get("prompt_token_count", 0),
+                completion_tokens=getattr(response, "usage_metadata", {}).get("candidates_token_count", 0),
+                total_tokens=getattr(response, "usage_metadata", {}).get("total_token_count", 0),
+            ),
+        )
+
+    def as_langchain(self):
+        """Return a LangChain-compatible chat model."""
+        try:
+            from kalibr_langchain.chat_model import KalibrChatModel
+            return KalibrChatModel(router=self)
+        except ImportError:
+            raise ImportError("Install 'kalibr-langchain' package for LangChain integration")

kalibr-1.2.4.dist-info/METADATA

@@ -0,0 +1,233 @@
+Metadata-Version: 2.2
+Name: kalibr
+Version: 1.2.4
+Summary: Unified LLM Observability & Multi-Model AI Integration Framework - Deploy to GPT, Claude, Gemini, Copilot with full telemetry.
+Author-email: Kalibr Team <support@kalibr.systems>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/kalibr-ai/kalibr-sdk-python
+Project-URL: Documentation, https://kalibr.systems/docs
+Project-URL: Repository, https://github.com/kalibr-ai/kalibr-sdk-python
+Project-URL: Issues, https://github.com/kalibr-ai/kalibr-sdk-python/issues
+Keywords: ai,mcp,gpt,claude,gemini,copilot,openai,anthropic,google,microsoft,observability,telemetry,tracing,llm,schema-generation,api,multi-model,langchain,crewai
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: tiktoken>=0.8.0
+Requires-Dist: fastapi>=0.110.1
+Requires-Dist: uvicorn>=0.25.0
+Requires-Dist: pydantic>=2.6.4
+Requires-Dist: typer>=0.9.0
+Requires-Dist: python-multipart>=0.0.9
+Requires-Dist: rich>=10.0.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: opentelemetry-api>=1.20.0
+Requires-Dist: opentelemetry-sdk>=1.20.0
+Requires-Dist: opentelemetry-exporter-otlp>=1.20.0
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.1.0; extra == "langchain"
+Provides-Extra: langchain-openai
+Requires-Dist: langchain-core>=0.1.0; extra == "langchain-openai"
+Requires-Dist: langchain-openai>=0.1.0; extra == "langchain-openai"
+Provides-Extra: langchain-anthropic
+Requires-Dist: langchain-core>=0.1.0; extra == "langchain-anthropic"
+Requires-Dist: langchain-anthropic>=0.1.0; extra == "langchain-anthropic"
+Provides-Extra: langchain-google
+Requires-Dist: langchain-core>=0.1.0; extra == "langchain-google"
+Requires-Dist: langchain-google-genai>=0.0.10; extra == "langchain-google"
+Provides-Extra: langchain-all
+Requires-Dist: langchain-core>=0.1.0; extra == "langchain-all"
+Requires-Dist: langchain-openai>=0.1.0; extra == "langchain-all"
+Requires-Dist: langchain-anthropic>=0.1.0; extra == "langchain-all"
+Requires-Dist: langchain-google-genai>=0.0.10; extra == "langchain-all"
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.28.0; extra == "crewai"
+Provides-Extra: openai-agents
+Requires-Dist: openai-agents>=0.0.3; extra == "openai-agents"
+Provides-Extra: integrations
+Requires-Dist: langchain-core>=0.1.0; extra == "integrations"
+Requires-Dist: crewai>=0.28.0; extra == "integrations"
+Requires-Dist: openai-agents>=0.0.3; extra == "integrations"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+
+# Kalibr SDK
+
+**Intelligent routing for AI agents.** Kalibr picks the best model for each request, learns from outcomes, and shifts traffic to what works.
+
+## Installation
+```bash
+pip install kalibr
+```
+```bash
+export KALIBR_API_KEY=kal_xxx  # Get from dashboard.kalibr.dev
+```
+
+## Quick Start
+```python
+from kalibr import Router
+
+router = Router(
+    goal="book_meeting",
+    paths=["gpt-4o", "claude-3-sonnet", "gpt-4o-mini"],
+    success_when=lambda output: "confirmed" in output.lower()
+)
+
+response = router.completion(
+    messages=[{"role": "user", "content": "Book a meeting with John tomorrow"}]
+)
+
+print(response.choices[0].message.content)
+```
+
+That's it. Kalibr handles:
+- ✅ Picking the best model (Thompson Sampling)
+- ✅ Making the API call
+- ✅ Checking success
+- ✅ Learning for next time
+- ✅ Tracing everything
+
+## How It Works
+
+1. **Define a goal** - What is your agent trying to do?
+2. **Register paths** - Which models/tools can achieve it?
+3. **Report outcomes** - Did it work?
+4. **Kalibr routes** - Traffic shifts to winners
+
+## Paths
+
+A path is a model + optional tools + optional params:
+```python
+# Simple: just models
+paths = ["gpt-4o", "claude-3-sonnet"]
+
+# With tools
+paths = [
+    {"model": "gpt-4o", "tools": ["web_search"]},
+    {"model": "claude-3-sonnet", "tools": ["web_search", "browser"]},
+]
+
+# With params
+paths = [
+    {"model": "gpt-4o", "params": {"temperature": 0.7}},
+    {"model": "gpt-4o", "params": {"temperature": 0.2}},
+]
+```
+
+## Success Criteria
+
+### Auto-detect from output
+```python
+router = Router(
+    goal="summarize",
+    paths=["gpt-4o", "claude-3-sonnet"],
+    success_when=lambda output: len(output) > 100
+)
+```
+
+### Manual reporting
+```python
+router = Router(goal="book_meeting", paths=["gpt-4o", "claude-3-sonnet"])
+
+response = router.completion(messages=[...])
+
+# Your verification logic
+meeting_created = check_calendar_api()
+
+router.report(success=meeting_created)
+```
+
+## Framework Integration
+
+### LangChain
+```python
+from kalibr import Router
+
+router = Router(goal="summarize", paths=["gpt-4o", "claude-3-sonnet"])
+llm = router.as_langchain()
+
+chain = prompt | llm | parser
+result = chain.invoke({"text": "..."})
+```
+
+### CrewAI
+```python
+from kalibr import Router
+
+router = Router(goal="research", paths=["gpt-4o", "claude-3-sonnet"])
+
+agent = Agent(
+    role="Researcher",
+    llm=router.as_langchain(),
+    ...
+)
+```
+
+## Observability (Included)
+
+Every call is automatically traced:
+
+- Token counts and costs
+- Latency (p50, p95, p99)
+- Tool usage
+- Errors with stack traces
+
+View in the [dashboard](https://dashboard.kalibr.dev) or use callback handlers directly:
+```python
+from kalibr_langchain import KalibrCallbackHandler
+
+handler = KalibrCallbackHandler()
+chain.invoke({"input": "..."}, config={"callbacks": [handler]})
+```
+
+## Pricing
+
+| Tier | Routing Decisions | Price |
+|------|-------------------|-------|
+| Free | 1,000/month | $0 |
+| Pro | 50,000/month | $49/month |
+| Enterprise | Unlimited | Custom |
+
+## API Reference
+
+### Router
+```python
+Router(
+    goal: str,                    # Required: name of the goal
+    paths: List[str | dict],      # Models/tools to route between
+    success_when: Callable,       # Optional: auto-evaluate success
+    exploration_rate: float,      # Optional: 0.0-1.0, default 0.1
+)
+```
+
+### Methods
+```python
+router.completion(messages, **kwargs)  # Make routed request
+router.report(success, reason=None)    # Report outcome manually
+router.add_path(model, tools=None)     # Add path dynamically
+router.as_langchain()                  # Get LangChain-compatible LLM
+```
+
+## Links
+
+- [Documentation](https://docs.kalibr.dev)
+- [Dashboard](https://dashboard.kalibr.dev)
+- [GitHub](https://github.com/kalibr-ai/kalibr-sdk-python)
+
+## License
+
+MIT

{kalibr-1.2.2.dist-info → kalibr-1.2.4.dist-info}/RECORD

@@ -1,4 +1,4 @@
-kalibr/__init__.py,sha256=N0FRcMM5Rq845MPDjogsY1iRZu7K7NoUHAGqW8-JQDQ,5148
+kalibr/__init__.py,sha256=_Aq0ZfsOGbLC-GMB43br5CPprmjwLfmeBZuuVHUOQOY,5189
 kalibr/__main__.py,sha256=jO96I4pqinwHg7ONRvNVKbySBh5pSIhOAiNrgSQrNlY,110
 kalibr/capsule_middleware.py,sha256=pXG_wORgCqo3wHjtkn_zY4doLyiDmTwJtB7XiZNnbPk,3163
 kalibr/client.py,sha256=6D1paakE6zgWJStaow3ak9t0R8afodQhSSpUO3WTs_8,9732
@@ -11,6 +11,7 @@ kalibr/kalibr.py,sha256=cNXC3W_TX5SvGsy1lRopkwFqsHOpyd1kkVjEMOz1Yr4,6084
 kalibr/kalibr_app.py,sha256=ItZwEh0FZPx9_BE-zPQajC2yxI2y9IHYwJD0k9tbHvY,2773
 kalibr/models.py,sha256=HwD_-iysZMSnCzMQYO1Qcf0aeXySupY7yJeBwl_dLS0,1024
 kalibr/redaction.py,sha256=XibxX4Lv1Ci0opE6Tb5ZI2GLbO0a8E9U66MAg60llnc,1139
+kalibr/router.py,sha256=Z_LYvRxfLK5bQD-VUc1arqfAoC_CqOwJR8yoz_sGmvY,13234
 kalibr/schemas.py,sha256=XLZNLkXca6jbj9AF6gDIyGVnIcr1SVOsNYaKvW-wbgE,3669
 kalibr/simple_tracer.py,sha256=VAhqxGhCMBz9rVFXfpJtRmt6SrM_cpUBKE5ygP9PC9Y,9779
 kalibr/tokens.py,sha256=istjgaxi9S4dMddjuGtoQaTnZYcWLCqdnxRjV86yNXA,1297
@@ -35,15 +36,16 @@ kalibr/middleware/__init__.py,sha256=qyDUn_irAX67MS-IkuDVxg4RmFnJHDf_BfIT3qfGoBI
 kalibr/middleware/auto_tracer.py,sha256=ZBSBM0O3a6rwVzfik1n5NUmQDah8_iaf86rU64aPYT4,13037
 kalibr_crewai/__init__.py,sha256=b0HFTiE80eArtSMBOIEKu1JM6KU0tCjEylKCVVVF29Q,1796
 kalibr_crewai/callbacks.py,sha256=_d1M4J-6XfKqrVIxnOgOQu57jpFKVv-VIsmPV0HNgZ4,20419
-kalibr_crewai/instrumentor.py,sha256=x26v0RcriImkPiC8KB1Hmez1XOYLcDa9o-g35BMu5Ek,24420
-kalibr_langchain/__init__.py,sha256=O4XYVyhLp1v-Y1kGZw3zD-tUK9wp0UX8Jt6oN0QTHN4,1373
+kalibr_crewai/instrumentor.py,sha256=-G_-xaqE3Op70MSEIaZjPYioGDxKRagwLbZmcmmvzFg,26793
+kalibr_langchain/__init__.py,sha256=voHgdkcZ6oo336YK_uAFBHyOB11EBbnDS92UDoXRZiI,1448
 kalibr_langchain/async_callback.py,sha256=_Mj_YrKbULNtfxixZ7iwiHyWEV9l178ZA5Oy5A5Pakk,27748
 kalibr_langchain/callback.py,sha256=SNM1aHOXdG55grHmGyTwbXOeM6hjZTub2REiZD2H-d8,35216
+kalibr_langchain/chat_model.py,sha256=Y4xsZGx9gZpDUF8NP-edJuYam4k0NBySdA6B5484MKk,3190
 kalibr_openai_agents/__init__.py,sha256=wL59LzGstptKigfQDrKKt_7hcMO1JGVQtVAsE0lz-Zw,1367
 kalibr_openai_agents/processor.py,sha256=F550sdRf3rpguP1yOlgAUQWDLPBy4hSACV3-zOyCpOU,18257
-kalibr-1.2.2.dist-info/LICENSE,sha256=5mwAnB38l3_PjmOQn6_L6cZnJvus143DUjMBPIH1yso,10768
-kalibr-1.2.2.dist-info/METADATA,sha256=XqhSOZekE5D5WQVT0pH2h1HCZWXiruGM9CqOelAZnf0,11201
-kalibr-1.2.2.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
-kalibr-1.2.2.dist-info/entry_points.txt,sha256=Kojlc6WRX8V1qS9lOMdDPZpTUVHCtzGtHqXusErgmLY,47
-kalibr-1.2.2.dist-info/top_level.txt,sha256=dIfBOWUnnHGFDwgz5zfIx5_0bU3wOUgAbYr4JcFHZmo,59
-kalibr-1.2.2.dist-info/RECORD,,
+kalibr-1.2.4.dist-info/LICENSE,sha256=5mwAnB38l3_PjmOQn6_L6cZnJvus143DUjMBPIH1yso,10768
+kalibr-1.2.4.dist-info/METADATA,sha256=aXtgLOmzI6z7R1Zb0pFYU2jy2V4PUcUJKVFm0nciSL8,7037
+kalibr-1.2.4.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+kalibr-1.2.4.dist-info/entry_points.txt,sha256=Kojlc6WRX8V1qS9lOMdDPZpTUVHCtzGtHqXusErgmLY,47
+kalibr-1.2.4.dist-info/top_level.txt,sha256=dIfBOWUnnHGFDwgz5zfIx5_0bU3wOUgAbYr4JcFHZmo,59
+kalibr-1.2.4.dist-info/RECORD,,

kalibr_crewai/instrumentor.py

@@ -12,6 +12,8 @@ from datetime import datetime, timezone
 from functools import wraps
 from typing import Any, Callable, Dict, List, Optional
 
+from opentelemetry import trace as otel_trace
+
 from .callbacks import EventBatcher, _count_tokens, _get_provider_from_model
 
 # Import Kalibr cost adapters
@@ -275,6 +277,21 @@ class KalibrCrewAIInstrumentor:
                 duration_ms = int((time.time() - start_time) * 1000)
                 ts_end = datetime.now(timezone.utc)
 
+                # Enrich CrewAI's OTel span with Kalibr telemetry
+                try:
+                    current_span = otel_trace.get_current_span()
+                    if current_span and current_span.is_recording():
+                        current_span.set_attribute("kalibr.cost_usd", instrumentor._accumulated_cost)
+                        current_span.set_attribute("kalibr.input_tokens", instrumentor._accumulated_tokens["input"])
+                        current_span.set_attribute("kalibr.output_tokens", instrumentor._accumulated_tokens["output"])
+                        current_span.set_attribute("kalibr.total_tokens", instrumentor._accumulated_tokens["input"] + instrumentor._accumulated_tokens["output"])
+                        current_span.set_attribute("kalibr.model_id", model_name)
+                        current_span.set_attribute("kalibr.provider", provider)
+                        current_span.set_attribute("kalibr.duration_ms", duration_ms)
+                        current_span.set_attribute("kalibr.tenant_id", instrumentor.tenant_id)
+                except Exception:
+                    pass  # Don't fail if span enrichment fails
+
                 # Build output info
                 output_preview = None
                 if instrumentor.capture_output and result is not None:
@@ -376,6 +393,21 @@ class KalibrCrewAIInstrumentor:
                 duration_ms = int((time.time() - start_time) * 1000)
                 ts_end = datetime.now(timezone.utc)
 
+                # Enrich CrewAI's OTel span with Kalibr telemetry
+                try:
+                    current_span = otel_trace.get_current_span()
+                    if current_span and current_span.is_recording():
+                        current_span.set_attribute("kalibr.cost_usd", instrumentor._accumulated_cost)
+                        current_span.set_attribute("kalibr.input_tokens", instrumentor._accumulated_tokens["input"])
+                        current_span.set_attribute("kalibr.output_tokens", instrumentor._accumulated_tokens["output"])
+                        current_span.set_attribute("kalibr.total_tokens", instrumentor._accumulated_tokens["input"] + instrumentor._accumulated_tokens["output"])
+                        current_span.set_attribute("kalibr.model_id", model_name)
+                        current_span.set_attribute("kalibr.provider", provider)
+                        current_span.set_attribute("kalibr.duration_ms", duration_ms)
+                        current_span.set_attribute("kalibr.tenant_id", instrumentor.tenant_id)
+                except Exception:
+                    pass  # Don't fail if span enrichment fails
+
                 output_preview = None
                 if instrumentor.capture_output and result is not None:
                     output_preview = str(result)[:500]

kalibr_langchain/__init__.py

@@ -1,4 +1,4 @@
-"""Kalibr LangChain Integration - Observability for LangChain applications.
+"""Kalibr LangChain Integration - Observability and Routing for LangChain applications.
 
 This package provides a callback handler that integrates LangChain with
 Kalibr's observability platform, capturing:
@@ -39,9 +39,11 @@ __version__ = "0.1.0"
 
 from .callback import KalibrCallbackHandler
 from .async_callback import AsyncKalibrCallbackHandler
+from .chat_model import KalibrChatModel
 
 __all__ = [
     "KalibrCallbackHandler",
     "AsyncKalibrCallbackHandler",
+    "KalibrChatModel",
     "__version__",
 ]

kalibr_langchain/chat_model.py

@@ -0,0 +1,103 @@
+"""
+Kalibr LangChain Chat Model - Routes requests through Kalibr.
+"""
+
+from typing import Any, List, Optional
+
+from langchain_core.callbacks import CallbackManagerForLLMRun
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_core.messages import AIMessage, BaseMessage
+from langchain_core.outputs import ChatGeneration, ChatResult
+
+
+class KalibrChatModel(BaseChatModel):
+    """
+    LangChain chat model that routes through Kalibr.
+
+    Example:
+        from kalibr import Router
+
+        router = Router(goal="summarize", paths=["gpt-4o", "claude-3"])
+        llm = router.as_langchain()
+
+        chain = prompt | llm | parser
+        result = chain.invoke({"text": "..."})
+    """
+
+    router: Any  # Kalibr Router instance
+
+    model_config = {"arbitrary_types_allowed": True}
+
+    @property
+    def _llm_type(self) -> str:
+        return "kalibr"
+
+    @property
+    def _identifying_params(self) -> dict:
+        return {"goal": self.router.goal}
+
+    def _generate(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> ChatResult:
+        """Generate a response using Kalibr routing."""
+
+        # Convert LangChain messages to OpenAI format
+        openai_messages = []
+        for m in messages:
+            role = self._get_role(m)
+            openai_messages.append({"role": role, "content": m.content})
+
+        # Add stop sequences if provided
+        if stop:
+            kwargs["stop"] = stop
+
+        # Call router
+        response = self.router.completion(messages=openai_messages, **kwargs)
+
+        # Convert response to LangChain format
+        content = response.choices[0].message.content or ""
+
+        return ChatResult(
+            generations=[
+                ChatGeneration(
+                    message=AIMessage(content=content),
+                    generation_info={
+                        "model": response.model,
+                        "finish_reason": response.choices[0].finish_reason,
+                    },
+                )
+            ],
+            llm_output={
+                "model": response.model,
+                "usage": {
+                    "prompt_tokens": response.usage.prompt_tokens,
+                    "completion_tokens": response.usage.completion_tokens,
+                    "total_tokens": response.usage.total_tokens,
+                } if hasattr(response, "usage") else {},
+            },
+        )
+
+    def _get_role(self, message: BaseMessage) -> str:
+        """Convert LangChain message type to OpenAI role."""
+        from langchain_core.messages import (
+            HumanMessage,
+            AIMessage,
+            SystemMessage,
+            FunctionMessage,
+            ToolMessage,
+        )
+
+        if isinstance(message, HumanMessage):
+            return "user"
+        elif isinstance(message, AIMessage):
+            return "assistant"
+        elif isinstance(message, SystemMessage):
+            return "system"
+        elif isinstance(message, (FunctionMessage, ToolMessage)):
+            return "function"
+        else:
+            return "user"

kalibr-1.2.2.dist-info/METADATA

@@ -1,384 +0,0 @@
-Metadata-Version: 2.2
-Name: kalibr
-Version: 1.2.2
-Summary: Unified LLM Observability & Multi-Model AI Integration Framework - Deploy to GPT, Claude, Gemini, Copilot with full telemetry.
-Author-email: Kalibr Team <support@kalibr.systems>
-License: Apache-2.0
-Project-URL: Homepage, https://github.com/kalibr-ai/kalibr-sdk-python
-Project-URL: Documentation, https://kalibr.systems/docs
-Project-URL: Repository, https://github.com/kalibr-ai/kalibr-sdk-python
-Project-URL: Issues, https://github.com/kalibr-ai/kalibr-sdk-python/issues
-Keywords: ai,mcp,gpt,claude,gemini,copilot,openai,anthropic,google,microsoft,observability,telemetry,tracing,llm,schema-generation,api,multi-model,langchain,crewai
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: httpx>=0.27.0
-Requires-Dist: tiktoken>=0.8.0
-Requires-Dist: fastapi>=0.110.1
-Requires-Dist: uvicorn>=0.25.0
-Requires-Dist: pydantic>=2.6.4
-Requires-Dist: typer>=0.9.0
-Requires-Dist: python-multipart>=0.0.9
-Requires-Dist: rich>=10.0.0
-Requires-Dist: requests>=2.31.0
-Requires-Dist: opentelemetry-api>=1.20.0
-Requires-Dist: opentelemetry-sdk>=1.20.0
-Requires-Dist: opentelemetry-exporter-otlp>=1.20.0
-Provides-Extra: langchain
-Requires-Dist: langchain-core>=0.1.0; extra == "langchain"
-Provides-Extra: langchain-openai
-Requires-Dist: langchain-core>=0.1.0; extra == "langchain-openai"
-Requires-Dist: langchain-openai>=0.1.0; extra == "langchain-openai"
-Provides-Extra: langchain-anthropic
-Requires-Dist: langchain-core>=0.1.0; extra == "langchain-anthropic"
-Requires-Dist: langchain-anthropic>=0.1.0; extra == "langchain-anthropic"
-Provides-Extra: langchain-google
-Requires-Dist: langchain-core>=0.1.0; extra == "langchain-google"
-Requires-Dist: langchain-google-genai>=0.0.10; extra == "langchain-google"
-Provides-Extra: langchain-all
-Requires-Dist: langchain-core>=0.1.0; extra == "langchain-all"
-Requires-Dist: langchain-openai>=0.1.0; extra == "langchain-all"
-Requires-Dist: langchain-anthropic>=0.1.0; extra == "langchain-all"
-Requires-Dist: langchain-google-genai>=0.0.10; extra == "langchain-all"
-Provides-Extra: crewai
-Requires-Dist: crewai>=0.28.0; extra == "crewai"
-Provides-Extra: openai-agents
-Requires-Dist: openai-agents>=0.0.3; extra == "openai-agents"
-Provides-Extra: integrations
-Requires-Dist: langchain-core>=0.1.0; extra == "integrations"
-Requires-Dist: crewai>=0.28.0; extra == "integrations"
-Requires-Dist: openai-agents>=0.0.3; extra == "integrations"
-Provides-Extra: dev
-Requires-Dist: pytest>=7.4.0; extra == "dev"
-Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
-Requires-Dist: black>=23.0.0; extra == "dev"
-Requires-Dist: ruff>=0.1.0; extra == "dev"
-
-# Kalibr Python SDK
-
-Production-grade observability and execution intelligence for LLM applications. Automatically instrument OpenAI, Anthropic, and Google AI SDKs with zero code changes.
-
-[![PyPI version](https://img.shields.io/pypi/v/kalibr)](https://pypi.org/project/kalibr/)
-[![Python](https://img.shields.io/pypi/pyversions/kalibr)](https://pypi.org/project/kalibr/)
-[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
-
-## Features
-
-- **Zero-code instrumentation** - Automatic tracing for OpenAI, Anthropic, and Google AI SDKs
-- **Outcome-conditioned routing** - Query for optimal models based on historical success rates
-- **TraceCapsule** - Cross-agent context propagation for multi-agent systems
-- **Cost tracking** - Real-time cost calculation for all LLM calls
-- **Token monitoring** - Track input/output tokens across providers
-- **Framework integrations** - LangChain, CrewAI, OpenAI Agents SDK
-
-## Installation
-
-```bash
-pip install kalibr
-```
-
-## Quick Start
-
-### Auto-instrumentation (Recommended)
-
-Simply import `kalibr` at the start of your application - all LLM calls are automatically traced:
-
-```python
-import kalibr  # Must be FIRST import
-from openai import OpenAI
-
-client = OpenAI()
-response = client.chat.completions.create(
-    model="gpt-4o",
-    messages=[{"role": "user", "content": "Hello!"}]
-)
-# That's it. The call is automatically traced.
-```
-
-### Manual Tracing with @trace Decorator
-
-For more control, use the `@trace` decorator:
-
-```python
-from kalibr import trace
-from openai import OpenAI
-
-@trace(operation="summarize", provider="openai", model="gpt-4o")
-def summarize_text(text: str) -> str:
-    client = OpenAI()
-    response = client.chat.completions.create(
-        model="gpt-4o",
-        messages=[
-            {"role": "system", "content": "Summarize the following text."},
-            {"role": "user", "content": text}
-        ]
-    )
-    return response.choices[0].message.content
-```
-
-### Multi-Provider Example
-
-```python
-import kalibr
-from openai import OpenAI
-from anthropic import Anthropic
-
-# Both are automatically traced
-openai_client = OpenAI()
-anthropic_client = Anthropic()
-
-gpt_response = openai_client.chat.completions.create(
-    model="gpt-4o",
-    messages=[{"role": "user", "content": "Explain quantum computing"}]
-)
-
-claude_response = anthropic_client.messages.create(
-    model="claude-3-5-sonnet-20241022",
-    max_tokens=1024,
-    messages=[{"role": "user", "content": "Explain machine learning"}]
-)
-```
-
-## Outcome-Conditioned Routing
-
-Query Kalibr for optimal model recommendations based on real execution outcomes:
-
-```python
-from kalibr import get_policy, report_outcome
-
-# Before executing - get the best model for your goal
-policy = get_policy(goal="book_meeting")
-print(f"Use {policy['recommended_model']} - {policy['outcome_success_rate']:.0%} success rate")
-
-# Execute with the recommended model
-# ...
-
-# After executing - report what happened
-report_outcome(
-    trace_id="abc123",
-    goal="book_meeting",
-    success=True
-)
-```
-
-### With Constraints
-
-```python
-from kalibr import get_policy
-
-policy = get_policy(
-    goal="resolve_ticket",
-    constraints={
-        "max_cost_usd": 0.05,
-        "max_latency_ms": 3000,
-        "min_quality": 0.8
-    }
-)
-```
-
-### Intelligent Routing with decide()
-
-Register execution paths and let Kalibr decide the best strategy:
-
-```python
-from kalibr import register_path, decide
-
-# Register available paths
-register_path(goal="book_meeting", model_id="gpt-4o", tool_id="calendar_api")
-register_path(goal="book_meeting", model_id="claude-3-sonnet")
-
-# Get intelligent routing decision
-decision = decide(goal="book_meeting")
-model = decision["model_id"]       # Selected based on outcomes
-tool = decision.get("tool_id")     # If tool routing enabled
-print(decision["exploration"])     # True if exploring new paths
-```
-
-### Goal Context
-
-Tag traces with goals for outcome tracking:
-
-```python
-from kalibr import goal, set_goal, get_goal, clear_goal
-
-# Context manager (recommended)
-with goal("book_meeting"):
-    response = openai.chat.completions.create(...)
-
-# Or manual control
-set_goal("book_meeting")
-response = openai.chat.completions.create(...)
-clear_goal()
-```
-
-## TraceCapsule - Cross-Agent Tracing
-
-Propagate trace context across agent boundaries:
-
-```python
-from kalibr import TraceCapsule, get_or_create_capsule
-
-# Agent 1: Create capsule and add hop
-capsule = get_or_create_capsule()
-capsule.append_hop({
-    "provider": "openai",
-    "operation": "chat_completion",
-    "model": "gpt-4o",
-    "duration_ms": 150,
-    "cost_usd": 0.002,
-    "status": "success"
-})
-
-# Pass to Agent 2 via HTTP header
-headers = {"X-Kalibr-Capsule": capsule.to_json()}
-
-# Agent 2: Receive and continue
-capsule = TraceCapsule.from_json(headers["X-Kalibr-Capsule"])
-capsule.append_hop({
-    "provider": "anthropic",
-    "operation": "chat_completion",
-    "model": "claude-3-5-sonnet-20241022",
-    "duration_ms": 200,
-    "cost_usd": 0.003,
-    "status": "success"
-})
-```
-
-## Framework Integrations
-
-### LangChain
-
-```bash
-pip install kalibr[langchain]
-```
-
-```python
-from kalibr_langchain import KalibrCallbackHandler
-from langchain_openai import ChatOpenAI
-
-handler = KalibrCallbackHandler()
-llm = ChatOpenAI(model="gpt-4o", callbacks=[handler])
-response = llm.invoke("What is the capital of France?")
-```
-
-See [LangChain Integration Guide](kalibr_langchain/README.md) for full documentation.
-
-### CrewAI
-
-```bash
-pip install kalibr[crewai]
-```
-
-```python
-from kalibr_crewai import KalibrCrewAIInstrumentor
-from crewai import Agent, Task, Crew
-
-instrumentor = KalibrCrewAIInstrumentor()
-instrumentor.instrument()
-
-# Use CrewAI normally - all operations are traced
-```
-
-See [CrewAI Integration Guide](kalibr_crewai/README.md) for full documentation.
-
-### OpenAI Agents SDK
-
-```bash
-pip install kalibr[openai-agents]
-```
-
-```python
-from kalibr_openai_agents import setup_kalibr_tracing
-from agents import Agent, Runner
-
-setup_kalibr_tracing()
-
-agent = Agent(name="Assistant", instructions="You are helpful.")
-result = Runner.run_sync(agent, "Hello!")
-```
-
-See [OpenAI Agents Integration Guide](kalibr_openai_agents/README.md) for full documentation.
-
-## Configuration
-
-Configure via environment variables:
-
-| Variable | Description | Default |
-|----------|-------------|---------|
-| `KALIBR_API_KEY` | API key for authentication | *Required* |
-| `KALIBR_TENANT_ID` | Tenant identifier | `default` |
-| `KALIBR_COLLECTOR_URL` | Collector endpoint URL | `https://api.kalibr.systems/api/ingest` |
-| `KALIBR_INTELLIGENCE_URL` | Intelligence API URL | `https://dashboard.kalibr.systems/intelligence` |
-| `KALIBR_SERVICE_NAME` | Service name for spans | `kalibr-app` |
-| `KALIBR_ENVIRONMENT` | Environment (prod/staging/dev) | `prod` |
-| `KALIBR_WORKFLOW_ID` | Workflow identifier | `default` |
-| `KALIBR_AUTO_INSTRUMENT` | Enable auto-instrumentation | `true` |
-
-## CLI Commands
-
-```bash
-# Show version
-kalibr version
-
-# Validate configuration
-kalibr validate
-
-# Check connection status
-kalibr status
-
-# Package for deployment
-kalibr package
-
-# Update schemas
-kalibr update_schemas
-```
-
-## Supported Providers
-
-| Provider | Models | Auto-Instrumentation |
-|----------|--------|---------------------|
-| OpenAI | GPT-4, GPT-4o, GPT-3.5 | Yes |
-| Anthropic | Claude 3.5 Sonnet, Claude 3 Opus/Sonnet/Haiku | Yes |
-| Google | Gemini Pro, Gemini Flash | Yes |
-
-## Development
-
-```bash
-git clone https://github.com/kalibr-ai/kalibr-sdk-python.git
-cd kalibr-sdk-python
-
-pip install -e ".[dev]"
-
-# Run tests
-pytest
-
-# Format code
-black kalibr/
-ruff check kalibr/
-```
-
-## Contributing
-
-We welcome contributions! See [CONTRIBUTING.md](CONTRIBUTING.md).
-
-## License
-
-Apache 2.0 - see [LICENSE](LICENSE).
-
-## Links
-
-- [Documentation](https://kalibr.systems/docs)
-- [Dashboard](https://dashboard.kalibr.systems)
-- [GitHub](https://github.com/kalibr-ai/kalibr-sdk-python)
-- [PyPI](https://pypi.org/project/kalibr/)