kalibr 1.0.28__py3-none-any.whl → 1.1.0__py3-none-any.whl

kalibr/utils.py

@@ -0,0 +1,198 @@
+"""Utility functions for Kalibr SDK.
+
+Helper functions for:
+- Environment configuration
+- Event validation
+- JSON serialization
+- Logging
+"""
+
+import json
+import os
+from datetime import date, datetime, time
+from typing import Any, Dict, Optional
+
+
+def load_config_from_env() -> Dict[str, str]:
+    """Load Kalibr configuration from environment variables.
+
+    Returns:
+        Configuration dict with keys:
+        - clickhouse_url: ClickHouse connection URL
+        - project_name: Project/service name
+        - auth_token: API authentication token
+        - environment: Environment (prod/staging/dev)
+        - tenant_id: Tenant identifier
+        - workflow_id: Workflow identifier
+        - sandbox_id: Sandbox/VM identifier
+        - runtime_env: Runtime environment
+        - collector_url: Collector endpoint URL
+    """
+    config = {
+        "clickhouse_url": os.getenv("CLICKHOUSE_URL", "http://localhost:8123"),
+        "project_name": os.getenv("KALIBR_PROJECT_NAME", "kalibr-app"),
+        "auth_token": os.getenv("KALIBR_AUTH_TOKEN", ""),
+        "api_key": os.getenv("KALIBR_API_KEY", ""),
+        "environment": os.getenv("KALIBR_ENVIRONMENT", "prod"),
+        "tenant_id": os.getenv("KALIBR_TENANT_ID", "default"),
+        "workflow_id": os.getenv("KALIBR_WORKFLOW_ID", "default-workflow"),
+        "sandbox_id": os.getenv("SANDBOX_ID", "local"),
+        "runtime_env": os.getenv("RUNTIME_ENV", "local"),
+        "api_endpoint": os.getenv("KALIBR_API_ENDPOINT", "http://localhost:8001/api/v1/traces"),
+        "collector_url": os.getenv("KALIBR_COLLECTOR_URL", "http://localhost:8080/api/ingest"),
+    }
+    return config
+
+
+def validate_event(event: Dict[str, Any]) -> bool:
+    """Validate that event has required fields.
+
+    Args:
+        event: Event dictionary
+
+    Returns:
+        True if valid, False otherwise
+    """
+    required_fields = [
+        "trace_id",
+        "span_id",
+        "timestamp",
+        "service",
+        "vendor",
+        "operation",
+        "latency_ms",
+        "status",
+    ]
+
+    for field in required_fields:
+        if field not in event:
+            return False
+
+    return True
+
+
+def serialize_event(event: Dict[str, Any]) -> str:
+    """Serialize event to JSON string.
+
+    Handles special types like datetime, date, time.
+
+    Args:
+        event: Event dictionary
+
+    Returns:
+        JSON string
+    """
+
+    def default_handler(obj):
+        """Handle non-serializable types."""
+        if isinstance(obj, (datetime, date, time)):
+            return obj.isoformat()
+        raise TypeError(f"Object of type {type(obj)} is not JSON serializable")
+
+    return json.dumps(event, default=default_handler)
+
+
+def safe_get_nested(data: Dict, keys: list, default: Any = None) -> Any:
+    """Safely get nested dictionary value.
+
+    Args:
+        data: Dictionary to query
+        keys: List of nested keys
+        default: Default value if key path doesn't exist
+
+    Returns:
+        Value at nested key path, or default
+
+    Example:
+        >>> data = {"a": {"b": {"c": 123}}}
+        >>> safe_get_nested(data, ["a", "b", "c"])
+        123
+        >>> safe_get_nested(data, ["a", "x", "y"], default=0)
+        0
+    """
+    current = data
+    for key in keys:
+        if isinstance(current, dict) and key in current:
+            current = current[key]
+        else:
+            return default
+    return current
+
+
+def truncate_string(s: str, max_length: int = 1000) -> str:
+    """Truncate string to max length with ellipsis.
+
+    Args:
+        s: String to truncate
+        max_length: Maximum length
+
+    Returns:
+        Truncated string
+    """
+    if len(s) <= max_length:
+        return s
+    return s[: max_length - 3] + "..."
+
+
+def format_cost(cost_usd: float) -> str:
+    """Format cost in USD for display.
+
+    Args:
+        cost_usd: Cost in USD
+
+    Returns:
+        Formatted string (e.g., "$0.0123")
+    """
+    if cost_usd < 0.0001:
+        return "$0.0000"
+    elif cost_usd < 0.01:
+        return f"${cost_usd:.4f}"
+    elif cost_usd < 1.0:
+        return f"${cost_usd:.3f}"
+    else:
+        return f"${cost_usd:.2f}"
+
+
+def format_latency(latency_ms: int) -> str:
+    """Format latency for display.
+
+    Args:
+        latency_ms: Latency in milliseconds
+
+    Returns:
+        Formatted string (e.g., "420ms" or "2.3s")
+    """
+    if latency_ms < 1000:
+        return f"{latency_ms}ms"
+    else:
+        seconds = latency_ms / 1000
+        return f"{seconds:.1f}s"
+
+
+def get_log_prefix() -> str:
+    """Get log prefix for Kalibr SDK messages.
+
+    Returns:
+        Log prefix string
+    """
+    return "[Kalibr SDK]"
+
+
+def log_info(message: str):
+    """Log info message."""
+    print(f"{get_log_prefix()} ℹ️  {message}")
+
+
+def log_warning(message: str):
+    """Log warning message."""
+    print(f"{get_log_prefix()} ⚠️  {message}")
+
+
+def log_error(message: str):
+    """Log error message."""
+    print(f"{get_log_prefix()} ❌ {message}")
+
+
+def log_success(message: str):
+    """Log success message."""
+    print(f"{get_log_prefix()} ✅ {message}")

kalibr-1.1.0.dist-info/METADATA

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: kalibr
+Version: 1.1.0
+Summary: Unified LLM Observability & Multi-Model AI Integration Framework - Deploy to GPT, Claude, Gemini, Copilot with full telemetry
+Author-email: Kalibr Team <team@kalibr.dev>
+License: MIT
+Project-URL: Homepage, https://github.com/devonakelley/kalibr-sdk
+Project-URL: Documentation, https://github.com/devonakelley/kalibr-sdk#readme
+Project-URL: Repository, https://github.com/devonakelley/kalibr-sdk
+Project-URL: Issues, https://github.com/devonakelley/kalibr-sdk/issues
+Keywords: ai,mcp,gpt,claude,gemini,copilot,openai,anthropic,google,microsoft,observability,telemetry,tracing,llm,schema-generation,api,multi-model
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: tiktoken>=0.8.0
+Requires-Dist: fastapi>=0.110.1
+Requires-Dist: uvicorn>=0.25.0
+Requires-Dist: pydantic>=2.6.4
+Requires-Dist: typer>=0.9.0
+Requires-Dist: python-multipart>=0.0.9
+Requires-Dist: rich>=10.0.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: opentelemetry-api>=1.20.0
+Requires-Dist: opentelemetry-sdk>=1.20.0
+Requires-Dist: opentelemetry-exporter-otlp>=1.20.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Dynamic: license-file
+
+# Kalibr Python SDK
+
+Production-grade observability for LLM applications.
+
+## Installation
+```bash
+pip install kalibr
+```
+
+## Quickstart
+```python
+from kalibr import trace
+import openai
+
+@trace(api_key="your-kalibr-api-key")
+def my_agent():
+    response = openai.chat.completions.create(
+        model="gpt-4",
+        messages=[{"role": "user", "content": "Hello!"}]
+    )
+    return response
+```
+
+## Features
+
+- ✅ Zero-code instrumentation for OpenAI, Anthropic, Google AI
+- ✅ Automatic parent-child trace relationships
+- ✅ Real-time cost tracking
+- ✅ Token usage monitoring
+- ✅ Performance metrics
+
+## CLI Tools
+```bash
+# Run your app locally
+kalibr serve myapp.py
+
+# Deploy to Fly.io
+kalibr deploy myapp.py
+
+# Fetch trace data
+kalibr capsule <trace-id>
+```
+
+## Examples
+
+See `examples/` directory for complete examples.
+
+## Documentation
+
+Full docs at https://docs.kalibr.systems
+
+## License
+
+MIT

kalibr-1.1.0.dist-info/RECORD

@@ -0,0 +1,40 @@
+kalibr/__init__.py,sha256=fNOjaXe1sJ9fFgqTsO6GQY4Yf4TCr_T659lxr3FB35Q,5906
+kalibr/__main__.py,sha256=jO96I4pqinwHg7ONRvNVKbySBh5pSIhOAiNrgSQrNlY,110
+kalibr/capsule_middleware.py,sha256=pXG_wORgCqo3wHjtkn_zY4doLyiDmTwJtB7XiZNnbPk,3163
+kalibr/client.py,sha256=t6_vZn_juHrsCg-7QFrkl-pzlqV7ZesQLCh8fnF808Q,9727
+kalibr/collector.py,sha256=rtTKQLe6NkDSblBIfFooQ-ESFcP0Q1HUp4Bcqqg8JFo,5818
+kalibr/context.py,sha256=hBxWXZx0gcmeGqDMS1rstke_DmrujoRBIsfrG26WKUY,3755
+kalibr/cost_adapter.py,sha256=NerJ7ywaJjBn97gVFr7qKX7318e3Kmy2qqeNlGl9nPE,6439
+kalibr/decorators.py,sha256=m-XBXxWMDVrzaNsljACiGmeGhgiHj_MqSfj6OGK3L5I,4380
+kalibr/kalibr.py,sha256=cNXC3W_TX5SvGsy1lRopkwFqsHOpyd1kkVjEMOz1Yr4,6084
+kalibr/kalibr_app.py,sha256=ItZwEh0FZPx9_BE-zPQajC2yxI2y9IHYwJD0k9tbHvY,2773
+kalibr/models.py,sha256=HwD_-iysZMSnCzMQYO1Qcf0aeXySupY7yJeBwl_dLS0,1024
+kalibr/redaction.py,sha256=XibxX4Lv1Ci0opE6Tb5ZI2GLbO0a8E9U66MAg60llnc,1139
+kalibr/schemas.py,sha256=XLZNLkXca6jbj9AF6gDIyGVnIcr1SVOsNYaKvW-wbgE,3669
+kalibr/simple_tracer.py,sha256=LPc56PfGZQT8YXS2Y1eAiOu0CsOEi4-UmWVlq03cZpM,9665
+kalibr/tokens.py,sha256=istjgaxi9S4dMddjuGtoQaTnZYcWLCqdnxRjV86yNXA,1297
+kalibr/trace_capsule.py,sha256=CPMUz5D-fVfao-MozNtSDbgOQKdDAJxTN5KQL6w2Xp8,10154
+kalibr/trace_models.py,sha256=9o7VJQk3gCrvdfXPrNh3Ptkq5sRgA9_qrLLE3jNkSBg,7304
+kalibr/tracer.py,sha256=jwWBpZbGXn6fEv4pw25BLFCH-22QUbyzofPWp1Iwdkk,11911
+kalibr/types.py,sha256=cna4-akpdwfHXfOJCtVIq5lO_jaoG2Am3BRrXi0Vo34,895
+kalibr/utils.py,sha256=IbAgw-Bwxdy9Kc0fm2yIDt2RxWU0gRCzffuz3GRUSnE,5042
+kalibr/cli/__init__.py,sha256=FmRGaDMhM9DhrKg1ONkF0emIrJcjFWjlFBl_oenvpsk,77
+kalibr/cli/capsule_cmd.py,sha256=htxUtRpos_dLs-LnJm6WeGtLYCCc1h7H3WXz7i6DVWc,6082
+kalibr/cli/deploy_cmd.py,sha256=kV4uqCN2IdQev1vPBY5qqIHsEhjGBZ7y_rLx8RGAL_4,5178
+kalibr/cli/main.py,sha256=Ob0Vpg8KPnHluP_23pgbEZpDb_iKnjoN7mW52-2Qr44,1939
+kalibr/cli/run.py,sha256=DrH0Pjc_gcrvvi0cSiQCf_WJNtOh3xd1EWncuNloNCM,6293
+kalibr/cli/serve.py,sha256=71Xha35qrBNkcQxuUkwC-ixbOriHGUIEgxl7C_qERQo,2085
+kalibr/instrumentation/__init__.py,sha256=YnUJ4gUH8WNxdVv5t1amn0l2WUULJG2MuQIL2ZZhn04,354
+kalibr/instrumentation/anthropic_instr.py,sha256=ozXHr8BPMafIbvgaxunskQi9YX5_Gpoiekye77oRc2E,10058
+kalibr/instrumentation/base.py,sha256=eMFBTIQXtG2bZD5st6vzN72ooeHCANZ3SapYzrdijgk,3109
+kalibr/instrumentation/google_instr.py,sha256=f2um7MB2QCT2u9CFV4-vKke-8M0dSXSpZHTcbdxMZyI,10476
+kalibr/instrumentation/openai_instr.py,sha256=UU0Pi1Gq1FqgetYWDacQhNFdjemuPrc0hRTKd-LIDHI,9250
+kalibr/instrumentation/registry.py,sha256=sfQnXhbPOI5LVon2kFhe8KcXQwWmuKW1XUe50B2AaBc,4749
+kalibr/middleware/__init__.py,sha256=qyDUn_irAX67MS-IkuDVxg4RmFnJHDf_BfIT3qfGoBI,115
+kalibr/middleware/auto_tracer.py,sha256=oevrhWBAM4el_F5jFc28ZBFLEklx7XGd40dNFe5VQ8Q,13032
+kalibr-1.1.0.dist-info/licenses/LICENSE,sha256=BYlEPoDdYD3iHuAjt2JYGoxDYQaI1gxab2pR4acoz04,1063
+kalibr-1.1.0.dist-info/METADATA,sha256=U1E1RTfkpgHZSOVSpfP6Sw-GxMf4ilmczPK6VvuZfW4,2841
+kalibr-1.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kalibr-1.1.0.dist-info/entry_points.txt,sha256=Kojlc6WRX8V1qS9lOMdDPZpTUVHCtzGtHqXusErgmLY,47
+kalibr-1.1.0.dist-info/top_level.txt,sha256=OkloC5_IfpE4-QwI30aLIYbFZk_-ChABWF7aBGddy28,7
+kalibr-1.1.0.dist-info/RECORD,,

kalibr-1.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kalibr = kalibr.cli.main:app

kalibr-1.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kalibr
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

kalibr/deployment.py

@@ -1,41 +0,0 @@
-"""
-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/packager.py

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

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