@qingflow-tech/qingflow-cli 1.1.43-beta.2 → 1.1.43-beta.4

package/src/qingflow_mcp/builder_facade/app_form_schema.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass
 import json
 import os
 from pathlib import Path
-from typing import Any
+from typing import Any, Iterable
 
 from jsonschema import Draft202012Validator, FormatChecker
 
@@ -14,6 +14,116 @@ JSONObject = dict[str, Any]
 SCHEMA_ROOT = Path(__file__).with_name("schemas") / "app_form"
 
 
+def _discriminator_score(schema: Any, instance: Any, root_schema: Any = None, seen_refs: set[str] | None = None) -> int:
+    """Score a schema branch against its input discriminator values."""
+    if not isinstance(schema, dict) or not isinstance(instance, dict):
+        return 0
+    reference = schema.get("$ref")
+    if isinstance(reference, str) and reference.startswith("#/") and isinstance(root_schema, dict):
+        seen_refs = seen_refs or set()
+        if reference in seen_refs:
+            return 0
+        target: Any = root_schema
+        for part in reference[2:].split("/"):
+            if not isinstance(target, dict):
+                return 0
+            target = target.get(part.replace("~1", "/").replace("~0", "~"))
+        return _discriminator_score(target, instance, root_schema, seen_refs | {reference})
+    score = 0
+    properties = schema.get("properties")
+    if isinstance(properties, dict):
+        for key, constraint in properties.items():
+            if not isinstance(constraint, dict) or key not in instance:
+                continue
+            value = instance.get(key)
+            if "const" in constraint:
+                score += 3 if value == constraint["const"] else -3
+            elif isinstance(constraint.get("enum"), list):
+                score += 3 if value in constraint["enum"] else -3
+    for combinator in ("allOf", "anyOf", "oneOf"):
+        children = schema.get(combinator)
+        if not isinstance(children, list):
+            continue
+        child_scores = [_discriminator_score(child, instance, root_schema, seen_refs) for child in children]
+        if combinator == "allOf":
+            score += sum(child_score for child_score in child_scores if child_score > 0)
+        elif child_scores:
+            score += max(child_scores)
+    return score
+
+
+def _selected_combinator_children(error: Any, root_schema: Any = None) -> list[Any] | None:
+    """Return errors from the branch matching a known discriminator.
+
+    jsonschema flattens errors from nested ``allOf`` branches into the parent
+    combinator context, so branch identity is recovered from the schema path.
+    """
+    if not isinstance(error.schema, dict):
+        return None
+    branches = error.schema.get(error.validator)
+    if not isinstance(branches, list) or not branches:
+        return None
+    scores = [_discriminator_score(branch, error.instance, root_schema) for branch in branches]
+    best = max(scores)
+    if best <= 0:
+        return None
+    selected = {index for index, score in enumerate(scores) if score == best}
+    prefix = tuple(error.absolute_schema_path)
+    children = [
+        child
+        for child in error.context
+        if len(tuple(child.absolute_schema_path)) > len(prefix)
+        and tuple(child.absolute_schema_path)[: len(prefix)] == prefix
+        and tuple(child.absolute_schema_path)[len(prefix)] in selected
+    ]
+    return children or None
+
+
+def _iter_compact_schema_errors(error: Any, root_schema: Any = None) -> Iterable[Any]:
+    if error.validator in {"oneOf", "anyOf"}:
+        selected = _selected_combinator_children(error, root_schema)
+        if selected:
+            for child in selected:
+                yield from _iter_compact_schema_errors(child, root_schema)
+            return
+        yield error
+        return
+    if error.context:
+        for child in error.context:
+            yield from _iter_compact_schema_errors(child, root_schema)
+        return
+    yield error
+
+
+def compact_schema_errors(errors: Iterable[Any], root_schema: Any = None) -> list[Any]:
+    """Collapse polymorphic-schema noise while retaining actionable errors."""
+    flattened = [leaf for error in errors for leaf in _iter_compact_schema_errors(error, root_schema)]
+    descendant_paths = [tuple(error.absolute_path) for error in flattened]
+    result: list[Any] = []
+    seen: set[tuple[tuple[Any, ...], str, str]] = set()
+    for error in flattened:
+        path = tuple(error.absolute_path)
+        if error.validator == "unevaluatedProperties" and any(
+            len(other) > len(path) and other[: len(path)] == path for other in descendant_paths
+        ):
+            continue
+        key = (path, str(error.validator), schema_error_message(error))
+        if key in seen:
+            continue
+        seen.add(key)
+        result.append(error)
+    return result
+
+
+def schema_error_message(error: Any) -> str:
+    """Render a bounded, user-facing message for a JSON Schema error."""
+    if error.validator == "oneOf":
+        return "value is not valid under any of the given schemas"
+    if error.validator == "anyOf":
+        return "value is not valid under any of the given schemas"
+    return str(error.message)
+
+
 class AppFormContractError(ValueError):
     def __init__(self, error_code: str, message: str, *, path: str | None = None, details: JSONObject | None = None) -> None:
         super().__init__(message)
@@ -39,11 +149,12 @@ class AppFormSchemaContext:
         errors = sorted(validator.iter_errors(payload), key=lambda item: (list(item.absolute_path), item.message))
         if not errors:
             return
-        error = errors[0]
+        compact_errors = compact_schema_errors(errors, self.complete_schema)
+        error = compact_errors[0] if compact_errors else errors[0]
         pointer = "".join(f"/{str(part).replace('~', '~0').replace('/', '~1')}" for part in error.absolute_path) or "/"
         raise AppFormContractError(
             "INVALID_SPEC",
-            error.message,
+            schema_error_message(error),
             path=pointer,
             details={"validator": error.validator, "schemaPath": "/".join(str(part) for part in error.absolute_schema_path)},
         )