vellum-ai 1.3.5__tar.gz → 1.3.7__tar.gz

{vellum_ai-1.3.5 → vellum_ai-1.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 1.3.5
+Version: 1.3.7
 Summary: 
 License: MIT
 Requires-Python: >=3.9,<4.0

{vellum_ai-1.3.5 → vellum_ai-1.3.7}/ee/vellum_ee/workflows/display/nodes/tests/test_base_node_display.py

@@ -100,3 +100,20 @@ def test_serialize_display_data():
         "position": {"x": 0.0, "y": 0.0},
         "comment": {"expanded": True, "value": "I hope this works"},
     }
+
+
+def test_serialize_node_label_with_pascal_case():
+    """
+    Tests that a node with PascalCase name serializes with proper title case label.
+    """
+
+    # GIVEN a node with a PascalCase name that includes common patterns
+    class MyCustomNode(BaseNode):
+        pass
+
+    # WHEN we serialize the node
+    node_display_class = get_node_display_class(MyCustomNode)
+    data = node_display_class().serialize(WorkflowDisplayContext())
+
+    # THEN the label should be converted to proper title case with spaces
+    assert data["label"] == "My Custom Node"

{vellum_ai-1.3.5 → vellum_ai-1.3.7}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_api_node_serialization.py

@@ -173,7 +173,7 @@ def test_serialize_workflow(vellum_client):
                 },
             ],
             "data": {
-                "label": "Simple A P I Node",
+                "label": "Simple API Node",
                 "error_output_id": None,
                 "source_handle_id": "7c33b4d3-9204-4bd5-9371-80ee34f83073",
                 "target_handle_id": "14b538a5-aedb-41f3-b579-039956b7c7ed",

{vellum_ai-1.3.5 → vellum_ai-1.3.7}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_parent_input.py

@@ -73,11 +73,15 @@ def test_serialize_workflow():
                                     "node_id": "8e89ae10-a709-45ec-89f8-242f92e4a83f",
                                     "node_output_id": "0cd09f0a-c142-4d5d-acc7-b93cd30ca58d",
                                 },
+                                "constant_input": {
+                                    "type": "CONSTANT_VALUE",
+                                    "value": {"type": "STRING", "value": "constant_input"},
+                                },
                             },
                             "forced": None,
                             "strict": None,
                         },
-                        "src": 'from vellum.workflows.utils.functions import use_tool_inputs\n\nfrom .inputs import ParentInputs\nfrom .nodes.dummy_node import DummyNode\n\n\n@use_tool_inputs(\n    parent_input=ParentInputs.parent_input,\n    dummy_input=DummyNode.Outputs.text,\n)\ndef get_string(parent_input: str, dummy_input: str, populated_input: str) -> str:\n    """\n    Get a string with the parent input, dummy input, and the populated input.\n    """\n    return f"This is the parent input: {parent_input}, this is the dummy input: {dummy_input}, and this is the populated input: {populated_input}"  # noqa: E501\n',  # noqa: E501
+                        "src": 'from vellum.workflows.utils.functions import use_tool_inputs\n\nfrom .inputs import ParentInputs\nfrom .nodes.dummy_node import DummyNode\n\n\n@use_tool_inputs(\n    parent_input=ParentInputs.parent_input,\n    dummy_input=DummyNode.Outputs.text,\n    constant_input="constant_input",\n)\ndef get_string(parent_input: str, dummy_input: str, constant_input: str, populated_input: str) -> str:\n    """\n    Get a string with the parent input, dummy input, and the populated input.\n    """\n    return f"parent input: {parent_input}, dummy input: {dummy_input}, constant input: {constant_input}, populated input: {populated_input}"  # noqa: E501\n',  # noqa: E501
                     }
                 ],
             },

{vellum_ai-1.3.5 → vellum_ai-1.3.7}/ee/vellum_ee/workflows/display/utils/expressions.py

@@ -6,8 +6,8 @@ from typing import TYPE_CHECKING, Any, Dict, List, cast
 
 from pydantic import BaseModel
 
-from vellum.client.types.function_definition import FunctionDefinition
 from vellum.client.types.logical_operator import LogicalOperator
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.expressions.accessor import AccessorExpression
 from vellum.workflows.expressions.add import AddExpression
@@ -244,7 +244,14 @@ def serialize_key(key: Any) -> str:
         return str(key)
 
 
+# Sentinel value to indicate a value should be omitted from serialization
+_UNDEFINED_SENTINEL: JsonObject = {"__undefined__": True}
+
+
 def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> JsonObject:
+    if value is undefined:
+        return _UNDEFINED_SENTINEL
+
     if isinstance(value, ConstantValueReference):
         return serialize_value(display_context, value._value)
 
@@ -315,7 +322,12 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
         }
 
     if isinstance(value, list):
-        serialized_items = [serialize_value(display_context, item) for item in value]
+        serialized_items = []
+        for item in value:
+            serialized_item = serialize_value(display_context, item)
+            if serialized_item != _UNDEFINED_SENTINEL:
+                serialized_items.append(serialized_item)
+
         if all(isinstance(item, dict) and item["type"] == "CONSTANT_VALUE" for item in serialized_items):
             constant_values = []
             for item in serialized_items:
@@ -346,14 +358,17 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
         return serialize_value(display_context, dict_value)
 
     if isinstance(value, dict):
-        serialized_entries: List[Dict[str, Any]] = [
-            {
-                "id": str(uuid4_from_hash(f"{key}|{val}")),
-                "key": serialize_key(key),
-                "value": serialize_value(display_context, val),
-            }
-            for key, val in value.items()
-        ]
+        serialized_entries: List[Dict[str, Any]] = []
+        for key, val in value.items():
+            serialized_val = serialize_value(display_context, val)
+            if serialized_val != _UNDEFINED_SENTINEL:
+                serialized_entries.append(
+                    {
+                        "id": str(uuid4_from_hash(f"{key}|{val}")),
+                        "key": serialize_key(key),
+                        "value": serialized_val,
+                    }
+                )
 
         # Check if all entries have constant values
         if all(entry["value"]["type"] == "CONSTANT_VALUE" for entry in serialized_entries):
@@ -423,6 +438,10 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
 
     if callable(value):
         function_definition = compile_function_definition(value)
+
+        name = function_definition.name
+        description = function_definition.description or ""
+
         inputs = getattr(value, "__vellum_inputs__", {})
 
         if inputs:
@@ -432,7 +451,9 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
 
             model_data = function_definition.model_dump()
             model_data["inputs"] = serialized_inputs
-            function_definition = FunctionDefinition.model_validate(model_data)
+            function_definition_data = model_data
+        else:
+            function_definition_data = function_definition.model_dump()
 
         source_path = inspect.getsourcefile(value)
         if source_path is not None:
@@ -447,9 +468,9 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
                 "type": "JSON",
                 "value": {
                     "type": "CODE_EXECUTION",
-                    "name": function_definition.name,
-                    "description": function_definition.description,
-                    "definition": function_definition.model_dump(),
+                    "name": name,
+                    "description": description,
+                    "definition": function_definition_data,
                     "src": source_code,
                 },
             },

{vellum_ai-1.3.5 → vellum_ai-1.3.7}/ee/vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -599,7 +599,7 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
 
             workflow_output_display = self.output_displays.get(workflow_output)
             workflow_output_displays[workflow_output] = (
-                workflow_output_display or self._generate_workflow_output_display(workflow_output, self._workflow)
+                workflow_output_display or self._generate_workflow_output_display(workflow_output)
             )
 
         return WorkflowDisplayContext(
@@ -688,14 +688,8 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
 
         return EntrypointDisplay(id=entrypoint_id, edge_display=edge_display)
 
-    def _generate_workflow_output_display(
-        self, output: OutputReference, workflow_class: Type[BaseWorkflow]
-    ) -> WorkflowOutputDisplay:
-        # TODO: use the output.id field instead once we add `__parent_class__` to BaseWorkflow.Outputs
-        output_id = workflow_class.__output_ids__.get(output.name) or uuid4_from_hash(
-            f"{self.workflow_id}|id|{output.name}"
-        )
-        return WorkflowOutputDisplay(id=output_id, name=output.name)
+    def _generate_workflow_output_display(self, output: OutputReference) -> WorkflowOutputDisplay:
+        return WorkflowOutputDisplay(id=output.id, name=output.name)
 
     def __init_subclass__(cls, **kwargs: Any) -> None:
         super().__init_subclass__(**kwargs)

{vellum_ai-1.3.5 → vellum_ai-1.3.7}/pyproject.toml

@@ -3,7 +3,7 @@ name = "vellum-ai"
 
 [tool.poetry]
 name = "vellum-ai"
-version = "1.3.5"
+version = "1.3.7"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-1.3.5 → vellum_ai-1.3.7}/src/vellum/client/README.md

@@ -232,3 +232,19 @@ client = Vellum(
 )
 ```
 
+## Contributing
+
+While we value open-source contributions to this SDK, this library is generated programmatically.
+Additions made directly to this library would have to be moved over to our generation code,
+otherwise they would be overwritten upon the next generated release. Feel free to open a PR as
+a proof of concept, but know that we will not be able to merge it as-is. We suggest opening
+an issue first to discuss with us!
+
+On the other hand, contributions to the README are always very welcome!
+## Open-Source vs. Paid
+
+This repo is available under the [MIT expat license](https://github.com/vellum-ai/vellum-python-sdks/blob/main/LICENSE), except
+for the `ee` directory (which has its [license here](https://github.com/vellum-ai/vellum-python-sdks/blob/main/ee/LICENSE)) if applicable.
+
+To learn more, [book a demo](https://www.vellum.ai/landing-pages/request-demo) or see our [pricing page](https://www.vellum.ai/pricing).
+

{vellum_ai-1.3.5 → vellum_ai-1.3.7}/src/vellum/client/core/client_wrapper.py

@@ -27,10 +27,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "vellum-ai/1.3.5",
+            "User-Agent": "vellum-ai/1.3.7",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.3.5",
+            "X-Fern-SDK-Version": "1.3.7",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

{vellum_ai-1.3.5 → vellum_ai-1.3.7}/src/vellum/plugins/vellum_mypy.py

@@ -20,6 +20,7 @@ from mypy.types import AnyType, CallableType, FunctionLike, Instance, Type as My
 
 TypeResolver = Callable[[str, List[MypyType]], MypyType]
 NODE_ATTRIBUTE_REGEX = r"^[a-z].*$"
+BASE_NODE_FULLNAME = "vellum.workflows.nodes.bases.base.BaseNode"
 
 DESCRIPTOR_PATHS: list[tuple[str, str, str]] = [
     (
@@ -28,12 +29,12 @@ DESCRIPTOR_PATHS: list[tuple[str, str, str]] = [
         r"^[^_].*$",
     ),
     (
-        "vellum.workflows.nodes.bases.base.BaseNode.ExternalInputs",
+        f"{BASE_NODE_FULLNAME}.ExternalInputs",
         "vellum.workflows.references.external_input.ExternalInputReference",
         r"^[^_].*$",
     ),
     (
-        "vellum.workflows.nodes.bases.base.BaseNode.Execution",
+        f"{BASE_NODE_FULLNAME}.Execution",
         "vellum.workflows.references.execution_count.ExecutionCountReference",
         r"^count$",
     ),
@@ -48,7 +49,7 @@ DESCRIPTOR_PATHS: list[tuple[str, str, str]] = [
         r"^[^_].*$",
     ),
     (
-        "vellum.workflows.nodes.bases.base.BaseNode",
+        BASE_NODE_FULLNAME,
         "vellum.workflows.references.node.NodeReference",
         NODE_ATTRIBUTE_REGEX,
     ),
@@ -163,7 +164,7 @@ class VellumMypyPlugin(Plugin):
         elif _is_subclass(ctx.cls.info, "vellum.workflows.nodes.displayable.final_output_node.node.FinalOutputNode"):
             self._dynamic_output_node_class_hook(ctx, "value")
 
-        if _is_subclass(ctx.cls.info, "vellum.workflows.nodes.bases.base.BaseNode"):
+        if _is_subclass(ctx.cls.info, BASE_NODE_FULLNAME):
             return self._base_node_class_hook(ctx)
 
         if _is_subclass(ctx.cls.info, "vellum.workflows.workflows.base.BaseWorkflow"):
@@ -241,6 +242,9 @@ class VellumMypyPlugin(Plugin):
         """
 
         for key, sym in ctx.cls.info.names.items():
+            if ctx.cls.info.fullname == BASE_NODE_FULLNAME:
+                continue
+
             if not isinstance(sym.node, Var):
                 continue
 
@@ -250,6 +254,7 @@ class VellumMypyPlugin(Plugin):
             type_ = sym.node.type
             if not type_:
                 continue
+
             sym.node.type = self._get_resolvable_type(
                 lambda fullname, types: ctx.api.named_type(fullname, types), type_
             )
@@ -301,7 +306,7 @@ class VellumMypyPlugin(Plugin):
                     and isinstance(arg.expr, MemberExpr)
                     and isinstance(arg.expr.expr, NameExpr)
                     and isinstance(arg.expr.expr.node, TypeInfo)
-                    and _is_subclass(arg.expr.expr.node, "vellum.workflows.nodes.bases.base.BaseNode")
+                    and _is_subclass(arg.expr.expr.node, BASE_NODE_FULLNAME)
                     and arg.expr.name == "Outputs"
                 ):
                     self._calls_with_nested_descriptor_expressions.add(call_expr)
@@ -548,7 +553,7 @@ class VellumMypyPlugin(Plugin):
         if not isinstance(ctx.default_return_type, Instance):
             return ctx.default_return_type
 
-        if not _is_subclass(ctx.default_return_type.type, "vellum.workflows.nodes.bases.base.BaseNode.Outputs"):
+        if not _is_subclass(ctx.default_return_type.type, f"{BASE_NODE_FULLNAME}.Outputs"):
             return ctx.default_return_type
 
         outputs_node = self._get_node_outputs_type_info(ctx)
@@ -677,9 +682,7 @@ class VellumMypyPlugin(Plugin):
 
         expr = ctx.context.callee.expr
         instance = ctx.api.get_expression_type(expr)
-        if not isinstance(instance, Instance) or not _is_subclass(
-            instance.type, "vellum.workflows.nodes.bases.base.BaseNode"
-        ):
+        if not isinstance(instance, Instance) or not _is_subclass(instance.type, BASE_NODE_FULLNAME):
             return None
 
         outputs_node = instance.type.names.get("Outputs")

vellum_ai-1.3.7/src/vellum/workflows/executable.py

@@ -0,0 +1,9 @@
+from uuid import UUID
+from typing import Dict
+
+from vellum.workflows.utils.uuids import uuid4_from_hash
+
+
+class BaseExecutable:
+    __id__: UUID = uuid4_from_hash(__qualname__)
+    __output_ids__: Dict[str, UUID] = {}

{vellum_ai-1.3.5 → vellum_ai-1.3.7}/src/vellum/workflows/graph/graph.py

@@ -96,6 +96,11 @@ class Graph:
     def from_edge(edge: Edge) -> "Graph":
         return Graph(entrypoints={edge.from_port}, edges=[edge], terminals={port for port in edge.to_node.Ports})
 
+    @staticmethod
+    def empty() -> "Graph":
+        """Create an empty graph with no entrypoints, edges, or terminals."""
+        return Graph(entrypoints=set(), edges=[], terminals=set())
+
     def __rshift__(self, other: GraphTarget) -> "Graph":
         if not self._edges and not self._entrypoints:
             raise ValueError("Graph instance can only create new edges from nodes within existing edges")

{vellum_ai-1.3.5 → vellum_ai-1.3.7}/src/vellum/workflows/graph/tests/test_graph.py

@@ -4,6 +4,23 @@ from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.ports.port import Port
 
 
+def test_graph__empty():
+    # WHEN we create an empty graph
+    graph = Graph.empty()
+
+    # THEN the graph has no entrypoints
+    assert len(list(graph.entrypoints)) == 0
+
+    # AND no nodes
+    assert len(list(graph.nodes)) == 0
+
+    # AND no edges
+    assert len(list(graph.edges)) == 0
+
+    # AND string representation indicates empty graph
+    assert str(graph) == "Graph(empty)"
+
+
 def test_graph__from_node():
     # GIVEN a node
     class MyNode(BaseNode):

{vellum_ai-1.3.5 → vellum_ai-1.3.7}/src/vellum/workflows/nodes/bases/base.py

@@ -13,6 +13,7 @@ from vellum.workflows.descriptors.utils import is_unresolved, resolve_value
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.events.node import NodeExecutionStreamingEvent
 from vellum.workflows.exceptions import NodeException
+from vellum.workflows.executable import BaseExecutable
 from vellum.workflows.graph import Graph
 from vellum.workflows.graph.graph import GraphTarget
 from vellum.workflows.inputs.base import BaseInputs
@@ -260,9 +261,7 @@ class _BaseNodeExecutionMeta(type):
 NodeRunResponse = Union[BaseOutputs, Iterator[BaseOutput]]
 
 
-class BaseNode(Generic[StateType], ABC, metaclass=BaseNodeMeta):
-    __id__: UUID = uuid4_from_hash(__qualname__)
-    __output_ids__: Dict[str, UUID] = {}
+class BaseNode(Generic[StateType], ABC, BaseExecutable, metaclass=BaseNodeMeta):
     state: StateType
     _context: WorkflowContext
     _inputs: MappingProxyType[NodeReference, Any]

{vellum_ai-1.3.5 → vellum_ai-1.3.7}/src/vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py

@@ -101,6 +101,7 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
         request_options = self.request_options or RequestOptions()
 
         processed_parameters = self.process_parameters(self.parameters)
+        processed_blocks = self.process_blocks(self.blocks)
 
         request_options["additional_body_parameters"] = {
             "execution_context": execution_context.model_dump(mode="json"),
@@ -139,7 +140,7 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
                 input_values=input_values,
                 input_variables=input_variables,
                 parameters=processed_parameters,
-                blocks=self.blocks,
+                blocks=processed_blocks,
                 settings=self.settings,
                 functions=normalized_functions,
                 expand_meta=self.expand_meta,
@@ -152,7 +153,7 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
                 input_values=input_values,
                 input_variables=input_variables,
                 parameters=processed_parameters,
-                blocks=self.blocks,
+                blocks=processed_blocks,
                 settings=self.settings,
                 functions=normalized_functions,
                 expand_meta=self.expand_meta,
@@ -310,3 +311,9 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
         processed_custom_params = normalize_json(parameters.custom_parameters)
 
         return parameters.model_copy(update={"custom_parameters": processed_custom_params})
+
+    def process_blocks(self, blocks: List[PromptBlock]) -> List[PromptBlock]:
+        """
+        Override this method to process the blocks before they are executed.
+        """
+        return blocks

{vellum_ai-1.3.5 → vellum_ai-1.3.7}/src/vellum/workflows/nodes/displayable/tool_calling_node/node.py

@@ -140,6 +140,7 @@ class ToolCallingNode(BaseNode[StateType], Generic[StateType]):
     def _build_graph(self) -> None:
         # Get the process_parameters method if it exists on this class
         process_parameters_method = getattr(self.__class__, "process_parameters", None)
+        process_blocks_method = getattr(self.__class__, "process_blocks", None)
 
         self.tool_prompt_node = create_tool_prompt_node(
             ml_model=self.ml_model,
@@ -149,6 +150,7 @@ class ToolCallingNode(BaseNode[StateType], Generic[StateType]):
             parameters=self.parameters,
             max_prompt_iterations=self.max_prompt_iterations,
             process_parameters_method=process_parameters_method,
+            process_blocks_method=process_blocks_method,
         )
 
         # Create the router node (handles routing logic only)

{vellum_ai-1.3.5 → vellum_ai-1.3.7}/src/vellum/workflows/nodes/displayable/tool_calling_node/utils.py

@@ -14,6 +14,7 @@ from vellum.client.types.prompt_output import PromptOutput
 from vellum.client.types.prompt_parameters import PromptParameters
 from vellum.client.types.string_chat_message_content import StringChatMessageContent
 from vellum.client.types.variable_prompt_block import VariablePromptBlock
+from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.expressions.concat import ConcatExpression
@@ -330,6 +331,7 @@ def create_tool_prompt_node(
     parameters: PromptParameters,
     max_prompt_iterations: Optional[int] = None,
     process_parameters_method: Optional[Callable] = None,
+    process_blocks_method: Optional[Callable] = None,
 ) -> Type[ToolPromptNode]:
     if functions and len(functions) > 0:
         prompt_functions: List[Union[Tool, FunctionDefinition]] = []
@@ -400,6 +402,7 @@ def create_tool_prompt_node(
                 "parameters": parameters,
                 "max_prompt_iterations": max_prompt_iterations,
                 **({"process_parameters": process_parameters_method} if process_parameters_method is not None else {}),
+                **({"process_blocks": process_blocks_method} if process_blocks_method is not None else {}),
                 "__module__": __name__,
             },
         ),
@@ -529,7 +532,10 @@ def create_function_node(
                 inputs = getattr(func, "__vellum_inputs__", {})
                 if inputs:
                     for param_name, param_ref in inputs.items():
-                        resolved_value = param_ref.resolve(self.state)
+                        if isinstance(param_ref, BaseDescriptor):
+                            resolved_value = param_ref.resolve(self.state)
+                        else:
+                            resolved_value = param_ref
                         merged_kwargs[param_name] = resolved_value
 
                 return func(**merged_kwargs)

{vellum_ai-1.3.5 → vellum_ai-1.3.7}/src/vellum/workflows/outputs/base.py

@@ -1,6 +1,6 @@
 from dataclasses import field
 import inspect
-from typing import Any, Generic, Iterator, Set, Tuple, Type, TypeVar, Union, cast
+from typing import Any, Dict, Generic, Iterator, Set, Tuple, Type, TypeVar, Union, cast
 from typing_extensions import dataclass_transform
 
 from pydantic import GetCoreSchemaHandler
@@ -10,6 +10,7 @@ from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
+from vellum.workflows.executable import BaseExecutable
 from vellum.workflows.references.output import OutputReference
 from vellum.workflows.types.generics import is_node_instance
 from vellum.workflows.types.utils import get_class_attr_names, infer_types
@@ -99,6 +100,10 @@ class BaseOutput(Generic[_Delta, _Accumulated]):
 
 @dataclass_transform(kw_only_default=True)
 class _BaseOutputsMeta(type):
+    def __new__(cls, name: str, bases: Tuple[Type, ...], dct: Dict[str, Any]) -> Any:
+        dct["__parent_class__"] = type(None)
+        return super().__new__(cls, name, bases, dct)
+
     def __eq__(cls, other: Any) -> bool:
         """
         We need to include custom eq logic to prevent infinite loops during ipython reloading.
@@ -119,7 +124,13 @@ class _BaseOutputsMeta(type):
         if self_outputs_class.__parent_class__ is None or other_outputs_class.__parent_class__ is None:
             return super().__eq__(other)
 
-        return self_outputs_class.__parent_class__.__qualname__ == other_outputs_class.__parent_class__.__qualname__
+        if self_outputs_class.__parent_class__ is type(None) or other_outputs_class.__parent_class__ is type(None):
+            return super().__eq__(other)
+
+        return (
+            self_outputs_class.__parent_class__.__qualname__ == other_outputs_class.__parent_class__.__qualname__
+            and self_outputs_class.__parent_class__.__module__ == other_outputs_class.__parent_class__.__module__
+        )
 
     def __setattr__(cls, name: str, value: Any) -> None:
         if isinstance(value, OutputReference):
@@ -183,9 +194,7 @@ class _BaseOutputsMeta(type):
 
 
 class BaseOutputs(metaclass=_BaseOutputsMeta):
-    # TODO: Uncomment once we figure out why this causes a failure in `infer_types`
-    # __parent_class__: Type[Union["BaseNode", "BaseWorkflow"]] = field(init=False)
-    __parent_class__: Type = field(init=False)
+    __parent_class__: Type[BaseExecutable] = field(init=False)
 
     def __init__(self, **kwargs: Any) -> None:
         declared_fields = {descriptor.name for descriptor in self.__class__}

{vellum_ai-1.3.5 → vellum_ai-1.3.7}/src/vellum/workflows/references/output.py

@@ -76,7 +76,7 @@ class OutputReference(BaseDescriptor[_OutputType], Generic[_OutputType]):
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, type(self)):
             return False
-        return super().__eq__(other) and id(self._outputs_class) == id(other._outputs_class)
+        return super().__eq__(other) and self._outputs_class == other._outputs_class
 
     def __hash__(self) -> int:
         return hash((self._outputs_class, self._name))

vellum_ai-1.3.7/src/vellum/workflows/utils/names.py

@@ -0,0 +1,21 @@
+import re
+
+
+def pascal_to_title_case(pascal_str: str) -> str:
+    title_case_str = re.sub(r"(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])", " ", pascal_str)
+
+    words = title_case_str.split()
+    result_words = []
+
+    for word in words:
+        if word.isupper():
+            result_words.append(word)
+        # Otherwise, apply title case
+        else:
+            result_words.append(word.capitalize())
+
+    return " ".join(result_words)
+
+
+def snake_to_title_case(snake_str: str) -> str:
+    return pascal_to_title_case(snake_str.replace("_", " "))

{vellum_ai-1.3.5 → vellum_ai-1.3.7}/src/vellum/workflows/utils/tests/test_names.py

@@ -8,6 +8,15 @@ from vellum.workflows.utils.names import pascal_to_title_case
     [
         ("MyPascalCaseString", "My Pascal Case String"),
         ("AnotherPascalCaseString", "Another Pascal Case String"),
+        ("FetchDeploymentScheme", "Fetch Deployment Scheme"),
+        ("CheckDeploymentExists", "Check Deployment Exists"),
+        ("APINode", "API Node"),
+        ("HTTPSConnection", "HTTPS Connection"),
+        ("XMLParser", "XML Parser"),
+        ("SimpleWord", "Simple Word"),
+        ("A", "A"),
+        ("AB", "AB"),
+        ("ABCDef", "ABC Def"),
     ],
 )
 def test_pascal_to_title_case(input_str, expected):

{vellum_ai-1.3.5 → vellum_ai-1.3.7}/src/vellum/workflows/workflows/base.py

@@ -62,6 +62,7 @@ from vellum.workflows.events.workflow import (
     WorkflowExecutionStreamingBody,
     WorkflowExecutionStreamingEvent,
 )
+from vellum.workflows.executable import BaseExecutable
 from vellum.workflows.graph import Graph
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
@@ -200,8 +201,7 @@ class _BaseWorkflowMeta(type):
         if inputs_class is not BaseInputs and inputs_class.__parent_class__ is type(None):
             inputs_class.__parent_class__ = workflow_class
 
-        # TODO: Uncomment this once we figure out why it's causing the ipython reload test to fail
-        # workflow_class.Outputs.__parent_class__ = workflow_class
+        workflow_class.Outputs.__parent_class__ = workflow_class
         workflow_class.__output_ids__ = {
             ref.name: uuid4_from_hash(f"{workflow_class.__id__}|id|{ref.name}") for ref in workflow_class.Outputs
         }
@@ -212,9 +212,7 @@ class _BaseWorkflowMeta(type):
 GraphAttribute = Union[Type[BaseNode], Graph, Set[Type[BaseNode]], Set[Graph]]
 
 
-class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
-    __id__: UUID = uuid4_from_hash(__qualname__)
-    __output_ids__: Dict[str, UUID] = {}
+class BaseWorkflow(Generic[InputsType, StateType], BaseExecutable, metaclass=_BaseWorkflowMeta):
     graph: ClassVar[GraphAttribute]
     unused_graphs: ClassVar[Set[GraphAttribute]]  # nodes or graphs that are defined but not used in the graph
     emitters: List[BaseWorkflowEmitter]

vellum_ai-1.3.5/src/vellum/workflows/utils/names.py

@@ -1,13 +0,0 @@
-import re
-
-
-def pascal_to_title_case(pascal_str: str) -> str:
-    # Insert space before each capital letter (except the first one)
-    title_case_str = re.sub(r"(?<!^)(?=[A-Z])", " ", pascal_str)
-
-    # Return the result in title case
-    return title_case_str.title()
-
-
-def snake_to_title_case(snake_str: str) -> str:
-    return pascal_to_title_case(snake_str.replace("_", " "))