vellum-ai 1.6.2__tar.gz → 1.6.4__tar.gz

{vellum_ai-1.6.2 → vellum_ai-1.6.4}/PKG-INFO

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

{vellum_ai-1.6.2 → vellum_ai-1.6.4}/ee/vellum_cli/image_push.py

@@ -123,6 +123,13 @@ def image_push_command(
                     suggestion="Make sure your VELLUM_API_KEY environment variable is set correctly.",
                 )
                 return
+            elif e.status_code == 400 and isinstance(e.body, dict) and "detail" in e.body:
+                handle_cli_error(
+                    logger,
+                    title="API request failed",
+                    message=e.body["detail"],
+                )
+                return
             elif e.status_code == 500:
                 handle_cli_error(
                     logger,
@@ -215,6 +222,13 @@ def image_push_command(
                 suggestion="Make sure your VELLUM_API_KEY environment variable is set correctly.",
             )
             return
+        elif e.status_code == 400 and isinstance(e.body, dict) and "detail" in e.body:
+            handle_cli_error(
+                logger,
+                title="API request failed",
+                message=e.body["detail"],
+            )
+            return
         elif e.status_code == 500:
             handle_cli_error(
                 logger,

{vellum_ai-1.6.2 → vellum_ai-1.6.4}/ee/vellum_cli/tests/test_image_push_error_handling.py

@@ -62,6 +62,37 @@ def test_image_push_docker_service_token_500_error(mock_docker_from_env, mock_ru
     assert "try again later" in result.output
 
 
+@patch("subprocess.run")
+@patch("docker.from_env")
+def test_image_push_docker_service_token_400_error(mock_docker_from_env, mock_run, vellum_client, monkeypatch):
+    monkeypatch.setenv("VELLUM_API_URL", "https://api.vellum.ai")
+    monkeypatch.setenv("VELLUM_API_KEY", "123456abcdef")
+
+    mock_docker_client = mock_docker_from_env.return_value
+    mock_docker_client.images.get.return_value.id = "test-image-id"
+
+    mock_run.side_effect = [
+        subprocess.CompletedProcess(args="", returncode=0, stdout=b"Pruning successful"),
+        subprocess.CompletedProcess(
+            args="", returncode=0, stdout=b'{"manifests": [{"platform": {"architecture": "amd64"}}]}'
+        ),
+    ]
+
+    vellum_client.container_images.docker_service_token.side_effect = ApiError(
+        status_code=400,
+        body={
+            "detail": "Invalid image configuration: missing required metadata",
+        },
+    )
+
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["image", "push", "myimage:latest"])
+
+    assert result.exit_code == 1
+    assert "API request failed" in result.output
+    assert "Invalid image configuration: missing required metadata" in result.output
+
+
 @patch("subprocess.run")
 @patch("docker.from_env")
 def test_image_push_docker_service_token_other_error(mock_docker_from_env, mock_run, vellum_client, monkeypatch):
@@ -156,6 +187,43 @@ def test_image_push_container_image_500_error(mock_docker_from_env, mock_run, ve
     assert "try again later" in result.output
 
 
+@patch("subprocess.run")
+@patch("docker.from_env")
+def test_image_push_container_image_400_error(mock_docker_from_env, mock_run, vellum_client, monkeypatch):
+    monkeypatch.setenv("VELLUM_API_URL", "https://api.vellum.ai")
+    monkeypatch.setenv("VELLUM_API_KEY", "123456abcdef")
+
+    mock_docker_client = mock_docker_from_env.return_value
+    mock_docker_client.images.get.return_value.id = "test-image-id"
+    mock_docker_client.images.push.return_value = ["pushed"]
+
+    mock_run.side_effect = [
+        subprocess.CompletedProcess(args="", returncode=0, stdout=b"Pruning successful"),
+        subprocess.CompletedProcess(
+            args="", returncode=0, stdout=b'{"manifests": [{"platform": {"architecture": "amd64"}}]}'
+        ),
+        subprocess.CompletedProcess(args="", returncode=0, stdout=b'[{"RepoDigests": ["test-repo@sha256:abcd1234"]}]'),
+    ]
+
+    vellum_client.container_images.docker_service_token.return_value = type(
+        "obj", (object,), {"access_token": "345678mnopqr", "organization_id": str(uuid4()), "repository": "myrepo.net"}
+    )()
+
+    vellum_client.container_images.push_container_image.side_effect = ApiError(
+        status_code=400,
+        body={
+            "detail": "Image validation failed: unsupported architecture",
+        },
+    )
+
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["image", "push", "myimage:latest"])
+
+    assert result.exit_code == 1
+    assert "API request failed" in result.output
+    assert "Image validation failed: unsupported architecture" in result.output
+
+
 @patch("subprocess.run")
 @patch("docker.from_env")
 def test_image_push_container_image_other_error(mock_docker_from_env, mock_run, vellum_client, monkeypatch):

{vellum_ai-1.6.2 → vellum_ai-1.6.4}/ee/vellum_ee/workflows/display/nodes/vellum/map_node.py

@@ -32,15 +32,6 @@ class BaseMapNodeDisplay(BaseAdornmentNodeDisplay[_MapNodeType], Generic[_MapNod
 
         items = raise_if_descriptor(node.items)
 
-        items_node_input = create_node_input(
-            node_id=node_id,
-            input_name="items",
-            value=items or [],
-            display_context=display_context,
-            input_id=self.node_input_ids_by_name.get("items"),
-        )
-        node_inputs = [items_node_input]
-
         subworkflow_display = get_workflow_display(
             base_display_class=display_context.workflow_display_class,
             workflow_class=subworkflow,
@@ -58,6 +49,16 @@ class BaseMapNodeDisplay(BaseAdornmentNodeDisplay[_MapNodeType], Generic[_MapNod
             for input_variable in input_variables
             if isinstance(input_variable, dict) and input_variable["key"] == "items"
         )
+
+        # Use the same ID for the map node's items input as the subworkflow's items input
+        items_node_input = create_node_input(
+            node_id=node_id,
+            input_name="items",
+            value=items or [],
+            display_context=display_context,
+            input_id=str(items_workflow_input_id),
+        )
+        node_inputs = [items_node_input]
         item_workflow_input_id = next(
             input_variable["id"]
             for input_variable in input_variables

{vellum_ai-1.6.2 → vellum_ai-1.6.4}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_map_node_serialization.py

@@ -81,7 +81,7 @@ def test_serialize_workflow():
             "type": "MAP",
             "inputs": [
                 {
-                    "id": "4c0a109f-599e-4d04-a396-a51474fc2996",
+                    "id": "0acef1e7-caa1-4d9f-bb69-6981729af18d",
                     "key": "items",
                     "value": {
                         "rules": [
@@ -393,3 +393,7 @@ def test_serialize_workflow():
             "workflow",
         ],
     }
+
+    # AND the map node's items input ID should match the subworkflow's items input ID
+    items_input_id = map_node["data"]["items_input_id"]
+    assert map_node["inputs"][0]["id"] == items_input_id

vellum_ai-1.6.4/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_terminal_node_any_serialization.py

@@ -0,0 +1,49 @@
+from typing import Any
+
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.displayable.final_output_node import FinalOutputNode
+from vellum.workflows.state.base import BaseState
+from vellum.workflows.workflows.base import BaseWorkflow
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+class Inputs(BaseInputs):
+    input: Any
+
+
+class AnyFinalOutputNode(FinalOutputNode[BaseState, Any]):
+    class Outputs(FinalOutputNode.Outputs):
+        value: Any = Inputs.input
+
+
+class AnyFinalOutputNodeWorkflow(BaseWorkflow[Inputs, BaseState]):
+    graph = AnyFinalOutputNode
+
+    class Outputs(BaseWorkflow.Outputs):
+        value = AnyFinalOutputNode.Outputs.value
+
+
+def test_serialize_workflow_with_any_output_type():
+    """
+    Tests that a terminal node with Any output type can be serialized correctly.
+    """
+    # GIVEN a Workflow that uses a Final Output Node with Any type
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=AnyFinalOutputNodeWorkflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN we should get a serialized representation of the Workflow
+    assert serialized_workflow.keys() == {
+        "workflow_raw_data",
+        "input_variables",
+        "state_variables",
+        "output_variables",
+    }
+
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    terminal_node = next(node for node in workflow_raw_data["nodes"] if node["type"] == "TERMINAL")
+    assert terminal_node["data"]["output_type"] == "JSON"
+
+    output_variables = serialized_workflow["output_variables"]
+    assert len(output_variables) == 1
+    assert output_variables[0]["type"] == "JSON"

{vellum_ai-1.6.2 → vellum_ai-1.6.4}/ee/vellum_ee/workflows/tests/test_serialize_module.py

@@ -1,6 +1,25 @@
+import pytest
+from pathlib import Path
+import shutil
+import sys
+import tempfile
+
+from vellum.workflows.exceptions import WorkflowInitializationException
 from vellum_ee.workflows.display.workflows.base_workflow_display import BaseWorkflowDisplay
 
 
+@pytest.fixture
+def temp_module_path():
+    """Fixture to manage sys.path for temporary modules."""
+    temp_dir = tempfile.mkdtemp()
+    sys.path.insert(0, temp_dir)
+    try:
+        yield temp_dir
+    finally:
+        sys.path.remove(temp_dir)
+        shutil.rmtree(temp_dir)
+
+
 def test_serialize_module_with_dataset():
     """Test that serialize_module correctly serializes dataset from sandbox modules."""
     module_path = "tests.workflows.basic_inputs_and_outputs"
@@ -75,3 +94,37 @@ def test_serialize_module_includes_additional_files():
     assert "def helper_function():" in additional_files["helper.py"]
     assert "sample data file" in additional_files["data.txt"]
     assert "CONSTANT_VALUE" in additional_files["utils/constants.py"]
+
+
+def test_serialize_module__with_invalid_nested_set_graph(temp_module_path):
+    """
+    Tests that serialize_module raises a clear user-facing exception for workflows with nested sets in graph attribute.
+    """
+    module_dir = Path(temp_module_path) / "test_invalid_workflow"
+    module_dir.mkdir()
+
+    (module_dir / "__init__.py").write_text("")
+
+    workflow_content = """
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.nodes import BaseNode
+
+class TestNode(BaseNode):
+    class Outputs(BaseNode.Outputs):
+        value = "test"
+
+class InvalidWorkflow(BaseWorkflow):
+    graph = {TestNode, {TestNode}}
+
+    class Outputs(BaseWorkflow.Outputs):
+        result = TestNode.Outputs.value
+"""
+    (module_dir / "workflow.py").write_text(workflow_content)
+
+    with pytest.raises(WorkflowInitializationException) as exc_info:
+        BaseWorkflowDisplay.serialize_module("test_invalid_workflow")
+
+    error_message = str(exc_info.value)
+    assert "Invalid graph structure detected" in error_message
+    assert "Nested sets or unsupported graph types are not allowed" in error_message
+    assert "contact Vellum support" in error_message

{vellum_ai-1.6.2 → vellum_ai-1.6.4}/pyproject.toml

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

{vellum_ai-1.6.2 → vellum_ai-1.6.4}/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.6.2",
+            "User-Agent": "vellum-ai/1.6.4",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.6.2",
+            "X-Fern-SDK-Version": "1.6.4",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

{vellum_ai-1.6.2 → vellum_ai-1.6.4}/src/vellum/workflows/exceptions.py

@@ -6,6 +6,19 @@ if TYPE_CHECKING:
     from vellum.workflows.workflows.base import BaseWorkflow
 
 
+def import_workflow_class() -> Type["BaseWorkflow"]:
+    """
+    Helper function to help avoid circular imports.
+
+    Ideally, we use the one in types.generics, but _that_ causes circular imports
+    due to the `src/vellum/workflows/types/definition.py` module's import of `EnvironmentVariableReference`
+    """
+
+    from vellum.workflows.workflows import BaseWorkflow
+
+    return BaseWorkflow
+
+
 class NodeException(Exception):
     def __init__(
         self,
@@ -35,12 +48,13 @@ class WorkflowInitializationException(Exception):
     def __init__(
         self,
         message: str,
-        workflow_definition: Type["BaseWorkflow"],
+        workflow_definition: Optional[Type["BaseWorkflow"]] = None,
         code: WorkflowErrorCode = WorkflowErrorCode.INVALID_INPUTS,
     ):
+
         self.message = message
         self.code = code
-        self.definition = workflow_definition
+        self.definition = workflow_definition if workflow_definition is not None else import_workflow_class()
         super().__init__(message)
 
     @property

{vellum_ai-1.6.2 → vellum_ai-1.6.4}/src/vellum/workflows/nodes/core/error_node/node.py

@@ -1,13 +1,14 @@
-from typing import ClassVar, Union
+from typing import ClassVar, Generic, Union
 
 from vellum.client.types.vellum_error import VellumError
 from vellum.workflows.errors.types import WorkflowError, WorkflowErrorCode, vellum_error_to_workflow_error
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.ports import NodePorts
+from vellum.workflows.types.generics import StateType
 
 
-class ErrorNode(BaseNode):
+class ErrorNode(BaseNode[StateType], Generic[StateType]):
     """
     Used to raise an error to reject the surrounding Workflow.
 

{vellum_ai-1.6.2 → vellum_ai-1.6.4}/src/vellum/workflows/nodes/displayable/code_execution_node/node.py

@@ -23,6 +23,7 @@ from vellum import (
 from vellum.client.core import RequestOptions
 from vellum.client.core.api_error import ApiError
 from vellum.client.types.code_executor_secret_input import CodeExecutorSecretInput
+from vellum.workflows.constants import undefined
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
@@ -147,6 +148,8 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
         compiled_inputs: List[CodeExecutorInput] = []
 
         for input_name, input_value in self.code_inputs.items():
+            if input_value is undefined:
+                continue
             if isinstance(input_value, str):
                 compiled_inputs.append(
                     StringInput(

{vellum_ai-1.6.2 → vellum_ai-1.6.4}/src/vellum/workflows/nodes/displayable/code_execution_node/tests/test_node.py

@@ -13,6 +13,7 @@ from vellum.client.types.code_executor_secret_input import CodeExecutorSecretInp
 from vellum.client.types.function_call import FunctionCall
 from vellum.client.types.number_input import NumberInput
 from vellum.client.types.string_chat_message_content import StringChatMessageContent
+from vellum.workflows.constants import undefined
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs.base import BaseInputs
@@ -1278,3 +1279,85 @@ def main(secret: str) -> str:
         packages=[],
         request_options=None,
     )
+
+
+def test_run_node__undefined_input_skipped():
+    """
+    Confirm that when an undefined value is passed as an input, it is skipped rather than raising an error.
+    The function should use the default parameter value when undefined input is skipped.
+    """
+
+    # GIVEN a node with both a valid input and an undefined input that runs inline
+    class State(BaseState):
+        pass
+
+    class ExampleCodeExecutionNode(CodeExecutionNode[State, int]):
+        code = """\
+def main(word: str, undefined_input: str = "default") -> int:
+    return len(word) + len(undefined_input)
+"""
+        runtime = "PYTHON_3_11_6"
+        packages = []
+
+        code_inputs = {
+            "word": "hello",
+            "undefined_input": undefined,
+        }
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode(state=State())
+    outputs = node.run()
+
+    # THEN the node should run successfully without raising an error
+    assert outputs == {"result": 12, "log": ""}  # len("hello") + len("default") = 5 + 7 = 12
+
+
+def test_run_node__undefined_input_skipped_api_execution(vellum_client):
+    """
+    Confirm that when an undefined value is passed as an input in API execution mode,
+    it is skipped rather than raising an error.
+    """
+
+    # GIVEN a node with both a valid input and an undefined input that forces API execution
+    class State(BaseState):
+        pass
+
+    class ExampleCodeExecutionNode(CodeExecutionNode[State, int]):
+        code = """\
+def main(word: str) -> int:
+    return len(word)
+"""
+        runtime = "PYTHON_3_11_6"
+        packages = [CodeExecutionPackage(name="requests", version="2.0.0")]
+
+        code_inputs = {
+            "word": "hello",
+            "undefined_input": undefined,
+        }
+
+    # AND we know what the Code Execution Node will respond with
+    mock_code_execution = CodeExecutorResponse(
+        log="",
+        output=NumberVellumValue(value=5),
+    )
+    vellum_client.execute_code.return_value = mock_code_execution
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode(state=State())
+    outputs = node.run()
+
+    # THEN the node should run successfully without raising an error
+    assert outputs == {"result": 5, "log": ""}
+
+    # AND the API should be called with only the non-undefined input
+    vellum_client.execute_code.assert_called_once_with(
+        input_values=[StringInput(name="word", value="hello")],
+        code="""\
+def main(word: str) -> int:
+    return len(word)
+""",
+        runtime="PYTHON_3_11_6",
+        output_type="NUMBER",
+        packages=[CodeExecutionPackage(name="requests", version="2.0.0")],
+        request_options=None,
+    )

{vellum_ai-1.6.2 → vellum_ai-1.6.4}/src/vellum/workflows/nodes/displayable/code_execution_node/utils.py

@@ -4,6 +4,7 @@ import sys
 import traceback
 from typing import Any, Optional, Tuple, Union
 
+from vellum.workflows.constants import undefined
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.utils import cast_to_output_type, wrap_inputs_for_backward_compatibility
@@ -54,7 +55,7 @@ def run_code_inline(
         "__arg__out": None,
         "print": _inline_print,
     }
-    run_args = [f"{name}=__arg__inputs['{name}']" for name in inputs.keys()]
+    run_args = [f"{name}=__arg__inputs['{name}']" for name, value in inputs.items() if value is not undefined]
     execution_code = f"""\
 {code}
 

{vellum_ai-1.6.2 → vellum_ai-1.6.4}/src/vellum/workflows/nodes/displayable/conditional_node/node.py

@@ -1,4 +1,4 @@
-from typing import Set
+from typing import Generic, Set
 
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.outputs.base import BaseOutputs
@@ -6,9 +6,10 @@ from vellum.workflows.ports.port import Port
 from vellum.workflows.ports.utils import validate_ports
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.types import MergeBehavior
+from vellum.workflows.types.generics import StateType
 
 
-class ConditionalNode(BaseNode):
+class ConditionalNode(BaseNode[StateType], Generic[StateType]):
     """
     Used to conditionally determine which port to invoke next. This node exists to be backwards compatible with
     Vellum's Conditional Node, and for most cases, you should extend `BaseNode.Ports` directly.

{vellum_ai-1.6.2 → vellum_ai-1.6.4}/src/vellum/workflows/nodes/displayable/merge_node/node.py

@@ -1,8 +1,11 @@
+from typing import Generic
+
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.types import MergeBehavior
+from vellum.workflows.types.generics import StateType
 
 
-class MergeNode(BaseNode):
+class MergeNode(BaseNode[StateType], Generic[StateType]):
     """
     Used to merge the control flow of multiple nodes into a single node. This node exists to be backwards compatible
     with Vellum's Merge Node, and for most cases, you should extend from `BaseNode.Trigger` directly.

{vellum_ai-1.6.2 → vellum_ai-1.6.4}/src/vellum/workflows/nodes/displayable/note_node/node.py

@@ -1,8 +1,11 @@
+from typing import Generic
+
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.types import MergeBehavior
+from vellum.workflows.types.generics import StateType
 
 
-class NoteNode(BaseNode):
+class NoteNode(BaseNode[StateType], Generic[StateType]):
     """
     A no-op Node purely used to display a note in the Vellum UI.
     """

{vellum_ai-1.6.2 → vellum_ai-1.6.4}/src/vellum/workflows/runner/runner.py

@@ -145,6 +145,14 @@ class WorkflowRunner(Generic[StateType]):
             ]
             self._is_resuming = True
         elif previous_execution_id:
+            if not self.workflow.resolvers:
+                raise WorkflowInitializationException(
+                    message=f"No resolvers configured to load initial state for execution ID: {previous_execution_id}",
+                    workflow_definition=self.workflow.__class__,
+                    code=WorkflowErrorCode.INVALID_INPUTS,
+                )
+
+            resolver_failed = True
             for resolver in self.workflow.resolvers:
                 try:
                     load_state_result = resolver.load_state(previous_execution_id)
@@ -161,10 +169,19 @@ class WorkflowRunner(Generic[StateType]):
                                 load_state_result.root_trace_id,
                                 load_state_result.root_span_id,
                             )
+                            resolver_failed = False
                             break
                 except Exception as e:
                     logger.warning(f"Failed to load state from resolver {type(resolver).__name__}: {e}")
                     continue
+
+            if resolver_failed:
+                raise WorkflowInitializationException(
+                    message=f"All resolvers failed to load initial state for execution ID: {previous_execution_id}",
+                    workflow_definition=self.workflow.__class__,
+                    code=WorkflowErrorCode.INVALID_INPUTS,
+                )
+
             self._entrypoints = self.workflow.get_entrypoints()
         else:
             normalized_inputs = deepcopy(inputs) if inputs else self.workflow.get_default_inputs()

{vellum_ai-1.6.2 → vellum_ai-1.6.4}/src/vellum/workflows/utils/vellum_variables.py

@@ -87,6 +87,9 @@ def primitive_type_to_vellum_variable_type(type_: Union[Type, BaseDescriptor]) -
     elif _is_type_optionally_in(type_, (VellumError, VellumErrorRequest)):
         return "ERROR"
 
+    if type_ is typing.Any:
+        return "JSON"
+
     builtin_list_type = _builtin_list_to_vellum_type(type_)
     if builtin_list_type:
         return builtin_list_type

{vellum_ai-1.6.2 → vellum_ai-1.6.4}/src/vellum/workflows/workflows/base.py

@@ -63,6 +63,7 @@ from vellum.workflows.events.workflow import (
     WorkflowExecutionStreamingBody,
     WorkflowExecutionStreamingEvent,
 )
+from vellum.workflows.exceptions import WorkflowInitializationException
 from vellum.workflows.executable import BaseExecutable
 from vellum.workflows.graph import Graph
 from vellum.workflows.inputs.base import BaseInputs
@@ -681,7 +682,16 @@ class BaseWorkflow(Generic[InputsType, StateType], BaseExecutable, metaclass=_Ba
     @staticmethod
     def load_from_module(module_path: str) -> Type["BaseWorkflow"]:
         workflow_path = f"{module_path}.workflow"
-        module = importlib.import_module(workflow_path)
+        try:
+            module = importlib.import_module(workflow_path)
+        except TypeError as e:
+            if "Unexpected graph type" in str(e) or "unhashable type: 'set'" in str(e):
+                raise WorkflowInitializationException(
+                    message="Invalid graph structure detected. Nested sets or unsupported graph types are not allowed. "
+                    "Please contact Vellum support for assistance with Workflow configuration."
+                ) from e
+            else:
+                raise
         workflows: List[Type[BaseWorkflow]] = []
         for name in dir(module):
             if name.startswith("__"):