kalibr 1.0.21__tar.gz → 1.0.23__tar.gz

kalibr-1.0.23/PKG-INFO

@@ -0,0 +1,257 @@
+Metadata-Version: 2.4
+Name: kalibr
+Version: 1.0.23
+Summary: Multi-Model AI Integration Framework
+Home-page: https://github.com/devonakelley/kalibr-sdk
+Author: Kalibr Team
+Author-email: Kalibr Team <team@kalibr.dev>
+License: MIT
+Project-URL: Homepage, https://kalibr.dev
+Project-URL: Documentation, https://kalibr.dev/docs
+Project-URL: Repository, https://github.com/devonakelley/kalibr-sdk
+Project-URL: Bug Reports, https://github.com/devonakelley/kalibr-sdk/issues
+Keywords: ai,api,framework,gpt,claude,gemini,copilot,multi-model,sdk
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Application
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+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: requests>=2.31.0
+Requires-Dist: python-jose[cryptography]>=3.3.0
+Requires-Dist: passlib[bcrypt]>=1.7.4
+Requires-Dist: python-multipart>=0.0.9
+Requires-Dist: motor>=3.3.1
+Requires-Dist: pymongo>=4.5.0
+Requires-Dist: boto3>=1.34.129
+Requires-Dist: aiofiles>=23.2.1
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: black>=24.1.1; extra == "dev"
+Requires-Dist: isort>=5.13.2; extra == "dev"
+Requires-Dist: flake8>=7.0.0; extra == "dev"
+Requires-Dist: mypy>=1.8.0; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Kalibr SDK  
+### Multi-Model AI Integration Framework
+
+**Write once. Deploy anywhere. Connect to any AI model.**
+
+Kalibr turns Python functions into APIs that work seamlessly with GPT, Claude, Gemini, and Copilot — automatically generating model-specific schemas and endpoints.
+
+---
+
+## 🚀 Quick Start (2 minutes)
+
+### 1. Install
+```bash
+pip install kalibr
+```
+
+### 2. Get Examples
+```bash
+kalibr-connect examples
+```
+This copies example files to `./kalibr_examples/` in your current directory.
+
+### 3. Run Demo
+```bash
+kalibr-connect serve kalibr_examples/basic_kalibr_example.py
+```
+
+### 4. See All Schemas
+Kalibr now **auto-detects your environment** and generates the correct base URLs.
+
+| Environment | Example Base URL |
+|--------------|------------------|
+| Local Dev | `http://localhost:8000` |
+| Fly.io | `https://<app-name>.fly.dev` |
+| Custom Host | Use `KALIBR_BASE_URL` env var |
+
+Then open:
+```
+<your-base-url>/gpt-actions.json    # ChatGPT
+<your-base-url>/mcp.json            # Claude
+<your-base-url>/schemas/gemini      # Gemini
+<your-base-url>/schemas/copilot     # Copilot
+```
+
+---
+
+## 🧠 What Kalibr Does
+
+Kalibr turns your Python functions into production-ready multi-model APIs.
+
+```python
+from kalibr import Kalibr
+
+app = Kalibr(title="Inventory API")
+
+@app.action("get_inventory", "Fetch inventory data")
+def get_inventory(product_id: str):
+    return {"product_id": product_id, "stock": 42}
+```
+
+Result:  
+ChatGPT, Claude, Gemini, and Copilot can all call `get_inventory()` using their native protocols — no schema work required.
+
+---
+
+## 💪 Two Modes
+
+### **Function-Level (Simple)**
+Ideal for one-off APIs or scripts.
+
+```python
+from kalibr import Kalibr
+
+app = Kalibr(title="My API")
+
+@app.action("calculate_price", "Calculate price total")
+def calculate_price(product_id: str, quantity: int):
+    return {"total": quantity * 19.99}
+```
+
+### **App-Level (Advanced)**
+Use `KalibrApp` for complete control — file uploads, sessions, streaming, and workflows.
+
+```python
+from kalibr import KalibrApp
+from kalibr.types import FileUpload, Session
+
+app = KalibrApp(title="Advanced API")
+
+@app.file_handler("analyze_doc", [".pdf", ".docx"])
+async def analyze_doc(file: FileUpload):
+    return {"filename": file.filename, "analysis": "..."}
+
+@app.session_action("save_data", "Save session data")
+async def save_data(session: Session, data: dict):
+    session.set("my_data", data)
+    return {"saved": True}
+```
+
+---
+
+## 📚 Examples Included
+
+After running `kalibr-connect examples`, you’ll get:
+
+- `basic_kalibr_example.py` – simple function-level demo  
+- `enhanced_kalibr_example.py` – full app with sessions, uploads, and streaming  
+
+---
+
+## 🤖 AI Platform Integration
+
+### ChatGPT (GPT Actions)
+1. Copy schema URL:  
+   `https://<your-domain>/gpt-actions.json`
+2. In GPT Builder → *Actions* → *Import from URL*
+3. Done — ChatGPT can call your endpoints.
+
+### Claude (MCP)
+Add to Claude Desktop config:
+```json
+{
+  "mcp": {
+    "servers": {
+      "my-api": {
+        "url": "https://<your-domain>/mcp.json"
+      }
+    }
+  }
+}
+```
+
+### Gemini / Copilot
+Use:
+```
+https://<your-domain>/schemas/gemini
+https://<your-domain>/schemas/copilot
+```
+
+---
+
+## 🎯 Common Use Cases
+
+- **Customer Service APIs** — let AI handle orders or refunds  
+- **Data Analysis** — query your analytics through AI  
+- **Document Processing** — parse or summarize uploaded docs  
+- **Business Automation** — trigger internal workflows  
+- **Internal Tools** — expose secure internal logic to assistants  
+
+---
+
+## 🔧 CLI Reference
+
+```bash
+kalibr-connect examples          # Copy examples
+kalibr-connect serve my_app.py   # Run locally
+kalibr-connect version           # Show version
+kalibr-connect --help            # Full CLI
+```
+
+---
+
+## ⚡ Key Features
+
+✅ Multi-Model Support — GPT, Claude, Gemini, Copilot  
+✅ Automatic Schema Generation  
+✅ Environment-Aware Base URLs (v1.0.21+)  
+✅ File Uploads  
+✅ Session Management  
+✅ Streaming Responses  
+✅ Workflow Support  
+✅ Type-Safe API Generation  
+✅ Async / Await Ready  
+
+---
+
+## 🔥 Why Kalibr?
+
+Without Kalibr:
+- Learn 4 model specs  
+- Maintain 4 codebases  
+- Duplicate effort  
+
+With Kalibr:
+- One Python function  
+- Four schemas generated automatically  
+- Deploy anywhere  
+
+---
+
+## 🆕 Version 1.0.21+
+
+- **Automatic Base-URL Detection**  
+  - Works with `KALIBR_BASE_URL` or `FLY_APP_NAME`  
+  - Fixes all localhost references in deployed schemas  
+- Ready for **MCP ecosystem production use**  
+- Drop-in backwards compatibility  
+
+---
+
+## 🧩 License
+
+MIT License — see `LICENSE` file for details.  
+
+---
+
+**Kalibr SDK — the unified layer between AI models and the real world.**  
+Write once. Deploy anywhere. Integrate everything.

kalibr-1.0.23/README.md

@@ -0,0 +1,208 @@
+# Kalibr SDK  
+### Multi-Model AI Integration Framework
+
+**Write once. Deploy anywhere. Connect to any AI model.**
+
+Kalibr turns Python functions into APIs that work seamlessly with GPT, Claude, Gemini, and Copilot — automatically generating model-specific schemas and endpoints.
+
+---
+
+## 🚀 Quick Start (2 minutes)
+
+### 1. Install
+```bash
+pip install kalibr
+```
+
+### 2. Get Examples
+```bash
+kalibr-connect examples
+```
+This copies example files to `./kalibr_examples/` in your current directory.
+
+### 3. Run Demo
+```bash
+kalibr-connect serve kalibr_examples/basic_kalibr_example.py
+```
+
+### 4. See All Schemas
+Kalibr now **auto-detects your environment** and generates the correct base URLs.
+
+| Environment | Example Base URL |
+|--------------|------------------|
+| Local Dev | `http://localhost:8000` |
+| Fly.io | `https://<app-name>.fly.dev` |
+| Custom Host | Use `KALIBR_BASE_URL` env var |
+
+Then open:
+```
+<your-base-url>/gpt-actions.json    # ChatGPT
+<your-base-url>/mcp.json            # Claude
+<your-base-url>/schemas/gemini      # Gemini
+<your-base-url>/schemas/copilot     # Copilot
+```
+
+---
+
+## 🧠 What Kalibr Does
+
+Kalibr turns your Python functions into production-ready multi-model APIs.
+
+```python
+from kalibr import Kalibr
+
+app = Kalibr(title="Inventory API")
+
+@app.action("get_inventory", "Fetch inventory data")
+def get_inventory(product_id: str):
+    return {"product_id": product_id, "stock": 42}
+```
+
+Result:  
+ChatGPT, Claude, Gemini, and Copilot can all call `get_inventory()` using their native protocols — no schema work required.
+
+---
+
+## 💪 Two Modes
+
+### **Function-Level (Simple)**
+Ideal for one-off APIs or scripts.
+
+```python
+from kalibr import Kalibr
+
+app = Kalibr(title="My API")
+
+@app.action("calculate_price", "Calculate price total")
+def calculate_price(product_id: str, quantity: int):
+    return {"total": quantity * 19.99}
+```
+
+### **App-Level (Advanced)**
+Use `KalibrApp` for complete control — file uploads, sessions, streaming, and workflows.
+
+```python
+from kalibr import KalibrApp
+from kalibr.types import FileUpload, Session
+
+app = KalibrApp(title="Advanced API")
+
+@app.file_handler("analyze_doc", [".pdf", ".docx"])
+async def analyze_doc(file: FileUpload):
+    return {"filename": file.filename, "analysis": "..."}
+
+@app.session_action("save_data", "Save session data")
+async def save_data(session: Session, data: dict):
+    session.set("my_data", data)
+    return {"saved": True}
+```
+
+---
+
+## 📚 Examples Included
+
+After running `kalibr-connect examples`, you’ll get:
+
+- `basic_kalibr_example.py` – simple function-level demo  
+- `enhanced_kalibr_example.py` – full app with sessions, uploads, and streaming  
+
+---
+
+## 🤖 AI Platform Integration
+
+### ChatGPT (GPT Actions)
+1. Copy schema URL:  
+   `https://<your-domain>/gpt-actions.json`
+2. In GPT Builder → *Actions* → *Import from URL*
+3. Done — ChatGPT can call your endpoints.
+
+### Claude (MCP)
+Add to Claude Desktop config:
+```json
+{
+  "mcp": {
+    "servers": {
+      "my-api": {
+        "url": "https://<your-domain>/mcp.json"
+      }
+    }
+  }
+}
+```
+
+### Gemini / Copilot
+Use:
+```
+https://<your-domain>/schemas/gemini
+https://<your-domain>/schemas/copilot
+```
+
+---
+
+## 🎯 Common Use Cases
+
+- **Customer Service APIs** — let AI handle orders or refunds  
+- **Data Analysis** — query your analytics through AI  
+- **Document Processing** — parse or summarize uploaded docs  
+- **Business Automation** — trigger internal workflows  
+- **Internal Tools** — expose secure internal logic to assistants  
+
+---
+
+## 🔧 CLI Reference
+
+```bash
+kalibr-connect examples          # Copy examples
+kalibr-connect serve my_app.py   # Run locally
+kalibr-connect version           # Show version
+kalibr-connect --help            # Full CLI
+```
+
+---
+
+## ⚡ Key Features
+
+✅ Multi-Model Support — GPT, Claude, Gemini, Copilot  
+✅ Automatic Schema Generation  
+✅ Environment-Aware Base URLs (v1.0.21+)  
+✅ File Uploads  
+✅ Session Management  
+✅ Streaming Responses  
+✅ Workflow Support  
+✅ Type-Safe API Generation  
+✅ Async / Await Ready  
+
+---
+
+## 🔥 Why Kalibr?
+
+Without Kalibr:
+- Learn 4 model specs  
+- Maintain 4 codebases  
+- Duplicate effort  
+
+With Kalibr:
+- One Python function  
+- Four schemas generated automatically  
+- Deploy anywhere  
+
+---
+
+## 🆕 Version 1.0.21+
+
+- **Automatic Base-URL Detection**  
+  - Works with `KALIBR_BASE_URL` or `FLY_APP_NAME`  
+  - Fixes all localhost references in deployed schemas  
+- Ready for **MCP ecosystem production use**  
+- Drop-in backwards compatibility  
+
+---
+
+## 🧩 License
+
+MIT License — see `LICENSE` file for details.  
+
+---
+
+**Kalibr SDK — the unified layer between AI models and the real world.**  
+Write once. Deploy anywhere. Integrate everything.

kalibr-1.0.23/kalibr/__main__.py

@@ -0,0 +1,206 @@
+import typer
+import uvicorn
+import sys
+import importlib.util
+from pathlib import Path
+import os
+import requests
+import json
+
+app = typer.Typer()
+
+def _load_user_module(file: str):
+    file_path = Path(file).resolve()
+    if not file_path.exists():
+        print(f"❌ Error: {file} not found")
+        raise typer.Exit(1)
+    spec = importlib.util.spec_from_file_location("user_app", file_path)
+    if not spec or not spec.loader:
+        print(f"❌ Error: Could not load {file}")
+        raise typer.Exit(1)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules["user_app"] = module
+    try:
+        spec.loader.exec_module(module)
+    except Exception as e:
+        print(f"❌ Error loading {file}: {e}")
+        raise typer.Exit(1)
+    return module
+
+@app.command()
+def serve(
+    file: str = typer.Argument("kalibr_app.py", help="Python file with Kalibr app"),
+    host: str = typer.Option("0.0.0.0", "--host", "-h"),
+    port: int = typer.Option(8000, "--port", "-p"),
+    base_url: str = typer.Option("http://localhost:8000", "--base-url", "-b"),
+):
+    """Serve a Kalibr-powered API locally."""
+    module = _load_user_module(file)
+
+    # Import Kalibr classes
+    from kalibr import Kalibr, KalibrApp
+    kalibr_instance = None
+    for attr_name in dir(module):
+        attr = getattr(module, attr_name)
+        if isinstance(attr, Kalibr) or (KalibrApp and isinstance(attr, KalibrApp)):
+            kalibr_instance = attr
+            kalibr_instance.base_url = base_url
+            break
+    if not kalibr_instance:
+        print(f"❌ Error: No Kalibr/KalibrApp instance found in {file}")
+        raise typer.Exit(1)
+
+    if hasattr(kalibr_instance, 'get_app'):
+        fastapi_app = kalibr_instance.get_app()
+    elif hasattr(kalibr_instance, 'app'):
+        fastapi_app = kalibr_instance.app
+    else:
+        print(f"❌ Error: Kalibr instance has no get_app() method or app attribute")
+        raise typer.Exit(1)
+
+    is_enhanced = 'KalibrApp' in str(type(kalibr_instance))
+    print(f"🚀 Starting {'Enhanced ' if is_enhanced else ''}Kalibr server from {file}")
+    print(f"📍 GPT (OpenAPI):     {base_url}/openapi.json")
+    print(f"📍 Claude (MCP):      {base_url}/mcp.json")
+    if is_enhanced:
+        print(f"📍 Gemini:            {base_url}/schemas/gemini")
+        print(f"📍 Copilot:           {base_url}/schemas/copilot")
+        print(f"📍 Supported Models:  {base_url}/models/supported")
+        print(f"📍 Health Check:      {base_url}/health")
+    print(f"📍 Swagger UI:        {base_url}/docs")
+    print(f"🔌 Actions registered: {list(kalibr_instance.actions.keys())}")
+
+    uvicorn.run(fastapi_app, host=host, port=port)
+
+@app.command()
+def package(
+    app_dir: str = typer.Option(".", "--app-dir", "-d", help="Directory containing your app"),
+    output: str = typer.Option("kalibr_bundle.zip", "--output", "-o", help="Bundle file"),
+    models: str = typer.Option("mcp,gpt-actions,gemini,copilot", "--models", "-m", help="Comma-separated models supported")
+):
+    """Create a deployable MCP bundle (code + schemas + metadata)."""
+    from kalibr.packager import package_app
+    try:
+        models_supported = [x.strip() for x in models.split(",") if x.strip()]
+        # Version best-effort
+        try:
+            from kalibr import __version__ as kalibr_version
+        except Exception:
+            kalibr_version = "unknown"
+        bundle_path = package_app(app_dir=app_dir, output=output, models_supported=models_supported, kalibr_version=kalibr_version)
+        print(f"📦 Bundle created: {bundle_path}")
+    except Exception as e:
+        print(f"❌ Packaging error: {e}")
+        raise typer.Exit(1)
+
+@app.command()
+def deploy(
+    file: str = typer.Argument(..., help="Python file to serve/deploy (e.g., kalibr_app.py)"),
+    name: str = typer.Option("", "--name", "-n", help="App name (defaults to filename)"),
+    runtime: str = typer.Option("local", "--runtime", "-r", help="Runtime: local|fly|render"),
+    host: str = typer.Option("0.0.0.0", "--host"),
+    port: int = typer.Option(8000, "--port"),
+    base_url: str = typer.Option("http://localhost:8000", "--base-url"),
+):
+    """Deploy via runtime router (no hosting burden on Kalibr)."""
+    from kalibr.runtime_router import deploy as router_deploy
+    file_path = Path(file)
+    if not file_path.exists():
+        print(f"❌ Error: {file} not found")
+        raise typer.Exit(1)
+    if not name:
+        name = file_path.stem.replace('_', '-').replace('.', '-')
+    try:
+        result = router_deploy(runtime=runtime, app_name=name, app_file=str(file_path), host=host, port=port, base_url=base_url)
+        if result.get("status") in ("success", "started"):
+            print("🎉 Deploy OK")
+            eps = result.get("endpoints", {})
+            if eps:
+                print("📍 Endpoints:")
+                for k, v in eps.items():
+                    print(f"   - {k}: {v}")
+        else:
+            print("⚠️  Deploy finished with unknown status:", result)
+    except Exception as e:
+        print(f"❌ Deployment error: {e}")
+        raise typer.Exit(1)
+
+@app.command()
+def validate(
+    url: str = typer.Option("http://localhost:8000/mcp.json", "--mcp-url", help="URL to MCP manifest"),
+):
+    """Validate MCP manifest against minimal JSON schema & version hint."""
+    from kalibr.validator import validate_mcp_manifest
+    try:
+        resp = requests.get(url, timeout=10)
+        resp.raise_for_status()
+        manifest = resp.json()
+        validate_mcp_manifest(manifest)
+        print("✅ MCP manifest looks structurally valid.")
+    except Exception as e:
+        print(f"❌ Validation failed: {e}")
+        raise typer.Exit(1)
+
+@app.command()
+def update_schemas():
+    """Stub: instruct users to upgrade SDK and regenerate manifests."""
+    from kalibr.validator import update_schemas as _upd
+    _upd()
+
+@app.command()
+def status(
+    app_url: str = typer.Argument(..., help="URL of deployed Kalibr app"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show detailed information")
+):
+    """Check status of a deployed Kalibr app."""
+    try:
+        health_url = f"{app_url.rstrip('/')}/health"
+        response = requests.get(health_url, timeout=10)
+        if response.status_code == 200:
+            health_data = response.json()
+            print(f"✅ App is healthy at {app_url}")
+            print(f"   Version: {health_data.get('version', 'unknown')}")
+            print(f"   Features: {health_data.get('features', {})}")
+            if verbose:
+                schemas = ["mcp.json", "openapi.json", "schemas/gemini", "schemas/copilot"]
+                print(f"\n📊 Available AI model schemas:")
+                for schema in schemas:
+                    schema_url = f"{app_url.rstrip('/')}/{schema}"
+                    try:
+                        schema_response = requests.get(schema_url, timeout=5)
+                        status_emoji = "✅" if schema_response.status_code == 200 else "❌"
+                        model_name = schema.replace(".json", "").replace("schemas/", "")
+                        print(f"   {status_emoji} {model_name.upper()}: {schema_url}")
+                    except:
+                        print(f"   ❌ {schema}: Connection failed")
+        else:
+            print(f"❌ App at {app_url} is not responding (HTTP {response.status_code})")
+            raise typer.Exit(1)
+    except requests.exceptions.RequestException as e:
+        print(f"❌ Cannot connect to {app_url}: {e}")
+        raise typer.Exit(1)
+
+@app.command()
+def version():
+    try:
+        from kalibr import __version__
+    except (ImportError, AttributeError):
+        __version__ = "unknown"
+    print(f"Kalibr SDK version: {__version__}")
+    print("Enhanced multi-model AI integration framework")
+    print("Supports: GPT Actions, Claude MCP, Gemini Extensions, Copilot Plugins")
+    print("GitHub: https://github.com/devonakelley/kalibr-sdk")
+
+def main():
+    config_file = Path.home() / ".kalibr" / "config.json"
+    if config_file.exists():
+        try:
+            config = json.loads(config_file.read_text())
+            if "api_token" in config and not os.environ.get("KALIBR_TOKEN"):
+                os.environ["KALIBR_TOKEN"] = config["api_token"]
+        except:
+            pass
+    app()
+
+if __name__ == "__main__":
+    main()

kalibr-1.0.23/kalibr/deployment.py

@@ -0,0 +1,41 @@
+"""
+Kalibr Deployment
+-----------------
+Thin wrapper that forwards to the runtime router.
+Keeps a simple API surface for backwards-compat commands.
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Dict, Any
+from kalibr.runtime_router import deploy as router_deploy
+
+@dataclass
+class DeploymentConfig:
+    app_name: str
+    memory_mb: int = 512
+    timeout_seconds: int = 30
+    environment_vars: Dict[str, str] = field(default_factory=dict)
+
+def deploy_app(file_path: str, config: DeploymentConfig, platform: str = "local") -> Dict[str, Any]:
+    # Map older "platform" to runtime names used by router
+    runtime = {
+        "local": "local",
+        "fly": "fly",
+        "aws-lambda": "local",  # not supported; punt to local
+        "render": "render",
+    }.get(platform, platform)
+
+    result = router_deploy(runtime=runtime, app_name=config.app_name, app_file=file_path)
+    if result.get("status") in ("success", "started"):
+        eps = result.get("endpoints", {})
+        return {
+            "status": "success",
+            "endpoints": {
+                "root": eps.get("root", ""),
+                "mcp": eps.get("mcp", ""),
+                "openapi": eps.get("openapi", ""),
+                "health": eps.get("health", ""),
+            }
+        }
+    return {"status": "error", "error": "unknown deploy outcome", "raw": result}