schema-validator-ai-mcp 1.0.0__tar.gz

schema_validator_ai_mcp-1.0.0/.github/workflows/mcp-smithery-publish.yml

@@ -0,0 +1,40 @@
+name: Publish to Smithery
+
+on:
+  release:
+    types: [published]
+
+permissions: {}
+
+jobs:
+  publish:
+    name: Publish MCP Server to Smithery
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      attestations: write
+      id-token: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          persist-credentials: false
+
+      - name: Setup Node.js
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
+        with:
+          node-version: '22'
+
+      - name: Publish to Smithery
+        id: smithery_publish
+        env:
+          SMITHERY_API_KEY: ${{ secrets.SMITHERY_API_KEY }}
+        run: |
+          npx @smithery/cli mcp publish "https://github.com/${{ github.repository }}" -n nicholastempleman/${{ github.event.repository.name }} --json
+
+      - name: Attest build provenance
+        uses: actions/attest-build-provenance@96b4a1ef7235a096b17240c259729fdd70c83d45 # v2
+        with:
+          subject-name: ${{ github.repository }}
+          subject-digest: sha256:${{ github.sha }}
+          push-to-registry: false

schema_validator_ai_mcp-1.0.0/.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+*.pyc
+.env
+*.db

schema_validator_ai_mcp-1.0.0/.mcp.json

@@ -0,0 +1,81 @@
+{
+  "name": "schema-validator-ai-mcp",
+  "description": "Schema Validator Ai automation via MCP. Includes validate json schema, generate schema, convert openapi. By MEOK AI Labs.",
+  "version": "1.0.0",
+  "tools": [
+    {
+      "name": "validate_json_schema",
+      "description": "Validate JSON data against a JSON Schema.",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "data_json": {
+            "type": "string"
+          },
+          "schema_json": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "data_json",
+          "schema_json"
+        ]
+      }
+    },
+    {
+      "name": "generate_schema",
+      "description": "Generate a JSON Schema from example JSON data.",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "data_json": {
+            "type": "string"
+          },
+          "title": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "data_json"
+        ]
+      }
+    },
+    {
+      "name": "convert_openapi",
+      "description": "Extract and convert schemas from an OpenAPI specification.",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "openapi_json": {
+            "type": "string"
+          },
+          "extract_schemas": {
+            "type": "boolean"
+          }
+        },
+        "required": [
+          "openapi_json"
+        ]
+      }
+    },
+    {
+      "name": "validate_types",
+      "description": "Validate that JSON data fields match expected types.",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "data_json": {
+            "type": "string"
+          },
+          "type_spec": {
+            "type": "object"
+          }
+        },
+        "required": [
+          "data_json",
+          "type_spec"
+        ]
+      }
+    }
+  ]
+}

schema_validator_ai_mcp-1.0.0/CODE_OF_CONDUCT.md

@@ -0,0 +1,18 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our project a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, caste, color, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment:
+- Demonstrating empathy and kindness toward other people
+- Being respectful of differing opinions, viewpoints, and experiences
+- Giving and gracefully accepting constructive feedback
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at nicholas@meok.ai.
+
+This Code of Conduct is adapted from the [Contributor Covenant](https://www.contributor-covenant.org), version 2.1.

schema_validator_ai_mcp-1.0.0/CONTRIBUTING.md

@@ -0,0 +1,21 @@
+# Contributing to MEOK AI Labs MCP Servers
+
+Thank you for your interest in contributing!
+
+## How to Contribute
+
+1. Fork the repository.
+2. Create a feature branch (`git checkout -b feature/amazing-feature`).
+3. Commit your changes (`git commit -m 'feat: add amazing feature'`).
+4. Push to the branch (`git push origin feature/amazing-feature`).
+5. Open a Pull Request.
+
+## Code Style
+
+- Follow PEP 8 for Python code.
+- Keep tool interfaces backward-compatible when possible.
+- Add tests for new functionality.
+
+## Questions?
+
+Reach out at nicholas@meok.ai.

schema_validator_ai_mcp-1.0.0/Dockerfile.glama

@@ -0,0 +1,20 @@
+FROM python:3.14-slim
+
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONDONTWRITEBYTECODE=1
+
+RUN apt-get update && apt-get install -y --no-install-recommends git build-essential && rm -rf /var/lib/apt/lists/*
+RUN pip install --no-cache-dir uv
+
+RUN useradd -m -s /bin/bash nicholas &&     mkdir -p /home/nicholas/clawd/meok-labs-engine/shared &&     chown -R nicholas:nicholas /home/nicholas
+
+WORKDIR /app
+USER nicholas
+
+RUN uv venv /home/nicholas/.venv
+ENV PATH="/home/nicholas/.venv/bin:$PATH"
+
+COPY --chown=nicholas:nicholas . /app
+RUN uv pip install -e .
+
+CMD ["python", "mcp-wrapper.py"]

schema_validator_ai_mcp-1.0.0/LICENSE

@@ -0,0 +1,13 @@
+MIT License
+
+Copyright (c) 2026 MEOK AI Labs
+
+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.

schema_validator_ai_mcp-1.0.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: schema-validator-ai-mcp
+Version: 1.0.0
+Summary: Schema Validator Ai automation via MCP. Includes validate json schema, generate schema, convert openapi. By MEOK AI Labs.
+Project-URL: Homepage, https://meok.ai
+Project-URL: Repository, https://github.com/CSOAI-ORG/schema-validator-ai-mcp
+Author-email: MEOK AI Labs <nicholas@meok.ai>
+License: MIT License
+        
+        Copyright (c) 2026 MEOK AI Labs
+        
+        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.
+License-File: LICENSE
+Keywords: ai,mcp,meok,schema,validator
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Requires-Dist: mcp>=1.0.0

schema_validator_ai_mcp-1.0.0/README.md

@@ -0,0 +1,24 @@
+# Schema Validator AI MCP Server
+
+JSON Schema validation, schema generation, OpenAPI extraction, and type checking.
+
+## Tools
+
+- **validate_json_schema**
+- **generate_schema**
+- **convert_openapi**
+- **validate_types**
+
+## Quick Start
+
+```bash
+pip install mcp
+python server.py
+```
+
+## Rate Limits
+
+- Free tier: 50 calls/day per tool
+- Upgrade: https://meok.ai/pricing
+
+Built by [MEOK AI Labs](https://meok.ai)

schema_validator_ai_mcp-1.0.0/SECURITY.md

@@ -0,0 +1,16 @@
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 1.0.x   | :white_check_mark: |
+
+## Reporting a Vulnerability
+
+If you discover a security vulnerability, please report it privately to:
+
+- **Email:** nicholas@meok.ai
+- **Organization:** MEOK AI Labs
+
+We aim to respond within 48 hours and will coordinate disclosure responsibly.

schema_validator_ai_mcp-1.0.0/glama.json

@@ -0,0 +1,10 @@
+{
+  "name": "schema-validator-ai-mcp",
+  "description": "MEOK AI Labs \u2014 schema-validator-ai-mcp",
+  "vendor": "MEOK AI Labs",
+  "homepage": "https://meok.ai",
+  "repository": "https://github.com/CSOAI-ORG/schema-validator-ai-mcp",
+  "license": "MIT",
+  "runtime": "python",
+  "entryPoint": "mcp-wrapper.py"
+}

schema_validator_ai_mcp-1.0.0/mcp-wrapper.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""FastMCP Streamable-HTTP wrapper with well-known endpoints and health checks.
+
+Usage:
+    python /path/to/mcp-streamable-http-wrapper.py
+
+This imports `mcp` from `server.py`, mounts discovery endpoints, and runs
+with transport='streamable-http'.
+"""
+
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.expanduser("~/clawd/meok-labs-engine/shared"))
+sys.path.insert(0, os.getcwd())
+
+from starlette.requests import Request
+from starlette.responses import JSONResponse, Response
+from server import mcp as mcp_server
+
+
+SERVICE_NAME = os.path.basename(os.getcwd())
+REPO_URL = f"https://github.com/CSOAI-ORG/{SERVICE_NAME}"
+
+
+@mcp_server.custom_route("/.well-known/mcp/server-card.json", methods=["GET"])
+async def server_card(request: Request) -> Response:
+    return JSONResponse(
+        {
+            "$schema": "https://schema.smithery.ai/server-card.json",
+            "version": "1.0.0",
+            "protocolVersion": "2025-11-25",
+            "serverInfo": {
+                "name": SERVICE_NAME,
+                "description": f"MEOK AI Labs — {SERVICE_NAME}",
+                "vendor": "MEOK AI Labs",
+                "homepage": "https://meok.ai",
+                "repository": REPO_URL,
+            },
+            "transport": {
+                "type": "streamable-http",
+                "url": "http://localhost:8000/mcp",
+            },
+            "capabilities": {
+                "tools": {"listChanged": False},
+                "resources": {"listChanged": False},
+                "prompts": {"listChanged": False},
+            },
+        },
+        headers={
+            "Access-Control-Allow-Origin": "*",
+            "Cache-Control": "public, max-age=3600",
+        },
+    )
+
+
+@mcp_server.custom_route("/.well-known/mcp", methods=["GET"])
+async def mcp_manifest(request: Request) -> Response:
+    return JSONResponse(
+        {
+            "mcp_version": "2025-11-25",
+            "endpoints": [
+                {
+                    "type": "streamable-http",
+                    "path": "/mcp",
+                    "url": "http://localhost:8000/mcp",
+                }
+            ],
+        },
+        headers={
+            "Access-Control-Allow-Origin": "*",
+            "Cache-Control": "public, max-age=3600",
+        },
+    )
+
+
+@mcp_server.custom_route("/health", methods=["GET"])
+async def health(request: Request) -> Response:
+    return JSONResponse({"status": "ok"})
+
+
+if __name__ == "__main__":
+    mcp_server.settings.host = "0.0.0.0"
+    mcp_server.run(transport="streamable-http")

schema_validator_ai_mcp-1.0.0/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "schema-validator-ai-mcp",
+  "version": "1.0.0",
+  "description": "Schema Validator Ai automation via MCP. Includes validate json schema, generate schema, convert openapi. By MEOK AI Labs.",
+  "main": "server.py",
+  "mcp": {
+    "name": "schema validator",
+    "vendor": "MEOK AI Labs",
+    "homepage": "https://meok.ai",
+    "repository": "https://github.com/CSOAI-ORG/schema-validator-ai-mcp",
+    "runtime": "python",
+    "tags": [
+      "mcp",
+      "mcp-server",
+      "meok-ai-labs",
+      "ai-tools"
+    ]
+  },
+  "keywords": [
+    "mcp",
+    "mcp-server",
+    "meok-ai-labs"
+  ],
+  "author": "MEOK AI Labs <nicholas@meok.ai>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CSOAI-ORG/schema-validator-ai-mcp"
+  }
+}

schema_validator_ai_mcp-1.0.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+[project]
+name = "schema-validator-ai-mcp"
+version = "1.0.0"
+description = "Schema Validator Ai automation via MCP. Includes validate json schema, generate schema, convert openapi. By MEOK AI Labs."
+license = {file = "LICENSE"}
+requires-python = ">=3.10"
+authors = [{name = "MEOK AI Labs", email = "nicholas@meok.ai"}]
+dependencies = ["mcp>=1.0.0"]
+keywords = ["mcp", "ai", "meok", "schema", "validator"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries",
+]
+[project.urls]
+Homepage = "https://meok.ai"
+Repository = "https://github.com/CSOAI-ORG/schema-validator-ai-mcp"
+[tool.hatch.build.targets.wheel]
+packages = ["."]
+only-include = ["server.py"]
+
+[project.scripts]
+schema_validator_ai_mcp = "server:main"

schema_validator_ai_mcp-1.0.0/pytest.ini

@@ -0,0 +1,3 @@
+[pytest]
+testpaths = tests
+python_files = test_*.py

schema_validator_ai_mcp-1.0.0/server.py

@@ -0,0 +1,230 @@
+"""
+Schema Validator AI MCP Server
+JSON Schema validation and generation tools powered by MEOK AI Labs.
+"""
+
+
+import sys, os
+sys.path.insert(0, os.path.expanduser('~/clawd/meok-labs-engine/shared'))
+from auth_middleware import check_access
+
+import json
+import time
+from collections import defaultdict
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("schema-validator-ai", instructions="MEOK AI Labs MCP Server")
+
+_call_counts: dict[str, list[float]] = defaultdict(list)
+FREE_TIER_LIMIT = 50
+WINDOW = 86400
+
+TYPE_MAP = {str: "string", int: "integer", float: "number", bool: "boolean", list: "array", dict: "object", type(None): "null"}
+
+
+def _check_rate_limit(tool_name: str) -> None:
+    now = time.time()
+    _call_counts[tool_name] = [t for t in _call_counts[tool_name] if now - t < WINDOW]
+    if len(_call_counts[tool_name]) >= FREE_TIER_LIMIT:
+        raise ValueError(f"Rate limit exceeded for {tool_name}. Free tier: {FREE_TIER_LIMIT}/day. Upgrade at https://meok.ai/pricing")
+    _call_counts[tool_name].append(now)
+
+
+def _infer_type(value) -> dict:
+    """Infer JSON Schema type from a Python value."""
+    if value is None:
+        return {"type": "null"}
+    if isinstance(value, bool):
+        return {"type": "boolean"}
+    if isinstance(value, int):
+        return {"type": "integer"}
+    if isinstance(value, float):
+        return {"type": "number"}
+    if isinstance(value, str):
+        schema = {"type": "string"}
+        if "@" in value and "." in value:
+            schema["format"] = "email"
+        elif value.startswith("http"):
+            schema["format"] = "uri"
+        elif len(value) == 10 and value[4:5] == "-":
+            schema["format"] = "date"
+        return schema
+    if isinstance(value, list):
+        if value:
+            item_types = [_infer_type(v) for v in value[:5]]
+            if all(t == item_types[0] for t in item_types):
+                return {"type": "array", "items": item_types[0]}
+            return {"type": "array", "items": {"anyOf": list({json.dumps(t, sort_keys=True): t for t in item_types}.values())}}
+        return {"type": "array"}
+    if isinstance(value, dict):
+        props = {}
+        for k, v in value.items():
+            props[k] = _infer_type(v)
+        return {"type": "object", "properties": props, "required": list(value.keys())}
+    return {}
+
+
+def _validate_against_schema(data, schema, path="$") -> list:
+    """Basic JSON Schema validation without external libs."""
+    errors = []
+    schema_type = schema.get("type")
+    if schema_type:
+        actual = TYPE_MAP.get(type(data))
+        if isinstance(data, bool) and schema_type != "boolean":
+            errors.append({"path": path, "error": f"Expected {schema_type}, got boolean"})
+        elif schema_type == "number" and actual in ("integer", "number"):
+            pass
+        elif actual != schema_type and data is not None:
+            errors.append({"path": path, "error": f"Expected {schema_type}, got {actual or type(data).__name__}"})
+    if schema_type == "object" and isinstance(data, dict):
+        for req in schema.get("required", []):
+            if req not in data:
+                errors.append({"path": f"{path}.{req}", "error": f"Required property '{req}' missing"})
+        for prop, prop_schema in schema.get("properties", {}).items():
+            if prop in data:
+                errors.extend(_validate_against_schema(data[prop], prop_schema, f"{path}.{prop}"))
+    if schema_type == "array" and isinstance(data, list):
+        items_schema = schema.get("items", {})
+        if items_schema:
+            for i, item in enumerate(data):
+                errors.extend(_validate_against_schema(item, items_schema, f"{path}[{i}]"))
+        if "minItems" in schema and len(data) < schema["minItems"]:
+            errors.append({"path": path, "error": f"Array has {len(data)} items, minimum {schema['minItems']}"})
+        if "maxItems" in schema and len(data) > schema["maxItems"]:
+            errors.append({"path": path, "error": f"Array has {len(data)} items, maximum {schema['maxItems']}"})
+    if schema_type == "string" and isinstance(data, str):
+        if "minLength" in schema and len(data) < schema["minLength"]:
+            errors.append({"path": path, "error": f"String too short: {len(data)} < {schema['minLength']}"})
+        if "maxLength" in schema and len(data) > schema["maxLength"]:
+            errors.append({"path": path, "error": f"String too long: {len(data)} > {schema['maxLength']}"})
+        if "enum" in schema and data not in schema["enum"]:
+            errors.append({"path": path, "error": f"Value not in enum: {schema['enum']}"})
+    if schema_type in ("integer", "number") and isinstance(data, (int, float)):
+        if "minimum" in schema and data < schema["minimum"]:
+            errors.append({"path": path, "error": f"Value {data} below minimum {schema['minimum']}"})
+        if "maximum" in schema and data > schema["maximum"]:
+            errors.append({"path": path, "error": f"Value {data} above maximum {schema['maximum']}"})
+    return errors
+
+
+@mcp.tool()
+def validate_json_schema(data_json: str, schema_json: str, api_key: str = "") -> dict:
+    """Validate JSON data against a JSON Schema.
+
+    Args:
+        data_json: JSON string of the data to validate
+        schema_json: JSON string of the schema to validate against
+    """
+    allowed, msg, tier = check_access(api_key)
+    if not allowed:
+        return {"error": msg, "upgrade_url": "https://meok.ai/pricing"}
+
+    _check_rate_limit("validate_json_schema")
+    try:
+        data = json.loads(data_json)
+        schema = json.loads(schema_json)
+    except json.JSONDecodeError as e:
+        return {"valid": False, "error": f"JSON parse error: {e}"}
+    errors = _validate_against_schema(data, schema)
+    return {"valid": len(errors) == 0, "errors": errors, "error_count": len(errors)}
+
+
+@mcp.tool()
+def generate_schema(data_json: str, title: str = "", api_key: str = "") -> dict:
+    """Generate a JSON Schema from example JSON data.
+
+    Args:
+        data_json: Example JSON data string
+        title: Optional schema title
+    """
+    allowed, msg, tier = check_access(api_key)
+    if not allowed:
+        return {"error": msg, "upgrade_url": "https://meok.ai/pricing"}
+
+    _check_rate_limit("generate_schema")
+    try:
+        data = json.loads(data_json)
+    except json.JSONDecodeError as e:
+        return {"error": f"Invalid JSON: {e}"}
+    schema = {"$schema": "https://json-schema.org/draft/2020-12/schema"}
+    if title:
+        schema["title"] = title
+    schema.update(_infer_type(data))
+    return {"schema": json.dumps(schema, indent=2), "schema_object": schema}
+
+
+@mcp.tool()
+def convert_openapi(openapi_json: str, extract_schemas: bool = True, api_key: str = "") -> dict:
+    """Extract and convert schemas from an OpenAPI specification.
+
+    Args:
+        openapi_json: OpenAPI spec as JSON string
+        extract_schemas: Whether to extract component schemas (default True)
+    """
+    allowed, msg, tier = check_access(api_key)
+    if not allowed:
+        return {"error": msg, "upgrade_url": "https://meok.ai/pricing"}
+
+    _check_rate_limit("convert_openapi")
+    try:
+        spec = json.loads(openapi_json)
+    except json.JSONDecodeError as e:
+        return {"error": f"Invalid JSON: {e}"}
+    info = spec.get("info", {})
+    paths = spec.get("paths", {})
+    endpoints = []
+    for path, methods in paths.items():
+        for method, details in methods.items():
+            if method in ("get", "post", "put", "delete", "patch"):
+                endpoints.append({"path": path, "method": method.upper(),
+                                  "summary": details.get("summary", ""), "operationId": details.get("operationId", "")})
+    schemas = {}
+    if extract_schemas:
+        components = spec.get("components", {}).get("schemas", {})
+        for name, schema in components.items():
+            schemas[name] = schema
+    return {"title": info.get("title", ""), "version": info.get("version", ""),
+            "endpoints": endpoints, "endpoint_count": len(endpoints),
+            "schemas": schemas, "schema_count": len(schemas)}
+
+
+@mcp.tool()
+def validate_types(data_json: str, type_spec: dict, api_key: str = "") -> dict:
+    """Validate that JSON data fields match expected types.
+
+    Args:
+        data_json: JSON string to validate
+        type_spec: Dict mapping field paths to expected types (e.g., {"name": "string", "age": "integer"})
+    """
+    allowed, msg, tier = check_access(api_key)
+    if not allowed:
+        return {"error": msg, "upgrade_url": "https://meok.ai/pricing"}
+
+    _check_rate_limit("validate_types")
+    try:
+        data = json.loads(data_json)
+    except json.JSONDecodeError as e:
+        return {"valid": False, "error": f"Invalid JSON: {e}"}
+    errors = []
+    for field, expected_type in type_spec.items():
+        parts = field.split('.')
+        value = data
+        found = True
+        for part in parts:
+            if isinstance(value, dict) and part in value:
+                value = value[part]
+            else:
+                errors.append({"field": field, "error": "Field not found"})
+                found = False
+                break
+        if found:
+            actual = TYPE_MAP.get(type(value), type(value).__name__)
+            if expected_type == "number" and actual in ("integer", "number"):
+                continue
+            if actual != expected_type:
+                errors.append({"field": field, "expected": expected_type, "actual": actual})
+    return {"valid": len(errors) == 0, "errors": errors, "fields_checked": len(type_spec)}
+
+
+if __name__ == "__main__":
+    mcp.run()

schema_validator_ai_mcp-1.0.0/smithery.yaml

@@ -0,0 +1,41 @@
+name: schema-validator-ai-mcp
+description: Schema Validator Ai automation via MCP. Includes validate json schema,
+  generate schema, convert openapi. By MEOK AI Labs.
+version: 1.0.0
+tools:
+- name: validate_json_schema
+  description: Validate JSON data against a JSON Schema.
+  parameters:
+  - name: data_json
+    type: string
+    required: true
+  - name: schema_json
+    type: string
+    required: true
+- name: generate_schema
+  description: Generate a JSON Schema from example JSON data.
+  parameters:
+  - name: data_json
+    type: string
+    required: true
+  - name: title
+    type: string
+    required: false
+- name: convert_openapi
+  description: Extract and convert schemas from an OpenAPI specification.
+  parameters:
+  - name: openapi_json
+    type: string
+    required: true
+  - name: extract_schemas
+    type: boolean
+    required: false
+- name: validate_types
+  description: Validate that JSON data fields match expected types.
+  parameters:
+  - name: data_json
+    type: string
+    required: true
+  - name: type_spec
+    type: object
+    required: true

schema_validator_ai_mcp-1.0.0/tests/test_server.py

@@ -0,0 +1,55 @@
+import os
+import sys
+import unittest
+
+# Ensure shared auth middleware is available
+sys.path.insert(0, os.path.expanduser("~/clawd/meok-labs-engine/shared"))
+os.chdir(os.path.dirname(os.path.abspath(__file__)) + "/..")
+
+
+class TestMCPImport(unittest.TestCase):
+    def test_import_server(self):
+        """Server module must import without errors."""
+        import server  # noqa: F401
+
+    def test_mcp_or_server_object_exists(self):
+        """FastMCP servers export 'mcp'; low-level servers export 'server'."""
+        import server as srv
+        self.assertTrue(
+            hasattr(srv, "mcp") or hasattr(srv, "server"),
+            "Expected 'mcp' or 'server' object in server.py",
+        )
+
+
+class TestAuthMiddleware(unittest.TestCase):
+    def test_check_access_allows_empty_key_as_free_tier(self):
+        """Empty API key maps to FREE tier and is allowed."""
+        from auth_middleware import check_access, Tier
+        allowed, msg, tier = check_access("")
+        self.assertTrue(allowed)
+        self.assertEqual(tier, Tier.FREE)
+        self.assertIsInstance(msg, str)
+
+    def test_check_access_returns_tuple(self):
+        """check_access must return a 3-tuple."""
+        from auth_middleware import check_access
+        result = check_access("")
+        self.assertIsInstance(result, tuple)
+        self.assertEqual(len(result), 3)
+
+
+class TestHealthEndpoint(unittest.TestCase):
+    def test_health_url_resolves(self):
+        """Wrapper must expose /health."""
+        import urllib.request
+        # Note: this test requires the wrapper to be running on port 8000.
+        # It is skipped in CI unless the server is active.
+        try:
+            resp = urllib.request.urlopen("http://localhost:8000/health", timeout=2)
+            self.assertEqual(resp.status, 200)
+        except Exception as e:
+            self.skipTest(f"Server not running: {e}")
+
+
+if __name__ == "__main__":
+    unittest.main()