kalibr 1.0.28__py3-none-any.whl → 1.1.3a0__py3-none-any.whl

kalibr/runtime_router.py

@@ -1,138 +0,0 @@
-"""
-Runtime Router
---------------
-Abstraction over deployment targets without hosting them ourselves.
-Generates minimal configs and invokes the target's CLI/API where possible.
-
-Supported:
-- local (uvicorn)
-- fly (fly.io)   -> generates fly.toml and basic Dockerfile
-- render         -> generates render.yaml
-
-Note: We do not ship vendor SDKs. We shell out to their CLIs if present.
-"""
-
-from __future__ import annotations
-from pathlib import Path
-import subprocess
-import shutil
-import os
-import json
-from typing import Dict, Any, Optional, Tuple
-
-HERE = Path(__file__).parent
-
-def which(cmd: str) -> Optional[str]:
-    return shutil.which(cmd)
-
-def ensure_file(path: Path, content: str):
-    path.parent.mkdir(parents=True, exist_ok=True)
-    if not path.exists():
-        path.write_text(content)
-
-def generate_fly_files(app_name: str) -> Tuple[Path, Path]:
-    fly_toml = Path("fly.toml")
-    dockerfile = Path("Dockerfile")
-    ensure_file(fly_toml, f"""# fly.toml
-app = "{app_name}"
-primary_region = "iad"
-
-[build]
-  dockerfile = "Dockerfile"
-
-[http_service]
-  internal_port = 8000
-  force_https = true
-  auto_stop_machines = "off"
-  auto_start_machines = true
-  min_machines_running = 1
-""")
-    ensure_file(dockerfile, """# Dockerfile
-FROM python:3.11-slim
-WORKDIR /app
-COPY . /app
-RUN pip install --no-cache-dir -U pip && \
-    pip install --no-cache-dir fastapi uvicorn typer pydantic requests
-EXPOSE 8000
-CMD ["python", "-m", "kalibr", "serve", "kalibr_app.py", "--host", "0.0.0.0", "--port", "8000", "--base-url", "http://0.0.0.0:8000"]
-""")
-    return fly_toml, dockerfile
-
-def generate_render_file(service_name: str) -> Path:
-    render_yaml = Path("render.yaml")
-    ensure_file(render_yaml, f"""# render.yaml
-services:
-  - type: web
-    name: {service_name}
-    env: docker
-    plan: free
-    dockerfilePath: ./Dockerfile
-    autoDeploy: true
-""")
-    return render_yaml
-
-def deploy_local(app_file: str, host: str = "0.0.0.0", port: int = 8000, base_url: str = "http://localhost:8000") -> Dict[str, Any]:
-    # Run uvicorn inline (non-blocking not handled here - CLI uses this to print guidance)
-    cmd = ["python", "-m", "kalibr", "serve", app_file, "--host", host, "--port", str(port), "--base-url", base_url]
-    print("▶︎", " ".join(cmd))
-    subprocess.run(cmd, check=False)
-    return {
-        "status": "started",
-        "endpoints": {
-            "root": f"{base_url}/",
-            "mcp": f"{base_url}/mcp.json",
-            "openapi": f"{base_url}/openapi.json",
-            "health": f"{base_url}/health"
-        }
-    }
-
-def deploy_fly(app_name: str) -> Dict[str, Any]:
-    if not which("flyctl"):
-        raise RuntimeError("flyctl is not installed. See https://fly.io/docs/flyctl/install/")
-    # Ensure files exist
-    generate_fly_files(app_name)
-    # Launch or deploy
-    print("▶︎ flyctl apps list")
-    subprocess.run(["flyctl", "apps", "list"], check=False)
-    print(f"▶︎ flyctl deploy --app {app_name}")
-    subprocess.run(["flyctl", "deploy", "--app", app_name], check=False)
-    url = f"https://{app_name}.fly.dev"
-    return {
-        "status": "success",
-        "endpoints": {
-            "root": f"{url}/",
-            "mcp": f"{url}/mcp.json",
-            "openapi": f"{url}/openapi.json",
-            "health": f"{url}/health"
-        }
-    }
-
-def deploy_render(service_name: str) -> Dict[str, Any]:
-    # We just generate render.yaml and Dockerfile. User connects repo in Render UI.
-    generate_render_file(service_name)
-    ensure_file(Path("Dockerfile"), """# Dockerfile for Render
-FROM python:3.11-slim
-WORKDIR /app
-COPY . /app
-RUN pip install --no-cache-dir -U pip && \
-    pip install --no-cache-dir fastapi uvicorn typer pydantic requests
-EXPOSE 8000
-CMD ["python", "-m", "kalibr", "serve", "kalibr_app.py", "--host", "0.0.0.0", "--port", "8000", "--base-url", "https://$RENDER_EXTERNAL_URL"]
-""")
-    print("📄 Generated render.yaml and Dockerfile. Connect your repo in Render.com and auto-deploy.")
-    return {
-        "status": "success",
-        "endpoints": {},
-        "note": "Connect this repository to Render; it will build from render.yaml."
-    }
-
-def deploy(runtime: str, app_name: str, app_file: str, host: str = "0.0.0.0", port: int = 8000, base_url: str = "http://localhost:8000") -> Dict[str, Any]:
-    runtime = runtime.lower()
-    if runtime in ("local", "dev"):
-        return deploy_local(app_file, host, port, base_url)
-    if runtime in ("fly", "flyio"):
-        return deploy_fly(app_name)
-    if runtime == "render":
-        return deploy_render(app_name)
-    raise ValueError(f"Unknown runtime: {runtime}")
-

kalibr/schema_generators.py

@@ -1,159 +0,0 @@
-"""
-Multi-model schema generators for different AI platforms
-"""
-from typing import Dict, Any, List
-from abc import ABC, abstractmethod
-
-KALIBR_TITLE = "Kalibr Enhanced API"
-KALIBR_VERSION = "2.0.0"
-MCP_SPEC_VERSION = "1.0"  # bump via validator when MCP evolves
-
-class BaseSchemaGenerator(ABC):
-    """Base class for AI model schema generators"""
-    @abstractmethod
-    def generate_schema(self, actions: Dict, base_url: str) -> Dict[str, Any]:
-        pass
-
-class MCPSchemaGenerator(BaseSchemaGenerator):
-    """Claude/GPT-AgentBuilder MCP schema generator"""
-    def generate_schema(self, actions: Dict, base_url: str) -> Dict[str, Any]:
-        tools = []
-        for action_name, action_data in actions.items():
-            properties = {}
-            required = []
-            for param_name, param_info in action_data["params"].items():
-                properties[param_name] = {"type": param_info["type"]}
-                if param_info["required"]:
-                    required.append(param_name)
-            tools.append({
-                "name": action_name,
-                "description": action_data["description"],
-                "input_schema": {
-                    "type": "object",
-                    "properties": properties,
-                    "required": required
-                },
-                "server": {"url": f"{base_url}/proxy/{action_name}"}
-            })
-        return {
-            "mcp": MCP_SPEC_VERSION,
-            "name": "kalibr-enhanced",
-            "tools": tools
-        }
-
-class OpenAPISchemaGenerator(BaseSchemaGenerator):
-    """GPT Actions OpenAPI schema generator (legacy but still useful)"""
-    def generate_schema(self, actions: Dict, base_url: str) -> Dict[str, Any]:
-        paths = {}
-        for action_name, action_data in actions.items():
-            properties = {}
-            required = []
-            for param_name, param_info in action_data["params"].items():
-                properties[param_name] = {"type": param_info["type"]}
-                if param_info["required"]:
-                    required.append(param_name)
-            paths[f"/proxy/{action_name}"] = {
-                "post": {
-                    "summary": action_data["description"],
-                    "operationId": action_name,
-                    "requestBody": {
-                        "required": True,
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "type": "object",
-                                    "properties": properties,
-                                    "required": required
-                                }
-                            }
-                        }
-                    },
-                    "responses": {
-                        "200": {
-                            "description": "Successful response",
-                            "content": {"application/json": {"schema": {"type": "object"}}}
-                        }
-                    }
-                }
-            }
-        return {
-            "openapi": "3.0.0",
-            "info": {"title": KALIBR_TITLE, "version": KALIBR_VERSION, "description": "Enhanced Kalibr API"},
-            "servers": [{"url": base_url}],
-            "paths": paths
-        }
-
-class GeminiSchemaGenerator(BaseSchemaGenerator):
-    """Google Gemini Extensions schema generator"""
-    def generate_schema(self, actions: Dict, base_url: str) -> Dict[str, Any]:
-        functions = []
-        for action_name, action_data in actions.items():
-            parameters = {"type": "object", "properties": {}, "required": []}
-            for param_name, param_info in action_data["params"].items():
-                parameters["properties"][param_name] = {"type": param_info["type"], "description": f"Parameter {param_name}"}
-                if param_info["required"]:
-                    parameters["required"].append(param_name)
-            functions.append({
-                "name": action_name,
-                "description": action_data["description"],
-                "parameters": parameters,
-                "server": {"url": f"{base_url}/proxy/{action_name}"}
-            })
-        return {
-            "gemini_extension": "1.0",
-            "name": "kalibr_enhanced",
-            "description": "Enhanced Kalibr API for Gemini integration",
-            "functions": functions
-        }
-
-class CopilotSchemaGenerator(BaseSchemaGenerator):
-    """Microsoft Copilot plugin schema generator (transitional)"""
-    def generate_schema(self, actions: Dict, base_url: str) -> Dict[str, Any]:
-        apis = []
-        for action_name, action_data in actions.items():
-            request_schema = {"type": "object", "properties": {}, "required": []}
-            for param_name, param_info in action_data["params"].items():
-                request_schema["properties"][param_name] = {"type": param_info["type"]}
-                if param_info["required"]:
-                    request_schema["required"].append(param_name)
-            apis.append({
-                "name": action_name,
-                "description": action_data["description"],
-                "url": f"{base_url}/proxy/{action_name}",
-                "method": "POST",
-                "request_schema": request_schema,
-                "response_schema": {"type": "object", "description": "API response"}
-            })
-        return {
-            "schema_version": "v1",
-            "name_for_model": "kalibr_enhanced",
-            "name_for_human": "Enhanced Kalibr API",
-            "description_for_model": "Enhanced Kalibr API with advanced capabilities",
-            "description_for_human": "API for advanced AI model integrations",
-            "auth": {"type": "none"},
-            "api": {"type": "openapi", "url": f"{base_url}/openapi.json"},
-            "apis": apis
-        }
-
-class CustomModelSchemaGenerator(BaseSchemaGenerator):
-    """Extensible generator for future AI models"""
-    def __init__(self, model_name: str, schema_format: str):
-        self.model_name = model_name
-        self.schema_format = schema_format
-    
-    def generate_schema(self, actions: Dict, base_url: str) -> Dict[str, Any]:
-        return {
-            "model": self.model_name,
-            "format": self.schema_format,
-            "version": KALIBR_VERSION,
-            "base_url": base_url,
-            "actions": [
-                {
-                    "name": name,
-                    "description": data["description"],
-                    "parameters": data["params"],
-                    "endpoint": f"{base_url}/proxy/{name}"
-                }
-                for name, data in actions.items()
-            ]
-        }

kalibr/validator.py

@@ -1,70 +0,0 @@
-"""
-Validator
----------
-- Validates MCP manifest structure (lightweight JSONSchema)
-- Detects spec drift (compares manifest version vs. embedded known latest)
-- Provides 'update-schemas' hook (stub here; can fetch from GH in future)
-
-Note: We keep it offline-safe. You can later wire network fetch if desired.
-"""
-
-from __future__ import annotations
-from typing import Dict, Any
-import json
-from jsonschema import validate, Draft7Validator
-
-# Minimal MCP JSON schema (aligned with your generator shape)
-MCP_SCHEMA = {
-  "type": "object",
-  "required": ["mcp", "name", "tools"],
-  "properties": {
-    "mcp": {"type": "string"},
-    "name": {"type": "string"},
-    "tools": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "required": ["name", "description", "input_schema", "server"],
-        "properties": {
-          "name": {"type": "string"},
-          "description": {"type": "string"},
-          "input_schema": {
-            "type": "object",
-            "required": ["type", "properties"],
-            "properties": {
-              "type": {"type": "string"},
-              "properties": {"type": "object"},
-              "required": {"type": "array", "items": {"type": "string"}}
-            }
-          },
-          "server": {
-            "type": "object",
-            "required": ["url"],
-            "properties": {"url": {"type": "string"}}
-          }
-        }
-      }
-    }
-  }
-}
-
-LATEST_MCP_SPEC_VERSION = "1.0"  # bump here as spec evolves
-
-def validate_mcp_manifest(manifest: Dict[str, Any]) -> None:
-    # Structural validation
-    validate(instance=manifest, schema=MCP_SCHEMA)
-    # Version guidance
-    version = str(manifest.get("mcp", ""))
-    if version != LATEST_MCP_SPEC_VERSION:
-        print(f"⚠️  MCP spec version in manifest is '{version}'. Latest known is '{LATEST_MCP_SPEC_VERSION}'.")
-        print("    Run `kalibr update-schemas` after updating the SDK, or regenerate the manifest.")
-
-def update_schemas() -> None:
-    """
-    Stub: In a connected environment, fetch updated schema templates.
-    Here, we simply print guidance so the CLI can expose the command now.
-    """
-    print("🔄 Update schemas (stub):")
-    print("   - Upgrade kalibr SDK to latest version: pip install -U kalibr")
-    print("   - Re-run manifest generation to pick up spec changes.")
-

kalibr-1.0.28.data/data/examples/README.md

@@ -1,173 +0,0 @@
-# Enhanced Kalibr SDK Examples
-
-This directory contains examples demonstrating both the original function-level Kalibr capabilities and the new enhanced app-level features.
-
-## Examples Included
-
-### 1. Basic Kalibr Example (`basic_kalibr_example.py`)
-Demonstrates the original Kalibr SDK capabilities:
-- Simple function decoration with `@sdk.action()`
-- Basic parameter handling and type inference
-- Compatible with GPT Actions and Claude MCP
-- Simple API endpoints
-
-**Features shown:**
-- Text processing functions
-- Mathematical calculations  
-- Email validation
-- Text statistics
-
-**To run:**
-```bash
-kalibr serve basic_kalibr_example.py
-```
-
-**Test endpoints:**
-- `POST /proxy/greet` - Greeting function
-- `POST /proxy/calculate` - Basic calculator
-- `POST /proxy/validate_email` - Email validation
-- `POST /proxy/text_stats` - Text analysis
-
-### 2. Enhanced Kalibr Example (`enhanced_kalibr_example.py`)
-Demonstrates the new enhanced app-level capabilities:
-- File upload handling
-- Session management
-- Streaming responses
-- Complex workflows
-- Multi-model schema generation
-
-**Features shown:**
-- File upload and analysis
-- Session-based note taking
-- Real-time streaming data
-- Multi-step workflows
-- Advanced parameter handling
-
-**To run:**
-```bash
-kalibr serve enhanced_kalibr_example.py --app-mode
-```
-
-**Test endpoints:**
-- `POST /upload/analyze_document` - File upload analysis
-- `POST /session/save_note` - Session-based note saving
-- `GET /stream/count_with_progress` - Streaming counter
-- `POST /workflow/process_text_analysis` - Complex text workflow
-
-## Multi-Model Integration
-
-Both examples automatically generate schemas for multiple AI models:
-
-### Available Schema Endpoints:
-- **Claude MCP**: `/mcp.json`
-- **GPT Actions**: `/openapi.json` 
-- **Gemini Extensions**: `/schemas/gemini`
-- **Microsoft Copilot**: `/schemas/copilot`
-
-### Management Endpoints:
-- **Health Check**: `/health`
-- **Supported Models**: `/models/supported`
-- **API Documentation**: `/docs`
-
-## Usage Examples
-
-### Basic Function Call:
-```bash
-curl -X POST http://localhost:8000/proxy/greet \
-  -H "Content-Type: application/json" \
-  -d '{"name": "Alice", "greeting": "Hi"}'
-```
-
-### File Upload:
-```bash
-curl -X POST http://localhost:8000/upload/analyze_document \
-  -F "file=@example.txt"
-```
-
-### Session Management:
-```bash
-# Save a note (creates session)
-curl -X POST http://localhost:8000/session/save_note \
-  -H "Content-Type: application/json" \
-  -d '{"note_title": "My Note", "note_content": "This is a test note"}'
-
-# Get notes (use session ID from previous response)
-curl -X POST http://localhost:8000/session/get_notes \
-  -H "Content-Type: application/json" \
-  -H "x-session-id: <session-id-here>" \
-  -d '{}'
-```
-
-### Streaming Data:
-```bash
-curl http://localhost:8000/stream/count_with_progress?max_count=5&delay_seconds=1
-```
-
-### Complex Workflow:
-```bash
-curl -X POST http://localhost:8000/workflow/process_text_analysis \
-  -H "Content-Type: application/json" \
-  -d '{"text": "This is a sample text for analysis. It contains multiple sentences and words for testing the workflow capabilities."}'
-```
-
-## Integration with AI Models
-
-### GPT Actions Setup:
-1. Copy the OpenAPI schema from `/openapi.json`
-2. Create a new GPT Action in ChatGPT
-3. Paste the schema and set the base URL
-
-### Claude MCP Setup:
-1. Add the MCP server configuration:
-```json
-{
-  "mcp": {
-    "servers": {
-      "kalibr": {
-        "command": "curl",
-        "args": ["http://localhost:8000/mcp.json"]
-      }
-    }
-  }
-}
-```
-
-### Gemini Extensions:
-1. Use the schema from `/schemas/gemini`
-2. Configure according to Gemini's extension documentation
-
-### Microsoft Copilot:
-1. Use the schema from `/schemas/copilot`  
-2. Follow Microsoft's plugin development guidelines
-
-## Advanced Features
-
-### Authentication (Optional):
-Uncomment the authentication line in enhanced example:
-```python
-app.enable_auth("your-secret-jwt-key-here")
-```
-
-### Custom Schema Generation:
-The framework supports extensible schema generation for future AI models through the `CustomModelSchemaGenerator` class.
-
-### Error Handling:
-All endpoints include comprehensive error handling with meaningful error messages.
-
-### Type Safety:
-Full support for Python type hints with automatic schema generation.
-
-## Development Notes
-
-- The enhanced framework is backward compatible with original Kalibr apps
-- Session data is stored in memory (use external storage for production)
-- File uploads are handled in memory (implement persistent storage as needed)
-- Streaming uses Server-Sent Events (SSE) format
-- All examples include proper async/await handling where needed
-
-## Next Steps
-
-1. Try the examples with different AI models
-2. Modify the examples to fit your specific use case
-3. Explore the source code in `/app/backend/kalibr/` for advanced customization
-4. Build your own enhanced Kalibr applications!

kalibr-1.0.28.data/data/examples/basic_kalibr_example.py

@@ -1,66 +0,0 @@
-"""
-Basic Kalibr SDK Example - Function-level API integration
-This demonstrates the original function-level capabilities of Kalibr.
-"""
-
-from kalibr import Kalibr
-
-# Create a basic Kalibr instance
-sdk = Kalibr(title="Basic Kalibr Demo", base_url="http://localhost:8000")
-
-@sdk.action("greet", "Greet someone with a personalized message")
-def greet_user(name: str, greeting: str = "Hello"):
-    """Simple greeting function"""
-    return {"message": f"{greeting}, {name}! Welcome to Kalibr SDK."}
-
-@sdk.action("calculate", "Perform basic mathematical operations")
-def calculate(operation: str, a: float, b: float):
-    """Basic calculator functionality"""
-    operations = {
-        "add": a + b,
-        "subtract": a - b,
-        "multiply": a * b,
-        "divide": a / b if b != 0 else None
-    }
-    
-    result = operations.get(operation)
-    if result is None:
-        return {"error": f"Invalid operation '{operation}' or division by zero"}
-    
-    return {
-        "operation": operation,
-        "operands": [a, b],
-        "result": result
-    }
-
-@sdk.action("validate_email", "Check if an email address is valid")
-def validate_email(email: str):
-    """Simple email validation"""
-    import re
-    
-    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
-    is_valid = bool(re.match(pattern, email))
-    
-    return {
-        "email": email,
-        "is_valid": is_valid,
-        "message": "Valid email address" if is_valid else "Invalid email format"
-    }
-
-@sdk.action("text_stats", "Get statistics about a text string")
-def text_statistics(text: str):
-    """Analyze text and return statistics"""
-    words = text.split()
-    sentences = text.split('.') + text.split('!') + text.split('?')
-    sentences = [s.strip() for s in sentences if s.strip()]
-    
-    return {
-        "character_count": len(text),
-        "word_count": len(words),
-        "sentence_count": len(sentences),
-        "average_word_length": sum(len(word) for word in words) / len(words) if words else 0,
-        "longest_word": max(words, key=len) if words else None
-    }
-
-# The SDK instance is automatically discovered by the Kalibr CLI
-# To run this: kalibr serve basic_kalibr_example.py