kalibr 1.0.22__tar.gz → 1.0.23__tar.gz

{kalibr-1.0.22/kalibr.egg-info → kalibr-1.0.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kalibr
-Version: 1.0.22
+Version: 1.0.23
 Summary: Multi-Model AI Integration Framework
 Home-page: https://github.com/devonakelley/kalibr-sdk
 Author: Kalibr Team

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}

{kalibr-1.0.22 → kalibr-1.0.23}/kalibr/kalibr_app.py

@@ -9,7 +9,6 @@ import os
 
 from kalibr.types import FileUpload, Session, WorkflowState
 
-
 class KalibrApp:
     """
     Enhanced app-level Kalibr framework with advanced capabilities:
@@ -20,7 +19,7 @@ class KalibrApp:
     - Multi-model schema generation
     """
 
-    def __init__(self, title="Kalibr Enhanced API", version="2.0.0", base_url: Optional[str] = None):
+    def __init__(self, title="Kalibr Enhanced API", version="2.0.0", base_url: Optional[str] = None, models: Optional[List[str]] = None):
         """
         Initialize the Kalibr enhanced app.
         Automatically determines correct base URL for deployed environments.
@@ -30,6 +29,9 @@ class KalibrApp:
         2. Env var `KALIBR_BASE_URL`
         3. Env var `FLY_APP_NAME` -> https://<fly_app_name>.fly.dev
         4. Default localhost for dev
+
+        `models`: optional list like ["mcp"] or ["mcp","gpt-actions","gemini","copilot"]
+                  controls which schema endpoints are advertised.
         """
         self.app = FastAPI(title=title, version=version)
 
@@ -42,6 +44,8 @@ class KalibrApp:
         else:
             self.base_url = "http://localhost:8000"
 
+        self.models_supported = models or ["mcp", "gpt-actions", "gemini", "copilot"]
+
         # Storage for different action types
         self.actions: Dict[str, Any] = {}
         self.file_handlers: Dict[str, Any] = {}
@@ -221,10 +225,10 @@ class KalibrApp:
                         import json
                         if inspect.isasyncgen(result):
                             async for item in result:
-                                yield json.dumps(item) + "\n"
+                                yield json.dumps(item) + "\\n"
                         elif inspect.isgenerator(result):
                             for item in result:
-                                yield json.dumps(item) + "\n"
+                                yield json.dumps(item) + "\\n"
 
                     return FastAPIStreamingResponse(generate(), media_type="application/x-ndjson")
                 except Exception as e:
@@ -255,17 +259,25 @@ class KalibrApp:
 
         @self.app.get("/")
         def root():
+            schemas = {}
+            if "gpt-actions" in self.models_supported:
+                schemas["gpt_actions"] = f"{self.base_url}/gpt-actions.json"
+            schemas["claude_mcp"] = f"{self.base_url}/mcp.json"  # MCP is the default lingua franca
+            if "gemini" in self.models_supported:
+                schemas["gemini"] = f"{self.base_url}/schemas/gemini"
+            if "copilot" in self.models_supported:
+                schemas["copilot"] = f"{self.base_url}/schemas/copilot"
+
             return {
                 "message": "Kalibr Enhanced API is running",
                 "actions": list(self.actions.keys()),
-                "schemas": {
-                    "gpt_actions": f"{self.base_url}/gpt-actions.json",
-                    "claude_mcp": f"{self.base_url}/mcp.json",
-                    "gemini": f"{self.base_url}/schemas/gemini",
-                    "copilot": f"{self.base_url}/schemas/copilot",
-                },
+                "schemas": schemas,
             }
 
+        @self.app.get("/models/supported")
+        def supported_models():
+            return {"models": self.models_supported}
+
         @self.app.get("/gpt-actions.json")
         def gpt_actions_schema():
             all_actions = {**self.actions, **self.file_handlers, **self.session_actions}
@@ -288,7 +300,16 @@ class KalibrApp:
 
         @self.app.get("/health")
         def health_check():
-            return {"status": "healthy", "service": "Kalibr Enhanced API"}
+            return {
+                "status": "healthy",
+                "service": "Kalibr Enhanced API",
+                "version": self.app.version,
+                "features": {
+                    "file_handlers": bool(self.file_handlers),
+                    "sessions": True,
+                    "streams": bool(self.stream_actions),
+                },
+            }
 
     # -------------------------------------------------------------------------
     # Helpers

kalibr-1.0.23/kalibr/packager.py

@@ -0,0 +1,43 @@
+"""
+Packager
+--------
+Create a deployable MCP bundle (code + manifests + metadata).
+This does not host anything; it prepares artifacts for any runtime.
+"""
+
+from __future__ import annotations
+from pathlib import Path
+import shutil
+import json
+import tempfile
+from typing import Dict, Any, Optional
+
+DEFAULT_BUNDLE = "kalibr_bundle.zip"
+
+def package_app(app_dir: str = ".", output: str = DEFAULT_BUNDLE, models_supported: Optional[list] = None, kalibr_version: str = "unknown") -> str:
+    app_dir = Path(app_dir).resolve()
+    out_path = Path(output).resolve()
+
+    # Assemble temp dir with metadata
+    with tempfile.TemporaryDirectory() as tmp:
+        tmpdir = Path(tmp)
+        # Copy source tree
+        for item in app_dir.iterdir():
+            if item.name == out_path.name:
+                continue
+            dest = tmpdir / item.name
+            if item.is_dir():
+                shutil.copytree(item, dest)
+            else:
+                shutil.copy2(item, dest)
+
+        # Write bundle metadata
+        (tmpdir / "kalibr_manifest.json").write_text(json.dumps({
+            "kalibr_version": kalibr_version,
+            "models_supported": models_supported or ["mcp", "gpt-actions", "gemini", "copilot"],
+        }, indent=2))
+
+        # Zip
+        shutil.make_archive(out_path.with_suffix(""), "zip", tmpdir)
+
+    return str(out_path)

kalibr-1.0.23/kalibr/runtime_router.py

@@ -0,0 +1,138 @@
+"""
+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}")
+