kalibr 1.0.18__py3-none-any.whl → 1.0.20__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