openapi-to-mcp-cli 0.9.2__tar.gz → 0.9.3__tar.gz

{openapi_to_mcp_cli-0.9.2 → openapi_to_mcp_cli-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: openapi-to-mcp-cli
-Version: 0.9.2
+Version: 0.9.3
 Summary: Generate, run, and test Node.js/TypeScript MCP servers from OpenAPI specifications.
 Project-URL: Homepage, https://github.com/nihal1294/openapi-to-mcp
 Project-URL: Documentation, https://nihal1294.github.io/openapi-to-mcp/
@@ -75,8 +75,8 @@ Run directly from a spec:
 
 ```bash
 openapi-to-mcp run \
-  --openapi-json https://petstore.swagger.io/v2/swagger.json \
-  --target-api-base-url https://petstore.swagger.io/v2
+  --openapi-json https://petstore3.swagger.io/api/v3/openapi.json \
+  --target-api-base-url https://petstore3.swagger.io/api/v3
 ```
 
 Smoke-test a running server:
@@ -116,6 +116,10 @@ Public product documentation lives on GitHub Pages:
 - CLI E2E coverage for `generate`, `run`, and `test-server`
 - version-aware PyPI and GitHub Releases automation on `master`
 
+## Swagger 2 support
+
+Swagger 2 response-only operations and base URL fields are supported. Convert operations that use Swagger 2 body or form parameters, top-level parameter types, security definitions, or unsupported protocol overrides to OpenAPI 3 before generating. Run `openapi-to-mcp doctor` to identify the affected operation and field.
+
 ## Development
 
 For repository-local workflows, use the repo docs directly:

{openapi_to_mcp_cli-0.9.2 → openapi_to_mcp_cli-0.9.3}/README.md

@@ -45,8 +45,8 @@ Run directly from a spec:
 
 ```bash
 openapi-to-mcp run \
-  --openapi-json https://petstore.swagger.io/v2/swagger.json \
-  --target-api-base-url https://petstore.swagger.io/v2
+  --openapi-json https://petstore3.swagger.io/api/v3/openapi.json \
+  --target-api-base-url https://petstore3.swagger.io/api/v3
 ```
 
 Smoke-test a running server:
@@ -86,6 +86,10 @@ Public product documentation lives on GitHub Pages:
 - CLI E2E coverage for `generate`, `run`, and `test-server`
 - version-aware PyPI and GitHub Releases automation on `master`
 
+## Swagger 2 support
+
+Swagger 2 response-only operations and base URL fields are supported. Convert operations that use Swagger 2 body or form parameters, top-level parameter types, security definitions, or unsupported protocol overrides to OpenAPI 3 before generating. Run `openapi-to-mcp doctor` to identify the affected operation and field.
+
 ## Development
 
 For repository-local workflows, use the repo docs directly:

{openapi_to_mcp_cli-0.9.2 → openapi_to_mcp_cli-0.9.3}/openapi_to_mcp/adapters/generator.py

@@ -25,6 +25,7 @@ RUNTIME_TEMPLATE_NAMES = (
     "limiter",
     "observability",
     "performance_preset",
+    "query",
     "rate_limit",
     "resilience",
     "retry",

{openapi_to_mcp_cli-0.9.2 → openapi_to_mcp_cli-0.9.3}/openapi_to_mcp/commands/generation_service.py

@@ -65,6 +65,7 @@ def _map_tools(
         strict=behavior.strict,
         on_mapping_error=behavior.on_mapping_error,
         on_schema_error=behavior.on_schema_error,
+        policy_config=request.policy_config,
     )
     tools = apply_policy(mapper.map_tools(), request.policy_config)
     tools = apply_tool_grouping(tools, behavior.tool_grouping)

openapi_to_mcp_cli-0.9.3/openapi_to_mcp/common/spec_compatibility.py

@@ -0,0 +1,152 @@
+"""Compatibility checks shared by Swagger 2 diagnostics and mapping."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True)
+class SwaggerFinding:
+    """One Swagger 2 construct that cannot be represented by the mapper."""
+
+    field: str
+    location: str
+
+
+def swagger_operation_findings(
+    spec: dict[str, Any],
+    method: str,
+    path: str,
+    path_item: dict[str, Any],
+    operation: dict[str, Any],
+) -> list[SwaggerFinding]:
+    """Return unsupported Swagger 2 constructs used by one operation."""
+    if spec.get("swagger") != "2.0":
+        return []
+    base = f"paths.{path}"
+    findings = _parameter_findings(
+        spec, path_item.get("parameters"), f"{base}.parameters"
+    )
+    findings.extend(
+        _parameter_findings(
+            spec, operation.get("parameters"), f"{base}.{method.lower()}.parameters"
+        )
+    )
+    findings.extend(_security_findings(spec, operation, base, method))
+    findings.extend(_scheme_findings(spec, operation, base, method))
+    return list(dict.fromkeys(findings))
+
+
+def format_swagger_finding(finding: SwaggerFinding) -> str:
+    """Format one compatibility finding as an actionable mapping error."""
+    return (
+        f"unsupported Swagger 2 construct `{finding.field}` at `{finding.location}`; "
+        "convert this operation to OpenAPI 3 before generation."
+    )
+
+
+def _parameter_findings(
+    spec: dict[str, Any], parameters: object, location: str
+) -> list[SwaggerFinding]:
+    if not isinstance(parameters, list):
+        return []
+    findings: list[SwaggerFinding] = []
+    for index, candidate in enumerate(parameters):
+        parameter = _resolve_parameter(spec, candidate)
+        field_location = f"{location}[{index}]"
+        if not isinstance(parameter, dict):
+            if isinstance(candidate, dict) and "$ref" in candidate:
+                findings.append(SwaggerFinding("$ref", f"{field_location}.$ref"))
+            continue
+        parameter_in = parameter.get("in")
+        if parameter_in in {"body", "formData"}:
+            findings.append(
+                SwaggerFinding(f"in: {parameter_in}", f"{field_location}.in")
+            )
+        if (
+            parameter_in in {"path", "query", "header", "cookie"}
+            and "type" in parameter
+        ):
+            findings.append(SwaggerFinding("type", f"{field_location}.type"))
+    return findings
+
+
+def _resolve_parameter(
+    spec: dict[str, Any], candidate: object
+) -> dict[str, Any] | None:
+    if not isinstance(candidate, dict):
+        return None
+    current = candidate
+    for _ in range(20):
+        ref = current.get("$ref")
+        if ref is None:
+            return current
+        if not isinstance(ref, str):
+            return None
+        resolved = _resolve_local_ref(spec, ref)
+        if not isinstance(resolved, dict):
+            return None
+        current = resolved
+    return None
+
+
+def _resolve_local_ref(spec: dict[str, Any], ref: str) -> object:
+    if not ref.startswith("#/"):
+        return None
+    current: object = spec
+    for token in ref[2:].split("/"):
+        if not isinstance(current, dict):
+            return None
+        current = current.get(token.replace("~1", "/").replace("~0", "~"))
+    return current
+
+
+def _security_findings(
+    spec: dict[str, Any], operation: dict[str, Any], base: str, method: str
+) -> list[SwaggerFinding]:
+    location = (
+        f"{base}.{method.lower()}.security" if "security" in operation else "security"
+    )
+    requirements = (
+        operation.get("security") if "security" in operation else spec.get("security")
+    )
+    if not isinstance(requirements, list) or not requirements:
+        return []
+    definitions = spec.get("securityDefinitions")
+    names = {
+        name
+        for item in requirements
+        if isinstance(item, dict)
+        for name in item
+        if isinstance(name, str)
+    }
+    if not names:
+        return []
+    field = (
+        "securityDefinitions"
+        if isinstance(definitions, dict) and names & definitions.keys()
+        else "security"
+    )
+    return [SwaggerFinding(field, location)]
+
+
+def _scheme_findings(
+    spec: dict[str, Any], operation: dict[str, Any], base: str, method: str
+) -> list[SwaggerFinding]:
+    selected_scheme = _document_scheme(spec)
+    if selected_scheme not in {"http", "https"}:
+        return [SwaggerFinding("schemes", "schemes[0]")]
+    if "schemes" not in operation:
+        return []
+    operation_schemes = operation.get("schemes")
+    if isinstance(operation_schemes, list) and selected_scheme in operation_schemes:
+        return []
+    return [SwaggerFinding("schemes", f"{base}.{method.lower()}.schemes")]
+
+
+def _document_scheme(spec: dict[str, Any]) -> str:
+    schemes = spec.get("schemes")
+    if isinstance(schemes, list) and schemes and isinstance(schemes[0], str):
+        return schemes[0]
+    return "https"

{openapi_to_mcp_cli-0.9.2 → openapi_to_mcp_cli-0.9.3}/openapi_to_mcp/doctor/analyzer.py

@@ -10,6 +10,7 @@ from openapi_to_mcp.doctor.security import (
     referenced_scheme_names,
     security_schemes,
 )
+from openapi_to_mcp.doctor.swagger import report_swagger_compatibility
 from openapi_to_mcp.mapping.utils import generate_tool_name
 
 _HTTP_METHODS = {"get", "post", "put", "delete", "patch", "options", "head", "trace"}
@@ -39,6 +40,7 @@ class DoctorAnalyzer:
         self._check_missing_operation_ids(report, operations)
         self._check_generated_name_collisions(report, operations)
         self._check_security(report, operations)
+        report_swagger_compatibility(report, self.spec, operations)
         self._check_schema_unions(report, operations)
         return report
 
@@ -123,12 +125,13 @@ class DoctorAnalyzer:
         operations: list[tuple[str, str, dict[str, Any]]],
     ) -> None:
         schemes = security_schemes(self.spec)
-        self._check_security_requirements(
-            report,
-            source=self.spec.get("security", []),
-            schemes=schemes,
-            location="security",
-        )
+        if any("security" not in operation for _, _, operation in operations):
+            self._check_security_requirements(
+                report,
+                source=self.spec.get("security", []),
+                schemes=schemes,
+                location="security",
+            )
         for method, path, operation in operations:
             security = operation.get("security")
             if security is None:

{openapi_to_mcp_cli-0.9.2 → openapi_to_mcp_cli-0.9.3}/openapi_to_mcp/doctor/security.py

@@ -13,10 +13,12 @@ if TYPE_CHECKING:
 def security_schemes(spec: dict[str, Any]) -> dict[str, Any]:
     """Return normalized OpenAPI security scheme definitions."""
     components = spec.get("components", {})
-    if not isinstance(components, dict):
-        return {}
-    schemes = components.get("securitySchemes", {})
-    return schemes if isinstance(schemes, dict) else {}
+    if isinstance(components, dict):
+        schemes = components.get("securitySchemes")
+        if isinstance(schemes, dict):
+            return schemes
+    definitions = spec.get("securityDefinitions", {})
+    return definitions if isinstance(definitions, dict) else {}
 
 
 def referenced_scheme_names(source: object) -> list[str]:

openapi_to_mcp_cli-0.9.3/openapi_to_mcp/doctor/swagger.py

@@ -0,0 +1,38 @@
+"""Swagger 2 compatibility diagnostics for doctor."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from openapi_to_mcp.common.spec_compatibility import swagger_operation_findings
+
+if TYPE_CHECKING:
+    from openapi_to_mcp.doctor.models import DoctorReport
+
+
+def report_swagger_compatibility(
+    report: DoctorReport,
+    spec: dict[str, Any],
+    operations: list[tuple[str, str, dict[str, Any]]],
+) -> None:
+    """Add one diagnostic for each unique unsupported Swagger 2 construct."""
+    paths = spec.get("paths", {})
+    if not isinstance(paths, dict):
+        return
+    seen = set()
+    for method, path, operation in operations:
+        path_item = paths.get(path)
+        if not isinstance(path_item, dict):
+            continue
+        for finding in swagger_operation_findings(
+            spec, method, path, path_item, operation
+        ):
+            if finding in seen:
+                continue
+            seen.add(finding)
+            report.add_error(
+                "unsupported_swagger_construct",
+                f"Swagger 2 `{finding.field}` cannot be faithfully generated.",
+                finding.location,
+                "Convert this operation to OpenAPI 3 before generating an MCP server.",
+            )

{openapi_to_mcp_cli-0.9.2 → openapi_to_mcp_cli-0.9.3}/openapi_to_mcp/mapping/mapper.py

@@ -1,10 +1,17 @@
 """Maps OpenAPI operations to MCP tool definitions."""
 
+from __future__ import annotations
+
 import logging
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from openapi_to_mcp.common import MappingError, SchemaError
 from openapi_to_mcp.common.error_policy import ErrorMode, resolve_error_mode
+from openapi_to_mcp.common.exceptions import PolicyConfigError
+from openapi_to_mcp.common.spec_compatibility import (
+    format_swagger_finding,
+    swagger_operation_findings,
+)
 from openapi_to_mcp.mapping.output_schema import extract_output_schema
 from openapi_to_mcp.mapping.tool_description import build_tool_description
 from openapi_to_mcp.mapping.tool_examples import (
@@ -13,12 +20,16 @@ from openapi_to_mcp.mapping.tool_examples import (
     build_input_examples,
 )
 from openapi_to_mcp.mapping.utils import generate_tool_name
+from openapi_to_mcp.policy.swagger import effective_swagger_findings
 from openapi_to_mcp.schema.converter import (
     SchemaConverter,
     openapi_schema_to_json_schema,
 )
 from openapi_to_mcp.schema.handlers.reference import ReferenceHandler
 
+if TYPE_CHECKING:
+    from openapi_to_mcp.policy.models import PolicyConfig
+
 logger = logging.getLogger(__name__)
 
 
@@ -32,6 +43,7 @@ class Mapper:
         strict: bool = True,
         on_mapping_error: ErrorMode | None = None,
         on_schema_error: ErrorMode | None = None,
+        policy_config: PolicyConfig | None = None,
     ) -> None:
         """
         Initialize the mapper with the loaded OpenAPI spec.
@@ -48,6 +60,7 @@ class Mapper:
             raise MappingError(err_msg)
         self.spec = spec
         self.strict = strict
+        self.policy_config = policy_config
         self.on_mapping_error = resolve_error_mode(on_mapping_error, strict=strict)
         self.on_schema_error = resolve_error_mode(on_schema_error, strict=strict)
         self.mcp_tools: list[dict[str, Any]] = []
@@ -109,16 +122,42 @@ class Mapper:
                         operation,
                         merged_parameters,
                     )
+                    self._raise_if_unsupported_swagger(
+                        path_item, operation, tool_definition
+                    )
+                    self._register_tool_name(
+                        operation.get("operationId")
+                        or generate_tool_name(method, path),
+                        tool_definition["name"],
+                    )
                     self.mcp_tools.append(tool_definition)
                 except SchemaError as exc:
                     self._handle_schema_error(method, path, exc)
-                except MappingError as exc:
-                    self._handle_mapping_error(method, path, exc)
+                except PolicyConfigError:
+                    raise
                 except Exception as exc:  # noqa: BLE001
                     self._handle_mapping_error(method, path, exc)
 
         return self.mcp_tools
 
+    def _raise_if_unsupported_swagger(
+        self,
+        path_item: dict[str, Any],
+        operation: dict[str, Any],
+        tool: dict[str, Any],
+    ) -> None:
+        """Raise when this operation needs unsupported Swagger 2 behavior."""
+        findings = swagger_operation_findings(
+            self.spec,
+            tool["_original_method"],
+            tool["_original_path"],
+            path_item,
+            operation,
+        )
+        findings = effective_swagger_findings(findings, tool, self.policy_config)
+        if findings:
+            raise MappingError(format_swagger_finding(findings[0]))
+
     def get_report(self) -> dict[str, Any]:
         """Get mapper warnings and skipped operations for generation report."""
         return {
@@ -285,13 +324,9 @@ class Mapper:
 
         return (name, location)
 
-    def _ensure_unique_tool_name(self, candidate_name: str) -> str:
-        """Ensure mapped tool names are unique."""
+    def _resolve_unique_tool_name(self, candidate_name: str) -> str:
+        """Return a unique tool name without reserving it."""
         if candidate_name not in self._used_tool_names:
-            self._used_tool_names.add(candidate_name)
-            self._tool_name_counts[candidate_name] = max(
-                self._tool_name_counts.get(candidate_name, 0), 1
-            )
             return candidate_name
 
         if self.on_mapping_error == "fail":
@@ -306,12 +341,26 @@ class Mapper:
             if deduped_name not in self._used_tool_names:
                 break
 
-        self._tool_name_counts[candidate_name] = count
-        self._used_tool_names.add(deduped_name)
+        return deduped_name
+
+    def _register_tool_name(
+        self,
+        candidate_name: str,
+        tool_name: str,
+    ) -> None:
+        """Reserve a tool name after the operation has been accepted."""
+        self._used_tool_names.add(tool_name)
+        if tool_name == candidate_name:
+            self._tool_name_counts[candidate_name] = max(
+                self._tool_name_counts.get(candidate_name, 0), 1
+            )
+            return
+
+        suffix = tool_name.removeprefix(f"{candidate_name}_")
+        self._tool_name_counts[candidate_name] = int(suffix)
         self._diagnostics.append(
-            f"Duplicate tool name '{candidate_name}' deduped to '{deduped_name}'."
+            f"Duplicate tool name '{candidate_name}' deduped to '{tool_name}'."
         )
-        return deduped_name
 
     def _process_parameters(
         self, parameters: list[dict[str, Any]], input_schema: dict[str, Any]
@@ -399,7 +448,7 @@ class Mapper:
             return None
 
         primary_content_type: str | None = None
-        body_schema_openapi: dict[str, Any] | None = None
+        body_schema_openapi: dict[str, Any] | bool | None = None
         primary_media: dict[str, Any] | None = None
 
         if "application/json" in content and isinstance(
@@ -419,7 +468,7 @@ class Mapper:
                     primary_content_type,
                 )
 
-        if primary_content_type and isinstance(body_schema_openapi, dict):
+        if primary_content_type and isinstance(body_schema_openapi, (bool, dict)):
             body_schema_json = openapi_schema_to_json_schema(
                 body_schema_openapi, self.spec, raise_on_error=True
             )
@@ -469,7 +518,7 @@ class Mapper:
         candidate_name = operation.get("operationId") or generate_tool_name(
             method, path
         )
-        tool_name = self._ensure_unique_tool_name(candidate_name)
+        tool_name = self._resolve_unique_tool_name(candidate_name)
         description = build_tool_description(method, path, operation)
 
         input_schema: dict[str, Any] = {

{openapi_to_mcp_cli-0.9.2 → openapi_to_mcp_cli-0.9.3}/openapi_to_mcp/mapping/output_schema.py

@@ -117,6 +117,13 @@ def _supports_structured_output(schema: dict[str, Any]) -> bool:
     schema_type = schema.get("type")
     if schema_type == "object":
         return True
-    if schema_type in {"array", "string", "number", "integer", "boolean"}:
+    if isinstance(schema_type, list):
+        return bool(schema_type) and all(item == "object" for item in schema_type)
+    if isinstance(schema_type, str):
         return False
-    return any(key in schema for key in ("properties", "allOf"))
+    if "properties" in schema:
+        return True
+    all_of = schema.get("allOf")
+    return isinstance(all_of, list) and any(
+        isinstance(item, dict) and _supports_structured_output(item) for item in all_of
+    )

openapi_to_mcp_cli-0.9.3/openapi_to_mcp/policy/swagger.py

@@ -0,0 +1,64 @@
+"""Evaluate Swagger compatibility against policy-adjusted tool metadata."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from openapi_to_mcp.policy.applier import apply_policy
+
+if TYPE_CHECKING:
+    from openapi_to_mcp.common.spec_compatibility import SwaggerFinding
+    from openapi_to_mcp.policy.models import PolicyConfig
+
+
+def effective_swagger_findings(
+    findings: list[SwaggerFinding],
+    tool: dict[str, Any],
+    policy: PolicyConfig | None,
+) -> list[SwaggerFinding]:
+    """Keep findings that remain relevant after tool selection and auth overrides."""
+    if not findings or policy is None:
+        return findings
+    selected = apply_policy([tool], policy)
+    if not selected:
+        return []
+    if _has_supported_security_metadata(selected[0]):
+        return [
+            finding
+            for finding in findings
+            if finding.field not in {"security", "securityDefinitions"}
+        ]
+    return findings
+
+
+def _has_supported_security_metadata(tool: dict[str, Any]) -> bool:
+    requirements = tool.get("_original_security")
+    if requirements is None or requirements == []:
+        return True
+    schemes = tool.get("_original_security_schemes")
+    if not isinstance(requirements, list) or not isinstance(schemes, dict):
+        return False
+    return all(
+        isinstance(requirement, dict)
+        and all(_runtime_supports_scheme(schemes.get(name)) for name in requirement)
+        for requirement in requirements
+    )
+
+
+def _runtime_supports_scheme(scheme: object) -> bool:
+    """Match the scheme types handled by the generated auth resolver."""
+    if not isinstance(scheme, dict):
+        return False
+    scheme_type = str(scheme.get("type", "")).lower()
+    if scheme_type == "http":
+        return str(scheme.get("scheme", "")).lower() == "bearer"
+    if scheme_type == "apikey":
+        location = scheme.get("in")
+        name = scheme.get("name")
+        return (
+            isinstance(location, str)
+            and location.lower() in {"header", "query", "cookie"}
+            and isinstance(name, str)
+            and bool(name.strip())
+        )
+    return scheme_type in {"oauth2", "openidconnect"}

{openapi_to_mcp_cli-0.9.2 → openapi_to_mcp_cli-0.9.3}/openapi_to_mcp/schema/converter.py

@@ -87,7 +87,7 @@ class SchemaConverter:
 
     def convert(
         self,
-        openapi_schema: dict[str, Any] | None,
+        openapi_schema: object,
         *,
         include_internal_markers: bool = False,
     ) -> dict[str, Any]:
@@ -101,6 +101,8 @@ class SchemaConverter:
         Returns:
             The converted JSON Schema.
         """
+        if isinstance(openapi_schema, bool):
+            return {} if openapi_schema else {"not": {}}
         if not isinstance(openapi_schema, dict):
             logger.debug(
                 "Invalid schema input provided to converter (expected dict). Returning empty schema."
@@ -177,7 +179,7 @@ class SchemaConverter:
 
 
 def openapi_schema_to_json_schema(
-    openapi_schema: dict[str, Any] | None,
+    openapi_schema: object,
     full_spec: dict[str, Any],
     *,
     raise_on_error: bool = False,

{openapi_to_mcp_cli-0.9.2 → openapi_to_mcp_cli-0.9.3}/openapi_to_mcp/schema/handlers/array_schema.py

@@ -3,7 +3,7 @@
 import logging
 from typing import Any
 
-from openapi_to_mcp.schema.handlers.base import SchemaHandler
+from openapi_to_mcp.schema.handlers.base import SchemaHandler, schema_has_type
 
 logger = logging.getLogger(__name__)
 
@@ -13,10 +13,9 @@ class ArraySchemaHandler(SchemaHandler):
 
     def can_handle(self, schema: dict[str, Any]) -> bool:
         """Check if this handler can process the given schema."""
-        schema_type = schema.get("type")
         # Handle explicit type=array or schemas with 'items'
         return isinstance(schema, dict) and (
-            schema_type == "array" or "items" in schema
+            schema_has_type(schema, "array") or "items" in schema
         )
 
     def handle(

{openapi_to_mcp_cli-0.9.2 → openapi_to_mcp_cli-0.9.3}/openapi_to_mcp/schema/handlers/base.py

@@ -8,6 +8,14 @@ logger = logging.getLogger(__name__)
 INTERNAL_CYCLIC_REFERENCE_MARKER = "_is_cyclic_reference"
 
 
+def schema_has_type(schema: dict[str, Any], expected_type: str) -> bool:
+    """Return whether a schema permits the expected JSON Schema type."""
+    schema_type = schema.get("type")
+    return schema_type == expected_type or (
+        isinstance(schema_type, list) and expected_type in schema_type
+    )
+
+
 class SchemaConverterProtocol(Protocol):
     """Protocol defining the interface for SchemaConverter.
 
@@ -17,7 +25,7 @@ class SchemaConverterProtocol(Protocol):
 
     def convert(
         self,
-        openapi_schema: dict[str, Any],
+        openapi_schema: object,
         *,
         include_internal_markers: bool = False,
     ) -> dict[str, Any]:

{openapi_to_mcp_cli-0.9.2 → openapi_to_mcp_cli-0.9.3}/openapi_to_mcp/schema/handlers/common.py

@@ -30,6 +30,8 @@ class CommonSchemaHandler(SchemaHandler):
             "description",
             "title",
             "default",
+            "const",
+            "enum",
             "example",
             "readOnly",
             "writeOnly",

{openapi_to_mcp_cli-0.9.2 → openapi_to_mcp_cli-0.9.3}/openapi_to_mcp/schema/handlers/composition.py

@@ -29,12 +29,12 @@ class CompositionHandler(SchemaHandler):
         for comp_key in ["allOf", "oneOf", "anyOf", "not"]:
             comp_value = openapi_schema.get(comp_key)
 
-            if comp_key == "not" and isinstance(comp_value, dict):
+            if comp_key == "not" and isinstance(comp_value, (bool, dict)):
                 # 'not' applies to a single schema
                 json_schema[comp_key] = self.converter.convert(comp_value)
             elif comp_key != "not" and isinstance(comp_value, list):
                 # Others apply to an array of schemas
-                valid_items = [s for s in comp_value if isinstance(s, dict)]
+                valid_items = [s for s in comp_value if isinstance(s, (bool, dict))]
                 if valid_items:
                     json_schema[comp_key] = [
                         self.converter.convert(s) for s in valid_items