kalibr 1.0.21__py3-none-any.whl → 1.0.23__py3-none-any.whl

kalibr/deployment.py

@@ -1,26 +1,41 @@
 """
-Kalibr Deployment Stub
------------------------
-This module provides a lightweight interface for future deployment providers.
-
-Current supported strategy:
-- Local (via Uvicorn)
-
-Planned:
-- Fly.io
-- Render
-- Railway
-
-No AWS dependencies are required or used.
+Kalibr Deployment
+-----------------
+Thin wrapper that forwards to the runtime router.
+Keeps a simple API surface for backwards-compat commands.
 """
 
-import subprocess
+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_local(file_path: str):
-    """Serve the Kalibr app locally using Uvicorn."""
-    subprocess.run(["uvicorn", f"{file_path}:app", "--reload"], check=False)
+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)
 
-def deploy_placeholder(file_path: str):
-    """Placeholder for future remote deployment support."""
-    print(f"🚀 Deployment placeholder: {file_path}")
-    print("Coming soon: Fly.io and Render deployment support.")
+    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/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/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/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}")
+

kalibr/schema_generators.py

@@ -4,29 +4,27 @@ 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]:
-        """Generate schema for the specific AI model"""
         pass
 
 class MCPSchemaGenerator(BaseSchemaGenerator):
-    """Claude MCP schema generator"""
-    
+    """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 = []
-            
-            # Construct the input schema for the tool
             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"],
@@ -35,32 +33,25 @@ class MCPSchemaGenerator(BaseSchemaGenerator):
                     "properties": properties,
                     "required": required
                 },
-                "server": {
-                    "url": f"{base_url}/proxy/{action_name}"
-                }
+                "server": {"url": f"{base_url}/proxy/{action_name}"}
             })
-        
         return {
-            "mcp": "1.0",
+            "mcp": MCP_SPEC_VERSION,
             "name": "kalibr-enhanced",
             "tools": tools
         }
 
 class OpenAPISchemaGenerator(BaseSchemaGenerator):
-    """GPT Actions OpenAPI schema generator"""
-    
+    """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"],
@@ -80,57 +71,34 @@ class OpenAPISchemaGenerator(BaseSchemaGenerator):
                     "responses": {
                         "200": {
                             "description": "Successful response",
-                            "content": {
-                                "application/json": {
-                                    "schema": {"type": "object"}
-                                }
-                            }
+                            "content": {"application/json": {"schema": {"type": "object"}}}
                         }
                     }
                 }
             }
-        
         return {
             "openapi": "3.0.0",
-            "info": {
-                "title": "Kalibr Enhanced API",
-                "version": "2.0.0",
-                "description": "Enhanced Kalibr API with app-level capabilities"
-            },
+            "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": []
-            }
-            
+            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}"
-                }
+                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}"
-                }
+                "server": {"url": f"{base_url}/proxy/{action_name}"}
             })
-        
         return {
             "gemini_extension": "1.0",
             "name": "kalibr_enhanced",
@@ -139,66 +107,45 @@ class GeminiSchemaGenerator(BaseSchemaGenerator):
         }
 
 class CopilotSchemaGenerator(BaseSchemaGenerator):
-    """Microsoft Copilot plugin schema generator"""
-    
+    """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": []
-            }
-            
+            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"]
-                }
+                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"
-                }
+                "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"
-            },
+            "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]:
-        # Generic schema format that can be customized
         return {
             "model": self.model_name,
             "format": self.schema_format,
-            "version": "2.0.0",
+            "version": KALIBR_VERSION,
             "base_url": base_url,
             "actions": [
                 {
@@ -209,4 +156,4 @@ class CustomModelSchemaGenerator(BaseSchemaGenerator):
                 }
                 for name, data in actions.items()
             ]
-        }
+        }

kalibr/validator.py

@@ -0,0 +1,70 @@
+"""
+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.")
+