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

kalibr/__init__.py

@@ -1,8 +1,7 @@
 """Kalibr SDK - Multi-Model AI Integration Framework"""
 
 from kalibr.kalibr import Kalibr
-# KalibrApp will be imported once it's properly implemented
-# from kalibr.kalibr_app import KalibrApp
+from kalibr.kalibr_app import KalibrApp
 
-__version__ = "1.0.18"
-__all__ = ["Kalibr"]  # "KalibrApp" will be added once implemented
+__version__ = "1.0.20"
+__all__ = ["Kalibr", "KalibrApp"]

kalibr/__main__.py

@@ -48,10 +48,7 @@ def serve(
         raise typer.Exit(1)
 
     # Import Kalibr classes
-    from kalibr import Kalibr
-    # KalibrApp import will be enabled once it's properly implemented
-    # from kalibr import KalibrApp
-    KalibrApp = None  # Placeholder until implemented
+    from kalibr import Kalibr, KalibrApp
     kalibr_instance = None
 
     # Iterate through the attributes of the loaded module
@@ -69,8 +66,14 @@ def serve(
         print(f"❌ Error: No Kalibr/KalibrApp instance found in {file}")
         raise typer.Exit(1)
 
-    # Get the FastAPI application from the Kalibr instance
-    fastapi_app = kalibr_instance.get_app()
+    # Get the FastAPI application from the Kalibr/KalibrApp instance
+    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)
 
     # Print server information
     is_enhanced = KalibrApp is not None and isinstance(kalibr_instance, KalibrApp)
@@ -589,6 +592,60 @@ def test(
         print(f"❌ Could not connect to {url}")
         print("Make sure the Kalibr server is running")
 
+@app.command()
+def examples():
+    """Copy example files to current directory."""
+    import shutil
+    from pathlib import Path
+    import sys
+    import kalibr
+    
+    # Find examples directory - check multiple possible locations
+    kalibr_path = Path(kalibr.__file__).parent
+    
+    # Location 1: Sibling to kalibr package (development install)
+    examples_src = kalibr_path.parent / "examples"
+    
+    # Location 2: In site-packages parent (wheel install with data_files)
+    if not examples_src.exists():
+        site_packages = Path(kalibr.__file__).parent.parent
+        examples_src = site_packages.parent / "examples"
+    
+    # Location 3: Check sys.prefix/examples
+    if not examples_src.exists():
+        examples_src = Path(sys.prefix) / "examples"
+    
+    if not examples_src.exists():
+        print(f"❌ Examples directory not found.")
+        print(f"   Checked locations:")
+        print(f"   - {kalibr_path.parent / 'examples'}")
+        print(f"   - {Path(kalibr.__file__).parent.parent.parent / 'examples'}")
+        print(f"   - {Path(sys.prefix) / 'examples'}")
+        print("This might happen if kalibr was installed without examples.")
+        raise typer.Exit(1)
+    
+    # Copy to current directory
+    examples_dest = Path.cwd() / "kalibr_examples"
+    
+    if examples_dest.exists():
+        print(f"⚠️  Directory 'kalibr_examples' already exists")
+        overwrite = typer.confirm("Do you want to overwrite it?")
+        if not overwrite:
+            print("Cancelled.")
+            raise typer.Exit(0)
+        shutil.rmtree(examples_dest)
+    
+    shutil.copytree(examples_src, examples_dest)
+    
+    print(f"✅ Examples copied to: {examples_dest}")
+    print(f"\n📚 Available examples:")
+    for example in examples_dest.glob("*.py"):
+        print(f"   - {example.name}")
+    
+    print(f"\n🚀 Try running:")
+    print(f"   kalibr-connect serve kalibr_examples/basic_kalibr_example.py")
+    print(f"   kalibr-connect serve kalibr_examples/enhanced_kalibr_example.py")
+
 @app.command()
 def version():
     """Show Kalibr version information."""

kalibr/kalibr.py

@@ -153,65 +153,75 @@ class Kalibr:
 
         This includes:
         - A root endpoint ("/") for basic API status and available actions.
-        - An MCP (Model Communication Protocol) manifest endpoint ("/mcp.json")
-          for AI model integrations.
-        - Customizes OpenAPI schema generation to include server URLs.
+        - Multi-model schema endpoints for all major AI platforms:
+          - /openapi.json (GPT Actions)
+          - /mcp.json (Claude MCP)
+          - /schemas/gemini (Google Gemini)
+          - /schemas/copilot (Microsoft Copilot)
         """
+        from kalibr.schema_generators import (
+            OpenAPISchemaGenerator, 
+            MCPSchemaGenerator, 
+            GeminiSchemaGenerator, 
+            CopilotSchemaGenerator
+        )
         
         @self.app.get("/")
         def root():
             """
             Root endpoint providing API status and a list of available actions.
             """
-            return {"message": "Kalibr API is running", "actions": list(self.actions.keys())}
+            return {
+                "message": "Kalibr API is running", 
+                "actions": list(self.actions.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"
+                }
+            }
+        
+        # Initialize schema generators
+        openapi_gen = OpenAPISchemaGenerator()
+        mcp_gen = MCPSchemaGenerator()
+        gemini_gen = GeminiSchemaGenerator()
+        copilot_gen = CopilotSchemaGenerator()
+        
+        @self.app.get("/gpt-actions.json")
+        def gpt_actions_schema():
+            """
+            Generates OpenAPI 3.0 schema for GPT Actions integration.
+            (Alternative endpoint since /openapi.json is used by FastAPI)
+            """
+            return openapi_gen.generate_schema(self.actions, self.base_url)
         
         @self.app.get("/mcp.json")
         def mcp_manifest():
             """
-            Generates the MCP manifest (Claude specific) for registered actions.
-
-            This manifest describes the available tools (actions) and their input schemas
-            in a format consumable by Claude.
+            Generates Claude MCP manifest for AI model integration.
             """
-            tools = []
-            for action_name, action_data in self.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"],
-                    "input_schema": {
-                        "type": "object",
-                        "properties": properties,
-                        "required": required
-                    },
-                    # The server URL points to the proxy endpoint for this action
-                    "server": {
-                        "url": f"{self.base_url}/proxy/{action_name}"
-                    }
-                })
-            
-            # Return the MCP manifest structure
-            return {
-                "mcp": "1.0",
-                "name": "kalibr",  # Name of the AI agent or toolset
-                "tools": tools
-            }
+            return mcp_gen.generate_schema(self.actions, self.base_url)
+        
+        @self.app.get("/schemas/gemini")
+        def gemini_schema():
+            """
+            Generates Google Gemini Extensions schema.
+            """
+            return gemini_gen.generate_schema(self.actions, self.base_url)
+        
+        @self.app.get("/schemas/copilot")
+        def copilot_schema():
+            """
+            Generates Microsoft Copilot plugin schema.
+            """
+            return copilot_gen.generate_schema(self.actions, self.base_url)
         
         # Override FastAPI's default OpenAPI generation to include servers configuration
         def custom_openapi():
             """
-            Customizes the OpenAPI schema generation.
-
-            Adds a 'servers' block to the OpenAPI schema, which is often required
-            by AI model integrations (e.g., OpenAI function calling).
+            Customizes the OpenAPI schema generation for Swagger UI.
             """
             if self.app.openapi_schema:
                 return self.app.openapi_schema

kalibr/kalibr_app.py

@@ -1,68 +1,322 @@
-from fastapi import FastAPI
-import importlib.util
-import json
+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
-from pydantic import BaseModel
+import asyncio
+from datetime import datetime
+import uuid
+import os
+
+from kalibr.types import FileUpload, Session, WorkflowState
+
 
 class KalibrApp:
     """
-    Minimal Kalibr SDK App that auto-generates schemas
-    for GPT Actions, Claude MCP, Gemini, etc.
+    Enhanced app-level Kalibr framework with advanced capabilities:
+    - File upload handling
+    - Session management
+    - Streaming responses
+    - Complex workflows
+    - Multi-model schema generation
     """
 
-    def __init__(self, file_path: str):
-        self.file_path = file_path
-        self.app = FastAPI(title="Kalibr App")
-        self.functions = self._load_tools()
-
-    def _load_tools(self):
-        """Dynamically import all @tool-decorated functions from the user app."""
-        spec = importlib.util.spec_from_file_location("user_app", self.file_path)
-        user_app = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(user_app)
-        funcs = {}
-
-        for name, obj in inspect.getmembers(user_app, inspect.isfunction):
-            if hasattr(obj, "_kalibr_tool"):
-                funcs[name] = obj
-                self._register_route(name, obj)
-
-        return funcs
-
-    def _register_route(self, name, func):
-        """Register each tool as a POST endpoint."""
-        class RequestSchema(BaseModel):
-            __annotations__ = {k: v for k, v in func.__annotations__.items() if k != "return"}
-
-        async def route(payload: RequestSchema):
-            result = func(**payload.dict())
-            return {"result": result}
-
-        self.app.post(f"/tools/{name}")(route)
-
-    def generate_schemas(self):
-        """Generate model-specific schemas for GPT Actions, Claude MCP, Gemini."""
-        schemas = {}
-        for name, func in self.functions.items():
-            sig = inspect.signature(func)
-            params = {
-                k: str(v.annotation) for k, v in sig.parameters.items()
+    def __init__(self, title="Kalibr Enhanced API", version="2.0.0", base_url: Optional[str] = None):
+        """
+        Initialize the Kalibr enhanced app.
+        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)
+
+        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: 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] = {}
+        self.workflow_states: Dict[str, WorkflowState] = {}
+
+        self._setup_routes()
+
+    # -------------------------------------------------------------------------
+    # Action registration decorators
+    # -------------------------------------------------------------------------
+
+    def action(self, name: str, description: str = ""):
+        def decorator(func: Callable):
+            self.actions[name] = {
+                "func": func,
+                "description": description,
+                "params": self._extract_params(func),
             }
-            schemas[name] = {
-                "description": func.__doc__ or "",
-                "parameters": params,
-                "returns": str(sig.return_annotation),
+
+            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 Exception:
+                        params = {}
+                else:
+                    params = dict(request.query_params)
+
+                try:
+                    result = func(**params)
+                    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)(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 = ""):
+        def decorator(func: Callable):
+            self.file_handlers[name] = {
+                "func": func,
+                "description": description,
+                "allowed_extensions": allowed_extensions or [],
+                "params": self._extract_params(func),
             }
-        return {
-            "gpt_actions": schemas,
-            "claude_mcp": schemas,
-            "gemini_tools": schemas,
-        }
-
-def serve_app(file_path: str):
-    """Run the Kalibr app locally."""
-    from uvicorn import run
-    app_instance = KalibrApp(file_path)
-    print("✅ Generated Schemas:")
-    print(json.dumps(app_instance.generate_schemas(), indent=2))
-    run(app_instance.app, host="127.0.0.1", port=8000)
+
+            endpoint_path = f"/files/{name}"
+
+            async def file_endpoint(file: UploadFile = File(...)):
+                try:
+                    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,
+                            )
+
+                    content = await file.read()
+                    file_upload = FileUpload(
+                        filename=file.filename,
+                        content_type=file.content_type or "application/octet-stream",
+                        size=len(content),
+                        content=content,
+                    )
+
+                    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 = ""):
+        def decorator(func: Callable):
+            self.session_actions[name] = {
+                "func": func,
+                "description": description,
+                "params": self._extract_params(func),
+            }
+
+            endpoint_path = f"/session/{name}"
+
+            async def session_endpoint(request: Request):
+                try:
+                    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)
+                        self.sessions[session_id] = session
+                    else:
+                        session = self.sessions[session_id]
+                        session.last_accessed = datetime.now()
+
+                    body = await request.json() if request.method == "POST" else {}
+
+                    sig = inspect.signature(func)
+                    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
+
+                    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 = ""):
+        def decorator(func: Callable):
+            self.stream_actions[name] = {
+                "func": func,
+                "description": description,
+                "params": self._extract_params(func),
+            }
+
+            endpoint_path = f"/stream/{name}"
+
+            async def stream_endpoint(request: Request):
+                try:
+                    params = dict(request.query_params) if request.method == "GET" else {}
+                    if request.method == "POST":
+                        body = await request.json()
+                        params.update(body)
+
+                    sig = inspect.signature(func)
+                    type_hints = get_type_hints(func) if hasattr(func, "__annotations__") else {}
+                    converted_params = {}
+                    for key, value in params.items():
+                        if key in sig.parameters:
+                            param_type = type_hints.get(key, str)
+                            try:
+                                if param_type == int:
+                                    converted_params[key] = int(value)
+                                elif param_type == float:
+                                    converted_params[key] = float(value)
+                                elif param_type == bool:
+                                    converted_params[key] = value.lower() in ("true", "1", "yes")
+                                else:
+                                    converted_params[key] = value
+                            except Exception:
+                                converted_params[key] = value
+
+                    result = func(**converted_params)
+
+                    async def generate():
+                        import json
+                        if inspect.isasyncgen(result):
+                            async for item in result:
+                                yield json.dumps(item) + "\n"
+                        elif inspect.isgenerator(result):
+                            for item in result:
+                                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
+
+    # -------------------------------------------------------------------------
+    # Schema generation routes
+    # -------------------------------------------------------------------------
+
+    def _setup_routes(self):
+        from kalibr.schema_generators import (
+            OpenAPISchemaGenerator,
+            MCPSchemaGenerator,
+            GeminiSchemaGenerator,
+            CopilotSchemaGenerator,
+        )
+
+        openapi_gen = OpenAPISchemaGenerator()
+        mcp_gen = MCPSchemaGenerator()
+        gemini_gen = GeminiSchemaGenerator()
+        copilot_gen = CopilotSchemaGenerator()
+
+        @self.app.get("/")
+        def root():
+            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",
+                },
+            }
+
+        @self.app.get("/gpt-actions.json")
+        def gpt_actions_schema():
+            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():
+            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():
+            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():
+            all_actions = {**self.actions, **self.file_handlers, **self.session_actions}
+            return copilot_gen.generate_schema(all_actions, self.base_url)
+
+        @self.app.get("/health")
+        def health_check():
+            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