@qingflow-tech/qingflow-cli 1.1.61-beta.5 → 1.1.61

package/src/qingflow_mcp/builder_facade/portals_schema.py

@@ -1,397 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-from copy import deepcopy
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any
-
-from jsonschema import Draft202012Validator, FormatChecker
-from referencing import Registry, Resource
-
-from .app_form_schema import compact_schema_errors, schema_error_message
-
-JSONObject = dict[str, Any]
-PORTALS_SCHEMA_ROOT = Path(__file__).with_name("schemas") / "portals"
-PORTALS_SUPPORTED_SCHEMA_KINDS = (
-    "summary",
-    "complete",
-    "chart",
-    "view",
-    "grid",
-    "filter",
-    "text",
-    "link",
-    "carousel",
-    "task",
-    "favourite",
-)
-
-
-class PortalsContractError(ValueError):
-    """Raised when a portals declaration violates the versioned schema contract."""
-
-    def __init__(self, error_code: str, message: str, *, path: str | None = None, details: JSONObject | None = None) -> None:
-        super().__init__(message)
-        self.error_code = error_code
-        self.message = message
-        self.path = path
-        self.details = details or {}
-
-
-def compact_none_values(value: Any) -> Any:
-    """Recursively drop None values so pydantic dumps match the JSON Schema contract."""
-    if isinstance(value, dict):
-        return {key: compact_none_values(item) for key, item in value.items() if item is not None}
-    if isinstance(value, list):
-        return [compact_none_values(item) for item in value]
-    return value
-
-
-@dataclass(frozen=True, slots=True)
-class PortalsSchemaContext:
-    """Resolved schema context for one portals schema version."""
-
-    schema_version: str
-    api_version: str
-    schemas: dict[str, JSONObject]
-    schema_files: dict[str, str]
-    ref_registry: Registry
-    supported_schema_kinds: tuple[str, ...]
-    contract_source: str
-    contract_version: str
-
-    @property
-    def summary_schema(self) -> JSONObject:
-        return self.schemas["summary"]
-
-    @property
-    def complete_schema(self) -> JSONObject:
-        return self.schemas["complete"]
-
-    def schema_for_kind(self, schema_kind: str) -> JSONObject:
-        requested = str(schema_kind or "").strip()
-        schema = self.schemas.get(requested)
-        if schema is not None:
-            return schema
-        raise PortalsContractError(
-            "UNSUPPORTED_SCHEMA_KIND",
-            f"unsupported portals schema kind: {requested}",
-            details={"supportedKinds": list(self.supported_schema_kinds)},
-        )
-
-    def _validate(self, payload: JSONObject, *, schema_kind: str) -> None:
-        schema = self.schema_for_kind(schema_kind)
-        validator = Draft202012Validator(schema, format_checker=FormatChecker(), registry=self.ref_registry)
-        errors = sorted(validator.iter_errors(payload), key=lambda item: (list(item.absolute_path), item.message))
-        if not errors:
-            return
-        compact_errors = compact_schema_errors(errors, 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 PortalsContractError(
-            "INVALID_SPEC",
-            schema_error_message(error),
-            path=pointer,
-            details={
-                "validator": error.validator,
-                "schemaPath": "/".join(str(part) for part in error.absolute_schema_path),
-                "schemaKind": schema_kind,
-            },
-        )
-
-    def validate_upsert(self, payload: JSONObject, *, schema_kind: str = "complete") -> None:
-        """Validate a single (alias-normalized) portal declaration."""
-        self._validate(payload, schema_kind=schema_kind)
-
-    def validate_declaration(self, payload: JSONObject, *, schema_kind: str = "complete") -> None:
-        """Validate one portal declaration used by ``portal_apply``."""
-        if not isinstance(payload, dict):
-            raise PortalsContractError("INVALID_SPEC", "portals declaration must be a JSON object", path="/")
-        self._validate(payload, schema_kind=schema_kind)
-
-
-class PortalsSchemaRegistry:
-    """Registry for versioned portals declaration schemas (mirrors ViewsSchemaRegistry)."""
-
-    def __init__(self, root: Path = PORTALS_SCHEMA_ROOT, *, enabled_versions: tuple[str, ...] | None = None) -> None:
-        self.root = root
-        self.manifest = self._read_json(root / "manifest.json")
-        versions = self.manifest.get("versions")
-        if not isinstance(versions, dict) or not versions:
-            raise RuntimeError("portals schema manifest must define versions")
-        env_versions = self._configured_versions()
-        defaults = tuple(
-            str(version)
-            for version, metadata in versions.items()
-            if isinstance(metadata, dict) and bool(metadata.get("enabledByDefault"))
-        )
-        configured = tuple(enabled_versions) if enabled_versions is not None else (env_versions or defaults)
-        self.stored_versions = tuple(str(version) for version in versions)
-        self.latest_version = str(self.manifest.get("latestVersion") or "")
-        self._stored_api_to_version: dict[str, str] = {}
-        for version, metadata in versions.items():
-            if not isinstance(metadata, dict):
-                raise RuntimeError(f"portals schema metadata must be an object: {version}")
-            api_version = str(metadata.get("apiVersion") or "")
-            if not api_version:
-                raise RuntimeError(f"portals schema version has no apiVersion: {version}")
-            if api_version in self._stored_api_to_version:
-                raise RuntimeError(f"duplicate portals apiVersion: {api_version}")
-            self._stored_api_to_version[api_version] = str(version)
-        self.enabled_versions = configured
-        if self.latest_version not in versions:
-            raise RuntimeError("portals latestVersion is not stored")
-        if self.latest_version not in self.enabled_versions:
-            raise RuntimeError("portals latestVersion must remain enabled")
-        self._contexts: dict[str, PortalsSchemaContext] = {}
-        self._api_to_version: dict[str, str] = {}
-        for version in self.enabled_versions:
-            metadata = versions.get(version)
-            if not isinstance(metadata, dict):
-                raise RuntimeError(f"enabled portals schema version is not stored: {version}")
-            api_version = str(metadata.get("apiVersion") or "")
-            schema_files = metadata.get("schemaFiles")
-            if not isinstance(schema_files, dict):
-                schema_files = {kind: f"{version}/{kind}.json" for kind in ("summary", "complete")}
-            supported_schema_kinds = tuple(str(item) for item in metadata.get("schemaKinds") or schema_files)
-            if not {"summary", "complete"}.issubset(supported_schema_kinds):
-                raise RuntimeError(f"portals schema version must support summary and complete kinds: {version}")
-            schemas: dict[str, JSONObject] = {}
-            paths: dict[str, Path] = {}
-            for name in supported_schema_kinds:
-                relative_path = schema_files.get(name)
-                if not isinstance(relative_path, str) or not relative_path:
-                    raise RuntimeError(f"portals schema kind has no schema file: {version}/{name}")
-                path = root / relative_path
-                schema = self._read_json(path)
-                schemas[name] = schema
-                paths[name] = path
-            ref_registry = Registry()
-            for name, schema in schemas.items():
-                schema_id = str(schema.get("$id") or "")
-                if version not in schema_id:
-                    raise RuntimeError(f"portals {name} schema $id mismatch for {version}: {schema_id}")
-                Draft202012Validator.check_schema(schema)
-                resource = Resource.from_contents(schema)
-                if schema_id:
-                    ref_registry = ref_registry.with_resource(schema_id, resource)
-                ref_registry = ref_registry.with_resource(paths[name].resolve().as_uri(), resource)
-            for name, schema in schemas.items():
-                self._validate_local_refs(schema, paths[name], schemas, paths)
-            context = PortalsSchemaContext(
-                version,
-                api_version,
-                schemas,
-                {name: str(schema_files[name]) for name in supported_schema_kinds},
-                ref_registry,
-                supported_schema_kinds,
-                str(metadata.get("contractSource") or "portal_apply"),
-                str(metadata.get("contractVersion") or version),
-            )
-            self._contexts[version] = context
-            self._api_to_version[api_version] = version
-
-    def schema(
-        self,
-        *,
-        schema_version: str | None = None,
-        schema_kind: str | None = None,
-    ) -> JSONObject:
-        context = self.resolve_schema_version(schema_version)
-        requested_kind = str(schema_kind or "summary").strip()
-        if requested_kind not in context.supported_schema_kinds:
-            raise PortalsContractError(
-                "UNSUPPORTED_SCHEMA_KIND",
-                f"unsupported portals schema kind: {requested_kind}",
-                details={"supportedKinds": list(context.supported_schema_kinds)},
-            )
-        schema, dependencies = self._bundle_schema(
-            context.schema_for_kind(requested_kind),
-            schema_path=(self.root / context.schema_files[requested_kind]),
-            schemas=context.schemas,
-            schema_files=context.schema_files,
-        )
-        return {
-            "schemaVersion": context.schema_version,
-            "apiVersion": context.api_version,
-            "latestVersion": self.latest_version,
-            "storedVersions": list(self.stored_versions),
-            "enabledVersions": list(self.enabled_versions),
-            "supportedSchemaKinds": list(context.supported_schema_kinds),
-            "schemaKind": requested_kind,
-            "schemaFile": context.schema_files[requested_kind],
-            "schemaBundled": bool(dependencies),
-            "schemaDependencies": dependencies,
-            "schema": schema,
-        }
-
-    @classmethod
-    def _bundle_schema(
-        cls,
-        schema: JSONObject,
-        *,
-        schema_path: Path,
-        schemas: dict[str, JSONObject],
-        schema_files: dict[str, str],
-    ) -> tuple[JSONObject, list[str]]:
-        """Inline reachable cross-file definitions for standalone consumers."""
-        bundled = deepcopy(schema)
-        definitions = bundled.get("$defs")
-        if not isinstance(definitions, dict):
-            definitions = {}
-        dependencies: set[str] = set()
-        # schema_path is <root>/<version>/components/<file> or <root>/<version>/<file>.
-        # Find the manifest root from the configured path instead of relying on
-        # a fixed components depth.
-        cls_root = schema_path.parent
-        for candidate in schema_path.parents:
-            if (candidate / "manifest.json").is_file():
-                cls_root = candidate
-                break
-        paths = {name: cls_root / relative for name, relative in schema_files.items()}
-
-        def resolve_pointer(document: JSONObject, fragment: str, *, ref: str) -> Any:
-            target: Any = document
-            for raw_part in fragment[1:].split("/") if fragment.startswith("/") else ():
-                part = raw_part.replace("~1", "/").replace("~0", "~")
-                if not isinstance(target, dict) or part not in target:
-                    raise RuntimeError(f"portals schema contains a dangling $ref in {schema_path}: {ref}")
-                target = target[part]
-            return target
-
-        pending: list[tuple[str, JSONObject, Path]] = []
-
-        def add_definition(name: str, source: JSONObject, source_path: Path) -> None:
-            if name in definitions:
-                return
-            source_definitions = source.get("$defs")
-            if not isinstance(source_definitions, dict) or name not in source_definitions:
-                raise RuntimeError(f"portals schema references an unknown definition: {name}")
-            definitions[name] = deepcopy(source_definitions[name])
-            pending.append((name, source, source_path))
-
-        def rewrite(value: Any, source: JSONObject, source_path: Path) -> None:
-            if isinstance(value, dict):
-                ref = value.get("$ref")
-                if isinstance(ref, str):
-                    ref_file, _, fragment = ref.partition("#")
-                    target_source = source
-                    target_path = source_path
-                    if ref_file:
-                        target_path = (source_path.parent / ref_file).resolve()
-                        target_name = next(
-                            (name for name, path in paths.items() if path.resolve() == target_path),
-                            None,
-                        )
-                        if target_name is None:
-                            raise RuntimeError(f"portals schema contains an external $ref in {source_path}: {ref}")
-                        target_source = schemas[target_name]
-                        dependencies.add(schema_files[target_name])
-                        value["$ref"] = f"#{fragment}"
-                    local_ref = str(value["$ref"])
-                    if local_ref.startswith("#/$defs/"):
-                        name = local_ref.removeprefix("#/$defs/").split("/", 1)[0]
-                        add_definition(name, target_source, target_path)
-                    else:
-                        resolve_pointer(target_source, fragment, ref=ref)
-                for child in value.values():
-                    rewrite(child, source, source_path)
-            elif isinstance(value, list):
-                for child in value:
-                    rewrite(child, source, source_path)
-
-        for key, value in bundled.items():
-            if key != "$defs":
-                rewrite(value, schema, schema_path)
-        while pending:
-            name, source, source_path = pending.pop()
-            rewrite(definitions[name], source, source_path)
-        if definitions:
-            bundled["$defs"] = definitions
-        return bundled, sorted(dependencies)
-
-    def resolve_schema_version(self, schema_version: str | None) -> PortalsSchemaContext:
-        version = str(schema_version or self.latest_version).strip()
-        if version not in self.stored_versions:
-            raise self._version_error("UNSUPPORTED_SCHEMA_VERSION", version)
-        if version not in self.enabled_versions:
-            raise self._version_error("SCHEMA_VERSION_DISABLED", version)
-        return self._contexts[version]
-
-    def resolve_api_version(self, api_version: str) -> PortalsSchemaContext:
-        version = self._api_to_version.get(api_version)
-        if version is not None:
-            return self._contexts[version]
-        stored = self._stored_api_to_version.get(api_version)
-        if stored is not None:
-            raise self._version_error("SCHEMA_VERSION_DISABLED", stored)
-        raise self._version_error("UNSUPPORTED_SCHEMA_VERSION", api_version)
-
-    def _version_error(self, error_code: str, requested: str) -> PortalsContractError:
-        return PortalsContractError(
-            error_code,
-            f"unsupported portals schema selection: {requested}",
-            details={
-                "requestedVersion": requested,
-                "latestVersion": self.latest_version,
-                "storedVersions": list(self.stored_versions),
-                "enabledVersions": list(self.enabled_versions),
-            },
-        )
-
-    @staticmethod
-    def _read_json(path: Path) -> JSONObject:
-        value = json.loads(path.read_text(encoding="utf-8"))
-        if not isinstance(value, dict):
-            raise RuntimeError(f"portals schema artifact must be an object: {path}")
-        return value
-
-    @staticmethod
-    def _validate_local_refs(
-        document: JSONObject,
-        path: Path,
-        documents: dict[str, JSONObject],
-        paths: dict[str, Path],
-    ) -> None:
-        stack: list[Any] = [document]
-        while stack:
-            value = stack.pop()
-            if isinstance(value, dict):
-                ref = value.get("$ref")
-                if ref is not None:
-                    if not isinstance(ref, str):
-                        raise RuntimeError(f"portals schema contains an invalid $ref in {path}: {ref}")
-                    ref_file, _, fragment = ref.partition("#")
-                    target_document = document
-                    if ref_file:
-                        target_path = (path.parent / ref_file).resolve()
-                        if target_path not in {item.resolve() for item in paths.values()}:
-                            raise RuntimeError(f"portals schema contains an external $ref in {path}: {ref}")
-                        target_name = next(name for name, item in paths.items() if item.resolve() == target_path)
-                        target_document = documents[target_name]
-                    target: Any = target_document
-                    for raw_part in fragment[1:].split("/") if fragment.startswith("/") else ():
-                        part = raw_part.replace("~1", "/").replace("~0", "~")
-                        if not isinstance(target, dict) or part not in target:
-                            raise RuntimeError(f"portals schema contains a dangling $ref in {path}: {ref}")
-                        target = target[part]
-                stack.extend(value.values())
-            elif isinstance(value, list):
-                stack.extend(value)
-
-    @staticmethod
-    def _configured_versions() -> tuple[str, ...]:
-        raw = os.environ.get("QINGFLOW_PORTALS_SCHEMA_VERSIONS", "")
-        return tuple(part.strip() for part in raw.split(",") if part.strip())
-
-
-_REGISTRY: PortalsSchemaRegistry | None = None
-
-
-def portals_schema_registry() -> PortalsSchemaRegistry:
-    global _REGISTRY
-    if _REGISTRY is None:
-        _REGISTRY = PortalsSchemaRegistry()
-    return _REGISTRY

package/src/qingflow_mcp/builder_facade/schemas/app_form/v1alpha1/fields/ai_content_classification.json

@@ -1,146 +0,0 @@
-{
-  "$defs": {
-    "EmptyConfig": {
-      "additionalProperties": false,
-      "description": "该字段类型没有特殊配置。",
-      "type": "object"
-    },
-    "FieldCommon": {
-      "allOf": [
-        {
-          "if": {
-            "properties": {
-              "defaultType": {
-                "const": 2
-              }
-            },
-            "required": [
-              "defaultType"
-            ]
-          },
-          "then": {
-            "properties": {
-              "defaultValue": {
-                "type": "null"
-              }
-            }
-          }
-        },
-        {
-          "if": {
-            "properties": {
-              "defaultType": {
-                "const": 3
-              }
-            },
-            "required": [
-              "defaultType"
-            ]
-          },
-          "then": {
-            "properties": {
-              "defaultValue": {
-                "minLength": 1,
-                "type": [
-                  "string",
-                  "null"
-                ]
-              }
-            }
-          }
-        }
-      ],
-      "anyOf": [
-        {
-          "required": [
-            "queId"
-          ]
-        },
-        {
-          "required": [
-            "name"
-          ]
-        }
-      ],
-      "description": "顶层业务字段的公共属性;字段类型由 TopField 的判别分支定义。",
-      "properties": {
-        "beingRequired": {
-          "description": "该字段是否必填;缺失时保留已有字段当前值。",
-          "type": "boolean"
-        },
-        "defaultType": {
-          "default": 1,
-          "description": "默认值类型,与 defaultValue 联动;1 表示静态值,2 表示关联/绑定值且 defaultValue 只能省略或为 null,3 表示公式值且提供 defaultValue 时必须为非空公式文本。省略 defaultType 但提供 defaultValue 时按 1 处理。",
-          "enum": [
-            1,
-            2,
-            3
-          ],
-          "type": "integer"
-        },
-        "defaultValue": {
-          "$ref": "#/$defs/ScalarDefaultValue",
-          "description": "普通字段的默认值;后端 queDefaultValue 为字符串,因此数字等字面量也必须以字符串传入。defaultType 为 1 时表示静态文本,为 3 时表示公式文本,为 2 时不携带字面量默认值。表格、地址、附件、引用等结构化默认值必须放在具体字段 config.defaultValues。显式 null 表示清除默认值。"
-        },
-        "name": {
-          "description": "字段展示名称;新增字段必填,已有字段可在携带 queId 时省略;同父级允许同名(后端以 queId 为字段身份),配置引用建议携带 queId。",
-          "minLength": 1,
-          "type": "string"
-        },
-        "queId": {
-          "description": "已有字段的后端 ID;更新时用于精确定位并复用,新增字段通常省略。",
-          "minimum": 1,
-          "type": "integer"
-        },
-        "questionDescription": {
-          "description": "字段说明;null 或空字符串表示清空。",
-          "type": [
-            "string",
-            "null"
-          ]
-        },
-        "questionType": {
-          "description": "字段类型;具体可用值由当前字段详情 Schema 的判别分支约束。",
-          "type": "string"
-        },
-        "width": {
-          "description": "字段在所在行的宽度百分比(1-100 整数);后端不校验总和与取值,存量数据存在 33/34 等三等分布值。",
-          "maximum": 100,
-          "minimum": 1,
-          "type": "integer"
-        }
-      },
-      "type": "object"
-    },
-    "ScalarDefaultValue": {
-      "description": "后端 queDefaultValue 支持的普通字段默认值;非空值必须是字符串,显式 null 表示清除默认值。数字和布尔值应先转换为字符串,对象和数组必须使用字段专用默认值配置。defaultType 为 3 时,通过 AppForm Schema 查询能力传入当前 schema_version 并设置 schema_kind=formula 获取公式语法、字段引用、运算符和全部函数说明;CLI 使用 builder app-form schema --schema-kind formula。需要配置结构化默认值时,传入当前 schema_version,并将字段的 questionType 作为 field_type 获取字段详细 Schema。",
-      "type": [
-        "null",
-        "string"
-      ]
-    }
-  },
-  "$id": "https://builder.qingflow.com/schemas/app-form-apply/v1alpha1/fields/ai_content_classification.json",
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "allOf": [
-    {
-      "$ref": "#/$defs/FieldCommon"
-    },
-    {
-      "properties": {
-        "config": {
-          "$ref": "#/$defs/EmptyConfig"
-        },
-        "questionType": {
-          "const": "ai_content_classification"
-        }
-      },
-      "required": [
-        "questionType"
-      ]
-    }
-  ],
-  "title": "Qingflow AppForm v1alpha1 ai_content_classification field",
-  "type": "object",
-  "unevaluatedProperties": false
-}

package/src/qingflow_mcp/builder_facade/schemas/app_form/v1alpha1/fields/ai_content_extraction.json

@@ -1,146 +0,0 @@
-{
-  "$defs": {
-    "EmptyConfig": {
-      "additionalProperties": false,
-      "description": "该字段类型没有特殊配置。",
-      "type": "object"
-    },
-    "FieldCommon": {
-      "allOf": [
-        {
-          "if": {
-            "properties": {
-              "defaultType": {
-                "const": 2
-              }
-            },
-            "required": [
-              "defaultType"
-            ]
-          },
-          "then": {
-            "properties": {
-              "defaultValue": {
-                "type": "null"
-              }
-            }
-          }
-        },
-        {
-          "if": {
-            "properties": {
-              "defaultType": {
-                "const": 3
-              }
-            },
-            "required": [
-              "defaultType"
-            ]
-          },
-          "then": {
-            "properties": {
-              "defaultValue": {
-                "minLength": 1,
-                "type": [
-                  "string",
-                  "null"
-                ]
-              }
-            }
-          }
-        }
-      ],
-      "anyOf": [
-        {
-          "required": [
-            "queId"
-          ]
-        },
-        {
-          "required": [
-            "name"
-          ]
-        }
-      ],
-      "description": "顶层业务字段的公共属性;字段类型由 TopField 的判别分支定义。",
-      "properties": {
-        "beingRequired": {
-          "description": "该字段是否必填;缺失时保留已有字段当前值。",
-          "type": "boolean"
-        },
-        "defaultType": {
-          "default": 1,
-          "description": "默认值类型,与 defaultValue 联动;1 表示静态值,2 表示关联/绑定值且 defaultValue 只能省略或为 null,3 表示公式值且提供 defaultValue 时必须为非空公式文本。省略 defaultType 但提供 defaultValue 时按 1 处理。",
-          "enum": [
-            1,
-            2,
-            3
-          ],
-          "type": "integer"
-        },
-        "defaultValue": {
-          "$ref": "#/$defs/ScalarDefaultValue",
-          "description": "普通字段的默认值;后端 queDefaultValue 为字符串,因此数字等字面量也必须以字符串传入。defaultType 为 1 时表示静态文本,为 3 时表示公式文本,为 2 时不携带字面量默认值。表格、地址、附件、引用等结构化默认值必须放在具体字段 config.defaultValues。显式 null 表示清除默认值。"
-        },
-        "name": {
-          "description": "字段展示名称;新增字段必填,已有字段可在携带 queId 时省略;同父级允许同名(后端以 queId 为字段身份),配置引用建议携带 queId。",
-          "minLength": 1,
-          "type": "string"
-        },
-        "queId": {
-          "description": "已有字段的后端 ID;更新时用于精确定位并复用,新增字段通常省略。",
-          "minimum": 1,
-          "type": "integer"
-        },
-        "questionDescription": {
-          "description": "字段说明;null 或空字符串表示清空。",
-          "type": [
-            "string",
-            "null"
-          ]
-        },
-        "questionType": {
-          "description": "字段类型;具体可用值由当前字段详情 Schema 的判别分支约束。",
-          "type": "string"
-        },
-        "width": {
-          "description": "字段在所在行的宽度百分比(1-100 整数);后端不校验总和与取值,存量数据存在 33/34 等三等分布值。",
-          "maximum": 100,
-          "minimum": 1,
-          "type": "integer"
-        }
-      },
-      "type": "object"
-    },
-    "ScalarDefaultValue": {
-      "description": "后端 queDefaultValue 支持的普通字段默认值;非空值必须是字符串,显式 null 表示清除默认值。数字和布尔值应先转换为字符串,对象和数组必须使用字段专用默认值配置。defaultType 为 3 时,通过 AppForm Schema 查询能力传入当前 schema_version 并设置 schema_kind=formula 获取公式语法、字段引用、运算符和全部函数说明;CLI 使用 builder app-form schema --schema-kind formula。需要配置结构化默认值时,传入当前 schema_version,并将字段的 questionType 作为 field_type 获取字段详细 Schema。",
-      "type": [
-        "null",
-        "string"
-      ]
-    }
-  },
-  "$id": "https://builder.qingflow.com/schemas/app-form-apply/v1alpha1/fields/ai_content_extraction.json",
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "allOf": [
-    {
-      "$ref": "#/$defs/FieldCommon"
-    },
-    {
-      "properties": {
-        "config": {
-          "$ref": "#/$defs/EmptyConfig"
-        },
-        "questionType": {
-          "const": "ai_content_extraction"
-        }
-      },
-      "required": [
-        "questionType"
-      ]
-    }
-  ],
-  "title": "Qingflow AppForm v1alpha1 ai_content_extraction field",
-  "type": "object",
-  "unevaluatedProperties": false
-}