kalibr 1.0.17__py3-none-any.whl → 1.0.20__py3-none-any.whl

kalibr/schema_generators.py

@@ -1,13 +1,212 @@
-import json
-
-def generate_openapi_schema(app):
-    return app.openapi()
-
-def generate_mcp_schema(app):
-    return {
-        "mcp": "1.0",
-        "tools": [
-            {"name": name, "description": func.__doc__ or ""}
-            for name, func in app.actions.items()
-        ],
-    }
+"""
+Multi-model schema generators for different AI platforms
+"""
+from typing import Dict, Any, List
+from abc import ABC, abstractmethod
+
+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"""
+    
+    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"],
+                "input_schema": {
+                    "type": "object",
+                    "properties": properties,
+                    "required": required
+                },
+                "server": {
+                    "url": f"{base_url}/proxy/{action_name}"
+                }
+            })
+        
+        return {
+            "mcp": "1.0",
+            "name": "kalibr-enhanced",
+            "tools": tools
+        }
+
+class OpenAPISchemaGenerator(BaseSchemaGenerator):
+    """GPT Actions OpenAPI schema generator"""
+    
+    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 Enhanced API",
+                "version": "2.0.0",
+                "description": "Enhanced Kalibr API with app-level capabilities"
+            },
+            "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"""
+    
+    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]:
+        # Generic schema format that can be customized
+        return {
+            "model": self.model_name,
+            "format": self.schema_format,
+            "version": "2.0.0",
+            "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/types.py

@@ -0,0 +1,106 @@
+"""
+Enhanced data types for Kalibr app-level framework
+"""
+from pydantic import BaseModel, Field
+from typing import Optional, Dict, Any, List, Union, AsyncGenerator
+from datetime import datetime
+import uuid
+import io
+
+class FileUpload(BaseModel):
+    """Enhanced file upload handling for AI model integrations"""
+    filename: str
+    content_type: str
+    size: int
+    content: bytes
+    upload_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    uploaded_at: datetime = Field(default_factory=datetime.now)
+    
+    class Config:
+        arbitrary_types_allowed = True
+
+class ImageData(BaseModel):
+    """Image data type for AI vision capabilities"""
+    filename: str
+    content_type: str
+    width: Optional[int] = None
+    height: Optional[int] = None
+    format: str  # jpeg, png, webp, etc.
+    content: bytes
+    image_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    
+    class Config:
+        arbitrary_types_allowed = True
+
+class TableData(BaseModel):
+    """Structured table data for AI analysis"""
+    headers: List[str]
+    rows: List[List[Any]]
+    table_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    metadata: Optional[Dict[str, Any]] = None
+
+class StreamingResponse(BaseModel):
+    """Base class for streaming responses"""
+    chunk_id: str
+    content: Any
+    is_final: bool = False
+    timestamp: datetime = Field(default_factory=datetime.now)
+
+class Session(BaseModel):
+    """Session management for stateful interactions"""
+    session_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    user_id: Optional[str] = None
+    created_at: datetime = Field(default_factory=datetime.now)
+    last_accessed: datetime = Field(default_factory=datetime.now)
+    data: Dict[str, Any] = Field(default_factory=dict)
+    expires_at: Optional[datetime] = None
+    
+    def get(self, key: str, default=None):
+        """Get session data"""
+        return self.data.get(key, default)
+    
+    def set(self, key: str, value: Any):
+        """Set session data"""
+        self.data[key] = value
+        self.last_accessed = datetime.now()
+    
+    def delete(self, key: str):
+        """Delete session data"""
+        if key in self.data:
+            del self.data[key]
+
+class AuthenticatedUser(BaseModel):
+    """Authenticated user context"""
+    user_id: str
+    username: str
+    email: Optional[str] = None
+    roles: List[str] = Field(default_factory=list)
+    permissions: List[str] = Field(default_factory=list)
+    auth_method: str  # "jwt", "oauth", "api_key", etc.
+    
+class FileDownload(BaseModel):
+    """File download response"""
+    filename: str
+    content_type: str
+    content: bytes
+    
+    class Config:
+        arbitrary_types_allowed = True
+
+class AnalysisResult(BaseModel):
+    """Generic analysis result structure"""
+    result_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    status: str  # "success", "error", "pending"
+    data: Dict[str, Any] = Field(default_factory=dict)
+    created_at: datetime = Field(default_factory=datetime.now)
+    processing_time: Optional[float] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+class WorkflowState(BaseModel):
+    """Workflow state management"""
+    workflow_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    step: str
+    status: str
+    data: Dict[str, Any] = Field(default_factory=dict)
+    created_at: datetime = Field(default_factory=datetime.now)
+    updated_at: datetime = Field(default_factory=datetime.now)

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

@@ -0,0 +1,173 @@
+# 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.20.data/data/examples/basic_kalibr_example.py

@@ -0,0 +1,66 @@
+"""
+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