kalibr 1.0.20__py3-none-any.whl → 1.0.22__py3-none-any.whl

kalibr/kalibr_app.py

@@ -1,12 +1,11 @@
-# kalibr/kalibr_app.py - Full App-Level Implementation
-
-from fastapi import FastAPI, Request, UploadFile, File, Depends
+from fastapi import FastAPI, Request, UploadFile, File
 from fastapi.responses import JSONResponse, StreamingResponse as FastAPIStreamingResponse
 from typing import Callable, Dict, Any, List, Optional, get_type_hints
 import inspect
 import asyncio
 from datetime import datetime
 import uuid
+import os
 
 from kalibr.types import FileUpload, Session, WorkflowState
 
@@ -20,63 +19,67 @@ class KalibrApp:
     - Complex workflows
     - Multi-model schema generation
     """
-    
-    def __init__(self, title="Kalibr Enhanced API", version="2.0.0", base_url="http://localhost:8000"):
+
+    def __init__(self, title="Kalibr Enhanced API", version="2.0.0", base_url: Optional[str] = None):
         """
         Initialize the Kalibr enhanced app.
-        
-        Args:
-            title: API title
-            version: API version
-            base_url: Base URL for schema generation
+        Automatically determines correct base URL for deployed environments.
+
+        Priority:
+        1. Explicit `base_url` passed by user
+        2. Env var `KALIBR_BASE_URL`
+        3. Env var `FLY_APP_NAME` -> https://<fly_app_name>.fly.dev
+        4. Default localhost for dev
         """
         self.app = FastAPI(title=title, version=version)
-        self.base_url = base_url
-        
+
+        if base_url:
+            self.base_url = base_url
+        elif os.getenv("KALIBR_BASE_URL"):
+            self.base_url = os.getenv("KALIBR_BASE_URL")
+        elif os.getenv("FLY_APP_NAME"):
+            self.base_url = f"https://{os.getenv('FLY_APP_NAME')}.fly.dev"
+        else:
+            self.base_url = "http://localhost:8000"
+
         # Storage for different action types
-        self.actions = {}           # Regular actions
-        self.file_handlers = {}     # File upload handlers
-        self.session_actions = {}   # Session-aware actions
-        self.stream_actions = {}    # Streaming actions
-        self.workflows = {}         # Workflow handlers
-        
-        # Session storage (in-memory for simplicity)
+        self.actions: Dict[str, Any] = {}
+        self.file_handlers: Dict[str, Any] = {}
+        self.session_actions: Dict[str, Any] = {}
+        self.stream_actions: Dict[str, Any] = {}
+        self.workflows: Dict[str, Any] = {}
+
+        # Session and workflow memory
         self.sessions: Dict[str, Session] = {}
-        
-        # Workflow state storage
         self.workflow_states: Dict[str, WorkflowState] = {}
-        
+
         self._setup_routes()
-    
+
+    # -------------------------------------------------------------------------
+    # Action registration decorators
+    # -------------------------------------------------------------------------
+
     def action(self, name: str, description: str = ""):
-        """
-        Decorator to register a regular action.
-        
-        Usage:
-            @app.action("greet", "Greet someone")
-            def greet(name: str):
-                return {"message": f"Hello, {name}!"}
-        """
         def decorator(func: Callable):
             self.actions[name] = {
                 "func": func,
                 "description": description,
-                "params": self._extract_params(func)
+                "params": self._extract_params(func),
             }
-            
+
             endpoint_path = f"/proxy/{name}"
-            
+
             async def endpoint_handler(request: Request):
                 params = {}
                 if request.method == "POST":
                     try:
                         body = await request.json()
                         params = body if isinstance(body, dict) else {}
-                    except:
+                    except Exception:
                         params = {}
                 else:
                     params = dict(request.query_params)
-                
+
                 try:
                     result = func(**params)
                     if inspect.isawaitable(result):
@@ -84,92 +87,67 @@ class KalibrApp:
                     return JSONResponse(content=result)
                 except Exception as e:
                     return JSONResponse(content={"error": str(e)}, status_code=500)
-            
+
             self.app.post(endpoint_path)(endpoint_handler)
             self.app.get(endpoint_path)(endpoint_handler)
-            
             return func
+
         return decorator
-    
+
     def file_handler(self, name: str, allowed_extensions: List[str] = None, description: str = ""):
-        """
-        Decorator to register a file upload handler.
-        
-        Usage:
-            @app.file_handler("process_document", [".pdf", ".docx"])
-            async def process_document(file: FileUpload):
-                return {"filename": file.filename, "size": file.size}
-        """
         def decorator(func: Callable):
             self.file_handlers[name] = {
                 "func": func,
                 "description": description,
                 "allowed_extensions": allowed_extensions or [],
-                "params": self._extract_params(func)
+                "params": self._extract_params(func),
             }
-            
+
             endpoint_path = f"/files/{name}"
-            
+
             async def file_endpoint(file: UploadFile = File(...)):
                 try:
-                    # Validate file extension
                     if allowed_extensions:
                         file_ext = "." + file.filename.split(".")[-1] if "." in file.filename else ""
                         if file_ext not in allowed_extensions:
                             return JSONResponse(
                                 content={"error": f"File type {file_ext} not allowed. Allowed: {allowed_extensions}"},
-                                status_code=400
+                                status_code=400,
                             )
-                    
-                    # Read file content
+
                     content = await file.read()
-                    
-                    # Create FileUpload object
                     file_upload = FileUpload(
                         filename=file.filename,
                         content_type=file.content_type or "application/octet-stream",
                         size=len(content),
-                        content=content
+                        content=content,
                     )
-                    
-                    # Call handler
+
                     result = func(file_upload)
                     if inspect.isawaitable(result):
                         result = await result
-                    
                     return JSONResponse(content=result)
                 except Exception as e:
                     return JSONResponse(content={"error": str(e)}, status_code=500)
-            
+
             self.app.post(endpoint_path)(file_endpoint)
-            
             return func
+
         return decorator
-    
+
     def session_action(self, name: str, description: str = ""):
-        """
-        Decorator to register a session-aware action.
-        
-        Usage:
-            @app.session_action("save_data", "Save data to session")
-            async def save_data(session: Session, data: dict):
-                session.set("my_data", data)
-                return {"saved": True}
-        """
         def decorator(func: Callable):
             self.session_actions[name] = {
                 "func": func,
                 "description": description,
-                "params": self._extract_params(func)
+                "params": self._extract_params(func),
             }
-            
+
             endpoint_path = f"/session/{name}"
-            
+
             async def session_endpoint(request: Request):
                 try:
-                    # Get or create session
                     session_id = request.headers.get("X-Session-ID") or request.cookies.get("session_id")
-                    
                     if not session_id or session_id not in self.sessions:
                         session_id = str(uuid.uuid4())
                         session = Session(session_id=session_id)
@@ -177,67 +155,50 @@ class KalibrApp:
                     else:
                         session = self.sessions[session_id]
                         session.last_accessed = datetime.now()
-                    
-                    # Get request parameters
+
                     body = await request.json() if request.method == "POST" else {}
-                    
-                    # Call function with session
+
                     sig = inspect.signature(func)
-                    if 'session' in sig.parameters:
-                        # Remove 'session' from params, pass separately
-                        func_params = {k: v for k, v in body.items() if k != 'session'}
+                    if "session" in sig.parameters:
+                        func_params = {k: v for k, v in body.items() if k != "session"}
                         result = func(session=session, **func_params)
                     else:
                         result = func(**body)
-                    
+
                     if inspect.isawaitable(result):
                         result = await result
-                    
-                    # Return result with session ID
+
                     response = JSONResponse(content=result)
                     response.set_cookie("session_id", session_id)
                     response.headers["X-Session-ID"] = session_id
-                    
                     return response
                 except Exception as e:
                     return JSONResponse(content={"error": str(e)}, status_code=500)
-            
+
             self.app.post(endpoint_path)(session_endpoint)
-            
             return func
+
         return decorator
-    
+
     def stream_action(self, name: str, description: str = ""):
-        """
-        Decorator to register a streaming action.
-        
-        Usage:
-            @app.stream_action("live_feed", "Stream live data")
-            async def live_feed(count: int = 10):
-                for i in range(count):
-                    yield {"item": i, "timestamp": datetime.now().isoformat()}
-                    await asyncio.sleep(0.5)
-        """
         def decorator(func: Callable):
             self.stream_actions[name] = {
                 "func": func,
                 "description": description,
-                "params": self._extract_params(func)
+                "params": self._extract_params(func),
             }
-            
+
             endpoint_path = f"/stream/{name}"
-            
+
             async def stream_endpoint(request: Request):
                 try:
-                    # Get parameters
                     params = dict(request.query_params) if request.method == "GET" else {}
                     if request.method == "POST":
                         body = await request.json()
                         params.update(body)
-                    
-                    # Convert parameter types based on function signature
+
                     sig = inspect.signature(func)
-                    type_hints = get_type_hints(func) if hasattr(func, '__annotations__') else {}
+                    type_hints = get_type_hints(func) if hasattr(func, "__annotations__") else {}
                     converted_params = {}
                     for key, value in params.items():
                         if key in sig.parameters:
@@ -248,222 +209,114 @@ class KalibrApp:
                                 elif param_type == float:
                                     converted_params[key] = float(value)
                                 elif param_type == bool:
-                                    converted_params[key] = value.lower() in ('true', '1', 'yes')
+                                    converted_params[key] = value.lower() in ("true", "1", "yes")
                                 else:
                                     converted_params[key] = value
-                            except (ValueError, AttributeError):
+                            except Exception:
                                 converted_params[key] = value
-                    
-                    # Call generator function
+
                     result = func(**converted_params)
-                    
-                    # Create streaming generator
+
                     async def generate():
+                        import json
                         if inspect.isasyncgen(result):
                             async for item in result:
-                                import json
                                 yield json.dumps(item) + "\n"
                         elif inspect.isgenerator(result):
                             for item in result:
-                                import json
                                 yield json.dumps(item) + "\n"
-                    
+
                     return FastAPIStreamingResponse(generate(), media_type="application/x-ndjson")
                 except Exception as e:
                     return JSONResponse(content={"error": str(e)}, status_code=500)
-            
+
             self.app.get(endpoint_path)(stream_endpoint)
             self.app.post(endpoint_path)(stream_endpoint)
-            
-            return func
-        return decorator
-    
-    def workflow(self, name: str, description: str = ""):
-        """
-        Decorator to register a workflow.
-        
-        Usage:
-            @app.workflow("process_order", "Process customer order")
-            async def process_order(order_data: dict, workflow_state: WorkflowState):
-                workflow_state.step = "validation"
-                # ... process steps
-                return {"workflow_id": workflow_state.workflow_id}
-        """
-        def decorator(func: Callable):
-            self.workflows[name] = {
-                "func": func,
-                "description": description,
-                "params": self._extract_params(func)
-            }
-            
-            endpoint_path = f"/workflow/{name}"
-            
-            async def workflow_endpoint(request: Request):
-                try:
-                    # Get workflow ID from headers or create new
-                    workflow_id = request.headers.get("X-Workflow-ID")
-                    
-                    if not workflow_id or workflow_id not in self.workflow_states:
-                        workflow_id = str(uuid.uuid4())
-                        workflow_state = WorkflowState(
-                            workflow_id=workflow_id,
-                            step="init",
-                            status="running"
-                        )
-                        self.workflow_states[workflow_id] = workflow_state
-                    else:
-                        workflow_state = self.workflow_states[workflow_id]
-                        workflow_state.updated_at = datetime.now()
-                    
-                    # Get request data
-                    body = await request.json() if request.method == "POST" else {}
-                    
-                    # Call workflow function
-                    sig = inspect.signature(func)
-                    if 'workflow_state' in sig.parameters:
-                        func_params = {k: v for k, v in body.items() if k != 'workflow_state'}
-                        result = func(workflow_state=workflow_state, **func_params)
-                    else:
-                        result = func(**body)
-                    
-                    if inspect.isawaitable(result):
-                        result = await result
-                    
-                    # Return result with workflow ID
-                    response = JSONResponse(content=result)
-                    response.headers["X-Workflow-ID"] = workflow_id
-                    
-                    return response
-                except Exception as e:
-                    return JSONResponse(content={"error": str(e)}, status_code=500)
-            
-            self.app.post(endpoint_path)(workflow_endpoint)
-            
             return func
+
         return decorator
-    
-    def _extract_params(self, func: Callable) -> Dict:
-        """Extract parameter information from function signature."""
-        sig = inspect.signature(func)
-        params = {}
-        type_hints = get_type_hints(func) if hasattr(func, '__annotations__') else {}
-        
-        for param_name, param in sig.parameters.items():
-            # Skip special parameters
-            if param_name in ['session', 'workflow_state', 'file']:
-                continue
-            
-            param_type = "string"
-            
-            if param_name in type_hints:
-                anno = type_hints[param_name]
-            elif param.annotation != inspect.Parameter.empty:
-                anno = param.annotation
-            else:
-                anno = str
-            
-            # Map types
-            if anno == int:
-                param_type = "integer"
-            elif anno == bool:
-                param_type = "boolean"
-            elif anno == float:
-                param_type = "number"
-            elif anno == list:
-                param_type = "array"
-            elif anno == dict:
-                param_type = "object"
-            
-            is_required = param.default == inspect.Parameter.empty
-            
-            params[param_name] = {
-                "type": param_type,
-                "required": is_required
-            }
-        
-        return params
-    
+
+    # -------------------------------------------------------------------------
+    # Schema generation routes
+    # -------------------------------------------------------------------------
+
     def _setup_routes(self):
-        """Setup core API routes."""
         from kalibr.schema_generators import (
             OpenAPISchemaGenerator,
             MCPSchemaGenerator,
             GeminiSchemaGenerator,
-            CopilotSchemaGenerator
+            CopilotSchemaGenerator,
         )
-        
-        # Initialize schema generators
+
         openapi_gen = OpenAPISchemaGenerator()
         mcp_gen = MCPSchemaGenerator()
         gemini_gen = GeminiSchemaGenerator()
         copilot_gen = CopilotSchemaGenerator()
-        
+
         @self.app.get("/")
         def root():
-            """Root endpoint with API information."""
             return {
                 "message": "Kalibr Enhanced API is running",
                 "actions": list(self.actions.keys()),
-                "file_handlers": list(self.file_handlers.keys()),
-                "session_actions": list(self.session_actions.keys()),
-                "stream_actions": list(self.stream_actions.keys()),
-                "workflows": list(self.workflows.keys()),
                 "schemas": {
                     "gpt_actions": f"{self.base_url}/gpt-actions.json",
-                    "openapi_swagger": f"{self.base_url}/openapi.json",
                     "claude_mcp": f"{self.base_url}/mcp.json",
                     "gemini": f"{self.base_url}/schemas/gemini",
-                    "copilot": f"{self.base_url}/schemas/copilot"
-                }
+                    "copilot": f"{self.base_url}/schemas/copilot",
+                },
             }
-        
+
         @self.app.get("/gpt-actions.json")
         def gpt_actions_schema():
-            """Generate GPT Actions schema from all registered actions."""
-            # Combine all action types for schema generation
             all_actions = {**self.actions, **self.file_handlers, **self.session_actions}
             return openapi_gen.generate_schema(all_actions, self.base_url)
-        
+
         @self.app.get("/mcp.json")
         def mcp_manifest():
-            """Generate Claude MCP manifest."""
             all_actions = {**self.actions, **self.file_handlers, **self.session_actions}
             return mcp_gen.generate_schema(all_actions, self.base_url)
-        
+
         @self.app.get("/schemas/gemini")
         def gemini_schema():
-            """Generate Gemini Extensions schema."""
             all_actions = {**self.actions, **self.file_handlers, **self.session_actions}
             return gemini_gen.generate_schema(all_actions, self.base_url)
-        
+
         @self.app.get("/schemas/copilot")
         def copilot_schema():
-            """Generate Microsoft Copilot schema."""
             all_actions = {**self.actions, **self.file_handlers, **self.session_actions}
             return copilot_gen.generate_schema(all_actions, self.base_url)
-        
-        # Health check
+
         @self.app.get("/health")
         def health_check():
-            return {
-                "status": "healthy",
-                "service": "Kalibr Enhanced API",
-                "features": ["actions", "file_uploads", "sessions", "streaming", "workflows"]
-            }
-        
-        # Override FastAPI OpenAPI for Swagger UI
-        def custom_openapi():
-            if self.app.openapi_schema:
-                return self.app.openapi_schema
-            
-            from fastapi.openapi.utils import get_openapi
-            openapi_schema = get_openapi(
-                title=self.app.title,
-                version=self.app.version,
-                routes=self.app.routes,
-            )
-            openapi_schema["servers"] = [{"url": self.base_url}]
-            self.app.openapi_schema = openapi_schema
-            return self.app.openapi_schema
-        
-        self.app.openapi = custom_openapi
+            return {"status": "healthy", "service": "Kalibr Enhanced API"}
+
+    # -------------------------------------------------------------------------
+    # Helpers
+    # -------------------------------------------------------------------------
+
+    def _extract_params(self, func: Callable) -> Dict[str, Any]:
+        sig = inspect.signature(func)
+        params = {}
+        type_hints = get_type_hints(func) if hasattr(func, "__annotations__") else {}
+
+        for param_name, param in sig.parameters.items():
+            if param_name in ["session", "workflow_state", "file"]:
+                continue
+
+            param_type = "string"
+            anno = type_hints.get(param_name, param.annotation)
+            if anno == int:
+                param_type = "integer"
+            elif anno == bool:
+                param_type = "boolean"
+            elif anno == float:
+                param_type = "number"
+            elif anno == list:
+                param_type = "array"
+            elif anno == dict:
+                param_type = "object"
+
+            is_required = param.default == inspect.Parameter.empty
+            params[param_name] = {"type": param_type, "required": is_required}
+
+        return params

kalibr-1.0.22.dist-info/METADATA

@@ -0,0 +1,257 @@
+Metadata-Version: 2.4
+Name: kalibr
+Version: 1.0.22
+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.20.dist-info → kalibr-1.0.22.dist-info}/RECORD

@@ -2,15 +2,15 @@ kalibr/__init__.py,sha256=1IIl43EB3tAsP1anJhi63PyD9Cx-cOGYPGJ9eKbAB0s,188
 kalibr/__main__.py,sha256=Hl_-_vfimqHWZEwAUl4_OjrUWb1l7pM4q_13wbDI6gY,25584
 kalibr/deployment.py,sha256=B-2ePPCMF2UcnkM2YKkAoaNrOjpUKUGfNO0IxyNOJMI,670
 kalibr/kalibr.py,sha256=yrgXVlTgadBbpnX_l7fAxxjxGp9oxcZhzGjaQPiIcpo,10469
-kalibr/kalibr_app.py,sha256=gNQprofiDk8CUk0oxC8kwRiOt32VkoRhKc2t6cgD3IA,19307
+kalibr/kalibr_app.py,sha256=bA-YOxEq2MyXVrjPQG-b8k_66gY5Ci7hxTOtg9rZuh0,12878
 kalibr/schema_generators.py,sha256=nIgoYaO0FGC6arHdUHG0XaGDpJDycJeWDDC1-zAHzfI,7528
 kalibr/types.py,sha256=bNmf_cOWXBmhaMVAPEp3_EdRCcdXY2pbOgOxZ1dZ0Mc,3476
-kalibr-1.0.20.data/data/examples/README.md,sha256=loo2nm6yfT-pqGb5uNg1VeEdOKflYzHISUHTuSltfY0,4875
-kalibr-1.0.20.data/data/examples/basic_kalibr_example.py,sha256=Kfrh-XZuJ0vwFLB_xBpdqpgpMJw2NpIx0yBsqrAqBnE,2188
-kalibr-1.0.20.data/data/examples/enhanced_kalibr_example.py,sha256=AuhTpyRUNVAJuZKRy9iydXusNkBgQ84eKNiXxsr4iUQ,11994
-kalibr-1.0.20.dist-info/licenses/LICENSE,sha256=1WLJDkrueNpHCROy9zANrK2Ar2weqZ_z88hw90UKDoc,451
-kalibr-1.0.20.dist-info/METADATA,sha256=mKCIVFrYPVFhl2XUidHMI21O8_-L8VNVvarWmshJO8E,7965
-kalibr-1.0.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kalibr-1.0.20.dist-info/entry_points.txt,sha256=T-DOrFEZb0fZxA9H8sSCh-2zKxdjnmpzIRmm5TY_f6s,56
-kalibr-1.0.20.dist-info/top_level.txt,sha256=OkloC5_IfpE4-QwI30aLIYbFZk_-ChABWF7aBGddy28,7
-kalibr-1.0.20.dist-info/RECORD,,
+kalibr-1.0.22.data/data/examples/README.md,sha256=loo2nm6yfT-pqGb5uNg1VeEdOKflYzHISUHTuSltfY0,4875
+kalibr-1.0.22.data/data/examples/basic_kalibr_example.py,sha256=Kfrh-XZuJ0vwFLB_xBpdqpgpMJw2NpIx0yBsqrAqBnE,2188
+kalibr-1.0.22.data/data/examples/enhanced_kalibr_example.py,sha256=AuhTpyRUNVAJuZKRy9iydXusNkBgQ84eKNiXxsr4iUQ,11994
+kalibr-1.0.22.dist-info/licenses/LICENSE,sha256=1WLJDkrueNpHCROy9zANrK2Ar2weqZ_z88hw90UKDoc,451
+kalibr-1.0.22.dist-info/METADATA,sha256=nuXv558HbymTNBsuh7WircA-uV5Q3neiZ0DGM4mZCnM,6658
+kalibr-1.0.22.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kalibr-1.0.22.dist-info/entry_points.txt,sha256=T-DOrFEZb0fZxA9H8sSCh-2zKxdjnmpzIRmm5TY_f6s,56
+kalibr-1.0.22.dist-info/top_level.txt,sha256=OkloC5_IfpE4-QwI30aLIYbFZk_-ChABWF7aBGddy28,7
+kalibr-1.0.22.dist-info/RECORD,,

kalibr-1.0.20.dist-info/METADATA

@@ -1,302 +0,0 @@
-Metadata-Version: 2.4
-Name: kalibr
-Version: 1.0.20
-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 lets you expose Python functions as APIs that work with **GPT, Claude, Gemini, and Copilot** automatically.
-
-[![PyPI version](https://badge.fury.io/py/kalibr.svg)](https://badge.fury.io/py/kalibr)
-[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-
----
-
-## 🚀 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 Multi-Model Schemas
-
-Open your browser to see all 4 AI model schemas auto-generated:
-
-```
-http://localhost:8000/                    # API info
-http://localhost:8000/gpt-actions.json    # For ChatGPT
-http://localhost:8000/mcp.json            # For Claude
-http://localhost:8000/schemas/gemini      # For Gemini
-http://localhost:8000/schemas/copilot     # For Copilot
-http://localhost:8000/docs                # Interactive docs
-```
-
-**That's it!** One Python file, four AI platform schemas. 🎯
-
----
-
-## 🎯 What Does This Do?
-
-Kalibr turns your Python functions into APIs that AI assistants can call:
-
-```python
-from kalibr import Kalibr
-
-app = Kalibr(title="My Business API")
-
-@app.action("get_inventory", "Check product stock")
-def get_inventory(product_id: str):
-    # Your business logic
-    return {"product_id": product_id, "stock": 42}
-```
-
-**Result:** ChatGPT, Claude, Gemini, and Copilot can all call your `get_inventory` function!
-
----
-
-## 💪 Two Modes
-
-### Function-Level (Simple)
-Perfect for exposing business logic:
-
-```python
-from kalibr import Kalibr
-
-app = Kalibr(title="My API")
-
-@app.action("calculate_price", "Calculate product price")
-def calculate_price(product_id: str, quantity: int):
-    return {"total": quantity * get_price(product_id)}
-```
-
-### App-Level (Advanced)
-Full framework with file uploads, sessions, streaming, 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 to session")
-async def save_data(session: Session, data: dict):
-    session.set("my_data", data)
-    return {"saved": True}
-
-@app.stream_action("live_feed", "Stream real-time data")
-async def live_feed(count: int = 10):
-    for i in range(count):
-        yield {"item": i, "timestamp": "..."}
-```
-
----
-
-## 📚 Examples Included
-
-After running `kalibr-connect examples`, you get:
-
-- **`basic_kalibr_example.py`** - Simple function-level example
-- **`enhanced_kalibr_example.py`** - Advanced app-level example with all features
-
----
-
-## 🤖 AI Platform Integration
-
-Once your Kalibr app is running, integrate with AI platforms:
-
-### ChatGPT (GPT Actions)
-1. Copy schema from `http://localhost:8000/gpt-actions.json`
-2. Go to GPT Builder → Actions → Import from URL
-3. Done! ChatGPT can now call your functions
-
-### Claude (MCP)
-1. Add to Claude Desktop config:
-```json
-{
-  "mcp": {
-    "servers": {
-      "my-api": {
-        "url": "http://localhost:8000/mcp.json"
-      }
-    }
-  }
-}
-```
-2. Done! Claude can now call your functions
-
-### Gemini & Copilot
-Similar simple setup using their respective schema endpoints.
-
----
-
-## 🎯 Use Cases
-
-- **Customer Service APIs** - Let AI assistants look up orders, process refunds
-- **Data Analysis APIs** - Let AI query your analytics and generate insights
-- **Document Processing** - Let AI analyze uploaded documents
-- **Business Automation** - Let AI trigger workflows in your systems
-- **Internal Tools** - Give your team AI-powered access to internal systems
-
----
-
-## 📖 Documentation
-
-- **Quick Start**: You're reading it!
-- **Full Docs**: See `KALIBR_SDK_COMPLETE.md` in the package
-- **Examples**: Run `kalibr-connect examples`
-- **CLI Help**: `kalibr-connect --help`
-
----
-
-## 🔧 CLI Commands
-
-```bash
-kalibr-connect examples          # Copy example files to current dir
-kalibr-connect serve my_app.py   # Run your app locally
-kalibr-connect version           # Show version info
-kalibr-connect --help            # Show all commands
-```
-
----
-
-## ⚡ Key Features
-
-- ✅ **Multi-Model Support** - Works with GPT, Claude, Gemini, Copilot
-- ✅ **Automatic Schemas** - No manual schema writing
-- ✅ **File Uploads** - Handle document uploads
-- ✅ **Sessions** - Stateful conversations
-- ✅ **Streaming** - Real-time data streaming
-- ✅ **Workflows** - Multi-step processes
-- ✅ **Type Safe** - Full Python type hints
-- ✅ **Fast** - Async/await support
-
----
-
-## 🔥 Why Kalibr?
-
-**Without Kalibr:**
-- Learn 4 different API specs
-- Write 4 different schemas
-- Maintain 4 codebases
-- = Weeks of work
-
-**With Kalibr:**
-- Write Python functions once
-- Kalibr generates all 4 schemas
-- Single codebase
-- = One day of work
-
----
-
-## 💡 Simple Example
-
-```python
-# my_app.py
-from kalibr import Kalibr
-
-app = Kalibr(title="Weather API")
-
-@app.action("get_weather", "Get current weather")
-def get_weather(city: str):
-    # Your logic here
-    return {"city": city, "temp": 72, "condition": "sunny"}
-```
-
-```bash
-# Run it
-kalibr-connect serve my_app.py
-
-# Now ALL these work:
-# ✅ ChatGPT can call get_weather()
-# ✅ Claude can call get_weather()
-# ✅ Gemini can call get_weather()
-# ✅ Copilot can call get_weather()
-```
-
----
-
-## 🚀 Get Started Now
-
-```bash
-pip install kalibr
-kalibr-connect examples
-kalibr-connect serve kalibr_examples/basic_kalibr_example.py
-```
-
-Open http://localhost:8000 and see your multi-model API in action! 🎯
-
----
-
-## 📝 License
-
-MIT License - see LICENSE file for details.
-
----
-
-**Kalibr SDK** - Transform how you build AI-integrated applications! 🚀