vellum-ai 0.12.17__py3-none-any.whl → 0.13.1__py3-none-any.whl

vellum_ee/workflows/display/tests/workflow_serialization/test_basic_templating_node_serialization.py

@@ -60,7 +60,8 @@ def test_serialize_workflow():
         "inputs": [],
         "data": {"label": "Entrypoint Node", "source_handle_id": "34069190-0942-4e0c-8700-b33b9dea4ea0"},
         "display_data": {"position": {"x": 0.0, "y": 0.0}},
-        "definition": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"], "bases": []},
+        "base": None,
+        "definition": None,
     }
 
     templating_node = workflow_raw_data["nodes"][1]
@@ -106,15 +107,13 @@ def test_serialize_workflow():
                 "output_type": "JSON",
             },
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "base": {
+                "name": "TemplatingNode",
+                "module": ["vellum", "workflows", "nodes", "core", "templating_node", "node"],
+            },
             "definition": {
                 "name": "ExampleTemplatingNode",
                 "module": ["tests", "workflows", "basic_templating_node", "workflow_with_json_input"],
-                "bases": [
-                    {
-                        "name": "TemplatingNode",
-                        "module": ["vellum", "workflows", "nodes", "core", "templating_node", "node"],
-                    }
-                ],
             },
         },
         templating_node,
@@ -152,13 +151,11 @@ def test_serialize_workflow():
                 }
             ],
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
-            "definition": {
+            "base": {
                 "name": "FinalOutputNode",
                 "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
-                "bases": [
-                    {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"], "bases": []}
-                ],
             },
+            "definition": None,
         },
         final_output_node,
         ignore_order=True,

vellum_ee/workflows/display/tests/workflow_serialization/test_basic_terminal_node_serialization.py

@@ -58,17 +58,8 @@ def test_serialize_workflow():
         "inputs": [],
         "data": {"label": "Entrypoint Node", "source_handle_id": "8b8d52a2-844f-44fe-a6c4-142fa70d391b"},
         "display_data": {"position": {"x": 0.0, "y": 0.0}},
-        "definition": {
-            "name": "BaseNode",
-            "module": [
-                "vellum",
-                "workflows",
-                "nodes",
-                "bases",
-                "base",
-            ],
-            "bases": [],
-        },
+        "base": None,
+        "definition": None,
     }
 
     final_output_node = workflow_raw_data["nodes"][1]
@@ -99,26 +90,12 @@ def test_serialize_workflow():
             }
         ],
         "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "base": {
+            "name": "FinalOutputNode",
+            "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
+        },
         "definition": {
             "name": "BasicFinalOutputNode",
-            "module": [
-                "tests",
-                "workflows",
-                "basic_final_output_node",
-                "workflow",
-            ],
-            "bases": [
-                {
-                    "name": "FinalOutputNode",
-                    "module": [
-                        "vellum",
-                        "workflows",
-                        "nodes",
-                        "displayable",
-                        "final_output_node",
-                        "node",
-                    ],
-                }
-            ],
+            "module": ["tests", "workflows", "basic_final_output_node", "workflow"],
         },
     }

vellum_ee/workflows/display/tests/workflow_serialization/test_basic_try_node_serialization.py

@@ -55,17 +55,8 @@ def test_serialize_workflow():
         "id": "c238508d-85ab-4644-8cbb-88eae457fe12",
         "type": "ENTRYPOINT",
         "inputs": [],
-        "definition": {
-            "bases": [],
-            "module": [
-                "vellum",
-                "workflows",
-                "nodes",
-                "bases",
-                "base",
-            ],
-            "name": "BaseNode",
-        },
+        "base": None,
+        "definition": None,
         "data": {
             "label": "Entrypoint Node",
             "source_handle_id": "04da0bb6-5b42-4dd1-a4e4-08f3ab03e1a3",

vellum_ee/workflows/display/tests/workflow_serialization/test_complex_terminal_node_serialization.py

@@ -77,17 +77,8 @@ def test_serialize_workflow__missing_final_output_node():
         "inputs": [],
         "data": {"label": "Entrypoint Node", "source_handle_id": "943ac183-d107-4604-aed1-619bd7fef09c"},
         "display_data": {"position": {"x": 0.0, "y": 0.0}},
-        "definition": {
-            "name": "BaseNode",
-            "module": [
-                "vellum",
-                "workflows",
-                "nodes",
-                "bases",
-                "base",
-            ],
-            "bases": [],
-        },
+        "base": None,
+        "definition": None,
     }
 
     passthrough_node = next(node for node in workflow_raw_data["nodes"] if node["type"] == "GENERIC")
@@ -123,27 +114,13 @@ def test_serialize_workflow__missing_final_output_node():
                     }
                 ],
                 "display_data": {"position": {"x": 0.0, "y": 0.0}},
+                "base": {
+                    "name": "FinalOutputNode",
+                    "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
+                },
                 "definition": {
                     "name": "FirstFinalOutputNode",
-                    "module": [
-                        "tests",
-                        "workflows",
-                        "complex_final_output_node",
-                        "missing_final_output_node",
-                    ],
-                    "bases": [
-                        {
-                            "name": "FinalOutputNode",
-                            "module": [
-                                "vellum",
-                                "workflows",
-                                "nodes",
-                                "displayable",
-                                "final_output_node",
-                                "node",
-                            ],
-                        }
-                    ],
+                    "module": ["tests", "workflows", "complex_final_output_node", "missing_final_output_node"],
                 },
             },
             {
@@ -176,7 +153,7 @@ def test_serialize_workflow__missing_final_output_node():
                     }
                 ],
                 "display_data": {"position": {"x": 0.0, "y": 0.0}},
-                "definition": {
+                "base": {
                     "name": "FinalOutputNode",
                     "module": [
                         "vellum",
@@ -186,20 +163,8 @@ def test_serialize_workflow__missing_final_output_node():
                         "final_output_node",
                         "node",
                     ],
-                    "bases": [
-                        {
-                            "name": "BaseNode",
-                            "module": [
-                                "vellum",
-                                "workflows",
-                                "nodes",
-                                "bases",
-                                "base",
-                            ],
-                            "bases": [],
-                        }
-                    ],
                 },
+                "definition": None,
             },
         ],
         final_output_nodes,

vellum_ee/workflows/display/utils/vellum.py

@@ -1,10 +1,8 @@
-import enum
-import json
-import typing
-from typing import Any, List, Union, cast
+from typing import Any, TypeVar
 
-from vellum import ChatMessage, SearchResult, SearchResultRequest, VellumVariableType
+from vellum.client.types.vellum_variable_type import VellumVariableType
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.nodes.displayable.bases.utils import primitive_to_vellum_value
 from vellum.workflows.references import OutputReference, WorkflowInputReference
 from vellum.workflows.references.execution_count import ExecutionCountReference
 from vellum.workflows.references.node import NodeReference
@@ -13,25 +11,19 @@ from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_var
 from vellum.workflows.vellum_client import create_vellum_client
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
 from vellum_ee.workflows.display.vellum import (
-    ChatHistoryVellumValue,
     ConstantValuePointer,
     ExecutionCounterData,
     ExecutionCounterPointer,
     InputVariableData,
     InputVariablePointer,
-    JsonVellumValue,
     NodeInputValuePointerRule,
     NodeOutputData,
     NodeOutputPointer,
-    NumberVellumValue,
-    SearchResultsVellumValue,
-    StringVellumValue,
-    VellumValue,
     WorkspaceSecretData,
     WorkspaceSecretPointer,
 )
 
-_T = typing.TypeVar("_T")
+_T = TypeVar("_T")
 
 
 def infer_vellum_variable_type(value: Any) -> VellumVariableType:
@@ -90,33 +82,3 @@ def create_node_input_value_pointer_rule(
         return ConstantValuePointer(type="CONSTANT_VALUE", data=vellum_value)
 
     raise ValueError(f"Unsupported descriptor type: {value.__class__.__name__}")
-
-
-def primitive_to_vellum_value(value: Any) -> VellumValue:
-    """Converts a python primitive to a VellumVariableValue"""
-
-    if isinstance(value, str):
-        return StringVellumValue(value=value)
-    elif isinstance(value, enum.Enum):
-        return StringVellumValue(value=value.value)
-    elif isinstance(value, (int, float)):
-        return NumberVellumValue(value=value)
-    elif isinstance(value, list) and (
-        all(isinstance(message, ChatMessage) for message in value)
-        or all(isinstance(message, ChatMessage) for message in value)
-    ):
-        chat_messages = cast(Union[List[ChatMessage], List[ChatMessage]], value)
-        return ChatHistoryVellumValue(value=chat_messages)
-    elif isinstance(value, list) and (
-        all(isinstance(search_result, SearchResultRequest) for search_result in value)
-        or all(isinstance(search_result, SearchResult) for search_result in value)
-    ):
-        search_results = cast(Union[List[SearchResultRequest], List[SearchResult]], value)
-        return SearchResultsVellumValue(value=search_results)
-
-    try:
-        json_value = json.dumps(value)
-    except json.JSONDecodeError:
-        raise ValueError(f"Unsupported variable type: {value.__class__.__name__}")
-
-    return JsonVellumValue(value=json.loads(json_value))

vellum_ee/workflows/display/vellum.py

@@ -1,11 +1,13 @@
 from dataclasses import dataclass, field
 from enum import Enum
 from uuid import UUID
-from typing import Any, List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union
 
 from pydantic import Field
 
-from vellum import ChatMessage, PromptParameters, SearchResult, SearchResultRequest, VellumVariable, VellumVariableType
+from vellum import PromptParameters, VellumVariable, VellumVariableType
+from vellum.client.types.array_vellum_value import ArrayVellumValue
+from vellum.client.types.vellum_value import VellumValue
 from vellum.core import UniversalBaseModel
 from vellum_ee.workflows.display.base import (
     EdgeDisplay,
@@ -47,12 +49,6 @@ class CodeResourceDefinition(UniversalBaseModel):
     module: List[str]
 
 
-class NodeDefinition(UniversalBaseModel):
-    name: str
-    module: List[str]
-    bases: List[CodeResourceDefinition]
-
-
 class WorkflowDisplayDataViewport(UniversalBaseModel):
     x: float = 0.0
     y: float = 0.0
@@ -146,45 +142,14 @@ class WorkflowNodeType(str, Enum):
     ERROR = "ERROR"
 
 
-class StringVellumValue(UniversalBaseModel):
-    type: Literal["STRING"] = "STRING"
-    value: str
-
-
-class NumberVellumValue(UniversalBaseModel):
-    type: Literal["NUMBER"] = "NUMBER"
-    value: Union[int, float]
-
-
-class ChatHistoryVellumValue(UniversalBaseModel):
-    type: Literal["CHAT_HISTORY"] = "CHAT_HISTORY"
-    value: Union[List[ChatMessage], List[ChatMessage]]
-
-
-class SearchResultsVellumValue(UniversalBaseModel):
-    type: Literal["SEARCH_RESULTS"] = "SEARCH_RESULTS"
-    value: Union[List[SearchResultRequest], List[SearchResult]]
-
-
-class JsonVellumValue(UniversalBaseModel):
-    type: Literal["JSON"] = "JSON"
-    value: Optional[Any] = None
-
-
-VellumValue = Union[
-    StringVellumValue,
-    NumberVellumValue,
-    ChatHistoryVellumValue,
-    SearchResultsVellumValue,
-    JsonVellumValue,
-]
-
-
 class ConstantValuePointer(UniversalBaseModel):
     type: Literal["CONSTANT_VALUE"] = "CONSTANT_VALUE"
     data: VellumValue
 
 
+ArrayVellumValue.model_rebuild()
+
+
 class NodeOutputData(UniversalBaseModel):
     node_id: str
     output_id: str
@@ -248,7 +213,8 @@ class BaseWorkflowNode(UniversalBaseModel):
     inputs: List[NodeInput]
     type: str
     display_data: Optional[NodeDisplayData] = None
-    definition: Optional[NodeDefinition] = None
+    base: CodeResourceDefinition
+    definition: CodeResourceDefinition
 
 
 class EntrypointNodeData(UniversalBaseModel):

vellum_ee/workflows/display/workflows/vellum_workflow_display.py

@@ -5,6 +5,7 @@ from typing import Dict, List, Optional, Type, cast
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.edges import Edge
 from vellum.workflows.nodes.bases import BaseNode
+from vellum.workflows.nodes.displayable.bases.utils import primitive_to_vellum_value
 from vellum.workflows.nodes.displayable.final_output_node import FinalOutputNode
 from vellum.workflows.nodes.utils import get_unadorned_node, get_unadorned_port, get_wrapped_node, has_wrapped_node
 from vellum.workflows.ports import Port
@@ -16,7 +17,7 @@ from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
 from vellum_ee.workflows.display.nodes.types import PortDisplay
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
-from vellum_ee.workflows.display.utils.vellum import infer_vellum_variable_type, primitive_to_vellum_value
+from vellum_ee.workflows.display.utils.vellum import infer_vellum_variable_type
 from vellum_ee.workflows.display.vellum import (
     EdgeVellumDisplay,
     EdgeVellumDisplayOverrides,
@@ -78,11 +79,6 @@ class VellumWorkflowDisplay(
         edges: JsonArray = []
 
         # Add a single synthetic node for the workflow entrypoint
-        base_node_definition: JsonObject = {
-            "name": BaseNode.__name__,
-            "module": cast(JsonArray, BaseNode.__module__.split(".")),
-            "bases": [],
-        }
         nodes.append(
             {
                 "id": str(self.display_context.workflow_display.entrypoint_node_id),
@@ -93,7 +89,8 @@ class VellumWorkflowDisplay(
                     "source_handle_id": str(self.display_context.workflow_display.entrypoint_node_source_handle_id),
                 },
                 "display_data": self.display_context.workflow_display.entrypoint_node_display.dict(),
-                "definition": base_node_definition,
+                "base": None,
+                "definition": None,
             },
         )
 
@@ -119,10 +116,9 @@ class VellumWorkflowDisplay(
         ]
         final_output_node_outputs = {node.Outputs.value for node in final_output_nodes}
         unreferenced_final_output_node_outputs = final_output_node_outputs.copy()
-        final_output_node_definition: JsonObject = {
+        final_output_node_base: JsonObject = {
             "name": FinalOutputNode.__name__,
             "module": cast(JsonArray, FinalOutputNode.__module__.split(".")),
-            "bases": [base_node_definition],
         }
 
         # Add a synthetic Terminal Node and track the Workflow's output variables for each Workflow output
@@ -171,7 +167,8 @@ class VellumWorkflowDisplay(
                         },
                         "inputs": [node_input.dict()],
                         "display_data": workflow_output_display.display_data.dict(),
-                        "definition": final_output_node_definition,
+                        "base": final_output_node_base,
+                        "definition": None,
                     }
                 )
 

vellum_ee/workflows/server/virtual_file_loader.py

@@ -10,7 +10,7 @@ class VirtualFileLoader(importlib.abc.Loader):
         return None  # use default module creation
 
     def exec_module(self, module):
-        if not self.is_package:
+        if not self.is_package or self.code:
             exec(self.code, module.__dict__)
 
 
@@ -26,13 +26,13 @@ class VirtualFileFinder(importlib.abc.MetaPathFinder, importlib.abc.Loader):
         key_name = "__init__" if fullname == self.namespace else fullname.replace(f"{self.namespace}.", "")
 
         files_key = f"{key_name.replace('.', '/')}.py"
-        if not self.files.get(files_key):
+        if self.files.get(files_key) is None:
             files_key = f"{key_name.replace('.', '/')}/__init__.py"
 
         file = self.files.get(files_key)
         is_package = "__init__" in files_key
 
-        if file:
+        if file is not None:
             return importlib.machinery.ModuleSpec(
                 prefixed_name,
                 VirtualFileLoader(file, is_package),

vellum/client/types/array_variable_value.py

@@ -1,27 +0,0 @@
-# This file was auto-generated by Fern from our API Definition.
-
-from __future__ import annotations
-from ..core.pydantic_utilities import UniversalBaseModel
-import typing
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
-import pydantic
-from ..core.pydantic_utilities import update_forward_refs
-
-
-class ArrayVariableValue(UniversalBaseModel):
-    type: typing.Literal["ARRAY"] = "ARRAY"
-    value: typing.Optional[typing.List["ArrayVariableValueItem"]] = None
-
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
-    else:
-
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow
-
-
-from .array_variable_value_item import ArrayVariableValueItem  # noqa: E402
-
-update_forward_refs(ArrayVariableValue)

vellum/client/types/array_variable_value_item.py

@@ -1,29 +0,0 @@
-# This file was auto-generated by Fern from our API Definition.
-
-from __future__ import annotations
-import typing
-from .string_variable_value import StringVariableValue
-from .number_variable_value import NumberVariableValue
-from .json_variable_value import JsonVariableValue
-from .error_variable_value import ErrorVariableValue
-from .function_call_variable_value import FunctionCallVariableValue
-from .image_variable_value import ImageVariableValue
-from .audio_variable_value import AudioVariableValue
-from .chat_history_variable_value import ChatHistoryVariableValue
-from .search_results_variable_value import SearchResultsVariableValue
-import typing
-
-if typing.TYPE_CHECKING:
-    from .array_variable_value import ArrayVariableValue
-ArrayVariableValueItem = typing.Union[
-    StringVariableValue,
-    NumberVariableValue,
-    JsonVariableValue,
-    ErrorVariableValue,
-    FunctionCallVariableValue,
-    ImageVariableValue,
-    AudioVariableValue,
-    ChatHistoryVariableValue,
-    SearchResultsVariableValue,
-    "ArrayVariableValue",
-]

vellum/client/types/audio_variable_value.py

@@ -1,25 +0,0 @@
-# This file was auto-generated by Fern from our API Definition.
-
-from ..core.pydantic_utilities import UniversalBaseModel
-import typing
-from .vellum_audio import VellumAudio
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
-import pydantic
-
-
-class AudioVariableValue(UniversalBaseModel):
-    """
-    A base Vellum primitive value representing audio.
-    """
-
-    type: typing.Literal["AUDIO"] = "AUDIO"
-    value: typing.Optional[VellumAudio] = None
-
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
-    else:
-
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow

vellum/client/types/chat_history_variable_value.py

@@ -1,21 +0,0 @@
-# This file was auto-generated by Fern from our API Definition.
-
-from ..core.pydantic_utilities import UniversalBaseModel
-import typing
-from .chat_message import ChatMessage
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
-import pydantic
-
-
-class ChatHistoryVariableValue(UniversalBaseModel):
-    type: typing.Literal["CHAT_HISTORY"] = "CHAT_HISTORY"
-    value: typing.Optional[typing.List[ChatMessage]] = None
-
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
-    else:
-
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow

vellum/client/types/error_variable_value.py

@@ -1,21 +0,0 @@
-# This file was auto-generated by Fern from our API Definition.
-
-from ..core.pydantic_utilities import UniversalBaseModel
-import typing
-from .vellum_error import VellumError
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
-import pydantic
-
-
-class ErrorVariableValue(UniversalBaseModel):
-    type: typing.Literal["ERROR"] = "ERROR"
-    value: typing.Optional[VellumError] = None
-
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
-    else:
-
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow

vellum/client/types/image_variable_value.py

@@ -1,25 +0,0 @@
-# This file was auto-generated by Fern from our API Definition.
-
-from ..core.pydantic_utilities import UniversalBaseModel
-import typing
-from .vellum_image import VellumImage
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
-import pydantic
-
-
-class ImageVariableValue(UniversalBaseModel):
-    """
-    A base Vellum primitive value representing an image.
-    """
-
-    type: typing.Literal["IMAGE"] = "IMAGE"
-    value: typing.Optional[VellumImage] = None
-
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
-    else:
-
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow

vellum/client/types/json_variable_value.py

@@ -1,20 +0,0 @@
-# This file was auto-generated by Fern from our API Definition.
-
-from ..core.pydantic_utilities import UniversalBaseModel
-import typing
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
-import pydantic
-
-
-class JsonVariableValue(UniversalBaseModel):
-    type: typing.Literal["JSON"] = "JSON"
-    value: typing.Optional[typing.Any] = None
-
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
-    else:
-
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow

vellum/client/types/number_variable_value.py

@@ -1,20 +0,0 @@
-# This file was auto-generated by Fern from our API Definition.
-
-from ..core.pydantic_utilities import UniversalBaseModel
-import typing
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
-import pydantic
-
-
-class NumberVariableValue(UniversalBaseModel):
-    type: typing.Literal["NUMBER"] = "NUMBER"
-    value: typing.Optional[float] = None
-
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
-    else:
-
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow

vellum/client/types/search_results_variable_value.py

@@ -1,21 +0,0 @@
-# This file was auto-generated by Fern from our API Definition.
-
-from ..core.pydantic_utilities import UniversalBaseModel
-import typing
-from .search_result import SearchResult
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
-import pydantic
-
-
-class SearchResultsVariableValue(UniversalBaseModel):
-    type: typing.Literal["SEARCH_RESULTS"] = "SEARCH_RESULTS"
-    value: typing.Optional[typing.List[SearchResult]] = None
-
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
-    else:
-
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow