vellum-ai 1.7.10__tar.gz → 1.7.11__tar.gz

{vellum_ai-1.7.10 → vellum_ai-1.7.11}/PKG-INFO

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

{vellum_ai-1.7.10 → vellum_ai-1.7.11}/ee/vellum_cli/pull.py

@@ -7,11 +7,11 @@ import zipfile
 from typing import Optional
 
 from dotenv import load_dotenv
-from pydash import snake_case
 
 from vellum.client.core.api_error import ApiError
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.utils.uuid import is_valid_uuid
+from vellum.workflows.utils.names import create_module_name
 from vellum.workflows.vellum_client import create_vellum_client
 from vellum_cli.config import (
     DEFAULT_WORKSPACE_CONFIG,
@@ -257,10 +257,11 @@ def pull_command(
                         workflow_config.container_image_tag = "latest"
                 if not workflow_config.workflow_sandbox_id and pull_contents_metadata.workflow_sandbox_id:
                     workflow_config.workflow_sandbox_id = str(pull_contents_metadata.workflow_sandbox_id)
-                if not workflow_config.module and workflow_deployment and pull_contents_metadata.deployment_name:
-                    workflow_config.module = snake_case(pull_contents_metadata.deployment_name)
-                if not workflow_config.module and pull_contents_metadata.label:
-                    workflow_config.module = snake_case(pull_contents_metadata.label)
+                if not workflow_config.module:
+                    deployment_name = pull_contents_metadata.deployment_name if workflow_deployment else None
+                    workflow_config.module = create_module_name(
+                        deployment_name=deployment_name, label=pull_contents_metadata.label
+                    )
 
                 # Save or update the deployment info when pulling with --workflow-deployment
                 if workflow_deployment:

{vellum_ai-1.7.10 → vellum_ai-1.7.11}/ee/vellum_cli/push.py

@@ -77,7 +77,20 @@ def push_command(
 
     logger.info(f"Loading workflow from {workflow_config.module}")
     resolved_workspace = workspace or workflow_config.workspace or DEFAULT_WORKSPACE_CONFIG.name
-    workspace_config = next((w for w in config.workspaces if w.name == resolved_workspace), DEFAULT_WORKSPACE_CONFIG)
+    workspace_config = next((w for w in config.workspaces if w.name == resolved_workspace), None)
+
+    if workspace_config is None:
+        if resolved_workspace == DEFAULT_WORKSPACE_CONFIG.name:
+            workspace_config = DEFAULT_WORKSPACE_CONFIG
+        else:
+            available_workspaces = sorted(set([w.name for w in config.workspaces] + [DEFAULT_WORKSPACE_CONFIG.name]))
+            handle_cli_error(
+                logger,
+                title=f"Workspace '{resolved_workspace}' not found in config",
+                message=f"Available workspaces: {', '.join(available_workspaces)}",
+            )
+            return
+
     api_key = os.getenv(workspace_config.api_key)
     if not api_key:
         raise ValueError(f"No API key value found in environment for workspace '{workspace_config.name}'.")
@@ -181,12 +194,14 @@ def push_command(
     artifact.seek(0)
     artifact.name = f"{workflow_config.module.replace('.', '__')}.tar.gz"
 
+    provided_id = workflow_config.workflow_sandbox_id or workflow_sandbox_id
+
     try:
         response = client.workflows.push(
             # Remove this once we could serialize using the artifact in Vembda
             # https://app.shortcut.com/vellum/story/5585
             exec_config=json.dumps(exec_config),
-            workflow_sandbox_id=workflow_config.workflow_sandbox_id or workflow_sandbox_id,
+            workflow_sandbox_id=provided_id,
             artifact=artifact,
             # We should check with fern if we could auto-serialize typed object fields for us
             # https://app.shortcut.com/vellum/story/5568
@@ -195,6 +210,24 @@ def push_command(
             strict=strict,
         )
     except ApiError as e:
+        if e.status_code == 404:
+            if provided_id:
+                handle_cli_error(
+                    logger,
+                    title="Workflow Sandbox not found",
+                    message=f"Could not find Workflow Sandbox with ID '{provided_id}' "
+                    f"in workspace '{resolved_workspace}'.",
+                )
+            else:
+                error_detail = e.body.get("detail") if isinstance(e.body, dict) else None
+                default_message = "The `/workflows/push` endpoint failed with a 404 response."
+                handle_cli_error(
+                    logger,
+                    title="Workflow Sandbox not found",
+                    message=error_detail or default_message,
+                )
+            return
+
         if e.status_code == 400 and isinstance(e.body, dict) and "diffs" in e.body:
             diffs: dict = e.body["diffs"]
             generated_only = diffs.get("generated_only", [])

{vellum_ai-1.7.10 → vellum_ai-1.7.11}/ee/vellum_cli/tests/test_push.py

@@ -592,6 +592,84 @@ def test_push__push_fails_due_to_400_error(mock_module, vellum_client):
     assert "Traceback" not in result.output
 
 
+def test_push__push_fails_due_to_404_error_with_id(mock_module, vellum_client):
+    """
+    Tests that a 404 error with a workflow sandbox ID shows a helpful error message.
+    """
+
+    # GIVEN a single workflow configured with a workflow_sandbox_id
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
+
+    # AND a workflow exists in the module successfully
+    _ensure_workflow_py(temp_dir, module)
+
+    # AND the push API call returns a 404 response
+    vellum_client.workflows.push.side_effect = ApiError(
+        status_code=404,
+        body={},
+    )
+
+    # WHEN calling `vellum push`
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["push", module])
+
+    # THEN it should fail with a user error code
+    assert result.exit_code == 1
+
+    # AND the error message should be in the error message
+    assert "Workflow Sandbox not found" in result.output
+    assert mock_module.workflow_sandbox_id in result.output
+    assert "workspace" in result.output
+
+    # AND the stack trace should not be present
+    assert "Traceback" not in result.output
+
+
+def test_push__push_fails_due_to_404_error_without_id(tmp_path, vellum_client, monkeypatch):
+    """
+    Tests that a 404 error without a workflow sandbox ID shows a helpful error message.
+    """
+
+    # GIVEN a workflow module exists but has no workflow_sandbox_id configured
+    module = "examples.mock.test_push__404_without_id"
+    module_dir = tmp_path / "examples" / "mock" / "test_push__404_without_id"
+    module_dir.mkdir(parents=True)
+
+    # AND a workflow.py file exists
+    workflow_file = module_dir / "workflow.py"
+    workflow_file.write_text(
+        "from vellum.workflows import BaseWorkflow\n\nclass ExampleWorkflow(BaseWorkflow):\n    pass\n"
+    )
+
+    # AND the pyproject.toml file exists without workflow_sandbox_id
+    pyproject_file = tmp_path / "pyproject.toml"
+    pyproject_file.write_text(f'[tool.vellum]\n[[tool.vellum.workflows]]\nmodule = "{module}"\n')
+
+    monkeypatch.chdir(tmp_path)
+
+    # AND the push API call returns a 404 response
+    vellum_client.workflows.push.side_effect = ApiError(
+        status_code=404,
+        body={},
+    )
+
+    # WHEN calling `vellum push`
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["push", module])
+
+    # THEN it should fail with a user error code
+    assert result.exit_code == 1
+
+    # AND the error message should be in the output
+    assert "Workflow Sandbox not found" in result.output
+    assert "/workflows/push" in result.output
+    assert "404 response" in result.output
+
+    # AND the stack trace should not be present
+    assert "Traceback" not in result.output
+
+
 @pytest.mark.parametrize(
     "file_data",
     [
@@ -1220,3 +1298,47 @@ MY_CUSTOM_VELLUM_API_KEY=custom-key-xyz
         assert len(lock_file_content["workflows"]) == 1
         assert lock_file_content["workflows"][0]["workspace"] == "my_custom_workspace"
         assert lock_file_content["workflows"][0]["workflow_sandbox_id"] == workflow_sandbox_id
+
+
+def test_push__workspace_option__nonexistent_workspace_should_fail(mock_module):
+    """
+    Tests that pushing with a nonexistent workspace that isn't default should fail.
+    """
+
+    # GIVEN a single workflow configured
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
+    set_pyproject_toml = mock_module.set_pyproject_toml
+
+    # AND a custom workspace is configured
+    set_pyproject_toml(
+        {
+            "workflows": [
+                {
+                    "module": module,
+                }
+            ],
+            "workspaces": [
+                {
+                    "name": "my_custom_workspace",
+                    "api_key": "MY_CUSTOM_VELLUM_API_KEY",
+                }
+            ],
+        }
+    )
+
+    # AND a workflow exists in the module successfully
+    _ensure_workflow_py(temp_dir, module)
+
+    # WHEN calling `vellum push` with a nonexistent workspace
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["push", module, "--workspace", "nonexistent_workspace"])
+
+    # THEN it should exit with an error
+    assert result.exit_code == 1
+
+    # AND the error message should indicate the workspace doesn't exist
+    assert "Workspace 'nonexistent_workspace' not found in config" in result.output
+    assert "Available workspaces:" in result.output
+    assert "default" in result.output
+    assert "my_custom_workspace" in result.output

vellum_ai-1.7.11/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_list_vellum_document_serialization.py

@@ -0,0 +1,65 @@
+from typing import List
+
+from vellum import VellumDocument
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs import BaseInputs
+from vellum.workflows.nodes.displayable import FinalOutputNode
+from vellum.workflows.outputs import BaseOutputs
+from vellum.workflows.state import BaseState
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+class Inputs(BaseInputs):
+    documents: List[VellumDocument]
+
+
+class MyFinalOutputNode(FinalOutputNode):
+    class Outputs(BaseOutputs):
+        value = Inputs.documents
+
+
+class WorkflowWithListVellumDocument(BaseWorkflow[Inputs, BaseState]):
+    """A workflow that takes a list of VellumDocument as input."""
+
+    graph = MyFinalOutputNode
+
+    class Outputs(BaseOutputs):
+        result = MyFinalOutputNode.Outputs.value
+
+
+def test_serialize_workflow_with_list_vellum_document():
+    """Tests that we can serialize a workflow with List[VellumDocument] input."""
+
+    workflow_display = get_workflow_display(workflow_class=WorkflowWithListVellumDocument)
+
+    # WHEN we serialize it
+    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",
+    }
+
+    input_variables = serialized_workflow["input_variables"]
+    assert len(input_variables) == 1
+
+    input_var = input_variables[0]
+    assert input_var["key"] == "documents"
+    assert input_var["type"] == "JSON"
+    # NOTE: Once custom type serialization is supported, we will want to represent this using an openapi spec
+    assert input_var["required"] is True
+    assert input_var["default"] is None
+    assert input_var["extensions"] == {"color": None}
+
+    output_variables = serialized_workflow["output_variables"]
+    assert len(output_variables) == 1
+
+    output_var = output_variables[0]
+    assert output_var["key"] == "result"
+
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    assert len(workflow_raw_data["nodes"]) == 2
+    assert len(workflow_raw_data["edges"]) == 1

{vellum_ai-1.7.10 → vellum_ai-1.7.11}/ee/vellum_ee/workflows/display/utils/events.py

@@ -1,7 +1,7 @@
 from typing import Optional
 
 from vellum import Vellum
-from vellum.workflows.events.workflow import WorkflowExecutionInitiatedEvent
+from vellum.workflows.events.workflow import WorkflowEvent, WorkflowExecutionInitiatedEvent
 from vellum_ee.workflows.display.utils.registry import (
     get_parent_display_context_from_event,
     register_workflow_display_class,
@@ -29,8 +29,8 @@ def _should_mark_workflow_dynamic(event: WorkflowExecutionInitiatedEvent) -> boo
 
 
 def event_enricher(
-    event: WorkflowExecutionInitiatedEvent, client: Optional[Vellum] = None
-) -> WorkflowExecutionInitiatedEvent:
+    event: WorkflowEvent, client: Optional[Vellum] = None, metadata: Optional[dict] = None
+) -> WorkflowEvent:
     if event.name != "workflow.execution.initiated":
         return event
 
@@ -49,4 +49,7 @@ def event_enricher(
         workflow_version_exec_config = workflow_display.serialize()
         setattr(event.body, "workflow_version_exec_config", workflow_version_exec_config)
 
+    if metadata is not None:
+        event.body.server_metadata = metadata
+
     return event

{vellum_ai-1.7.10 → vellum_ai-1.7.11}/ee/vellum_ee/workflows/display/utils/tests/test_events.py

@@ -112,6 +112,7 @@ def test_event_enricher_marks_subworkflow_deployment_as_dynamic(vellum_client):
 
     enriched_event = event_enricher(event, vellum_client)
 
+    assert enriched_event.name == "workflow.execution.initiated"
     assert hasattr(enriched_event.body, "workflow_version_exec_config")
     assert enriched_event.body.workflow_version_exec_config is not None
 
@@ -119,3 +120,31 @@ def test_event_enricher_marks_subworkflow_deployment_as_dynamic(vellum_client):
     assert hasattr(enriched_event.body.display_context, "node_displays")
     assert hasattr(enriched_event.body.display_context, "workflow_inputs")
     assert hasattr(enriched_event.body.display_context, "workflow_outputs")
+
+
+def test_event_enricher_with_metadata(vellum_client):
+    """Test that event_enricher attaches metadata to server_metadata field."""
+
+    # GIVEN a workflow class
+    class TestWorkflow(BaseWorkflow):
+        is_dynamic = False
+
+    # AND an event
+    event: WorkflowExecutionInitiatedEvent = WorkflowExecutionInitiatedEvent(
+        trace_id=uuid4(),
+        span_id=uuid4(),
+        body=WorkflowExecutionInitiatedBody(
+            workflow_definition=TestWorkflow,
+            inputs=BaseInputs(),
+        ),
+    )
+
+    # AND some metadata
+    metadata = {"custom_key": "custom_value", "another_key": 123}
+
+    # WHEN the event_enricher is called with metadata
+    enriched_event = event_enricher(event, vellum_client, metadata=metadata)
+
+    # THEN the metadata should be attached to server_metadata
+    assert enriched_event.name == "workflow.execution.initiated"
+    assert enriched_event.body.server_metadata == metadata

{vellum_ai-1.7.10 → vellum_ai-1.7.11}/ee/vellum_ee/workflows/server/virtual_file_loader.py

@@ -4,11 +4,14 @@ import re
 import sys
 from typing import Optional
 
+from vellum.workflows.loaders.base import BaseWorkflowFinder
+
 
 class VirtualFileLoader(importlib.abc.Loader):
-    def __init__(self, files: dict[str, str], namespace: str):
+    def __init__(self, files: dict[str, str], namespace: str, source_module: Optional[str] = None):
         self.files = files
         self.namespace = namespace
+        self.source_module = source_module
 
     def create_module(self, spec: ModuleSpec):
         """
@@ -65,9 +68,17 @@ class VirtualFileLoader(importlib.abc.Loader):
         return self.files.get(file_key_name)
 
 
-class VirtualFileFinder(importlib.abc.MetaPathFinder, importlib.abc.Loader):
-    def __init__(self, files: dict[str, str], namespace: str):
-        self.loader = VirtualFileLoader(files, namespace)
+class VirtualFileFinder(BaseWorkflowFinder):
+    def __init__(self, files: dict[str, str], namespace: str, source_module: Optional[str] = None):
+        self.loader = VirtualFileLoader(files, namespace, source_module)
+        self.source_module = source_module
+        self.namespace = namespace
+
+    def format_error_message(self, error_message: str) -> str:
+        """Format error message by replacing namespace with source_module."""
+        if self.source_module and self.namespace in error_message:
+            return error_message.replace(self.namespace, self.source_module)
+        return error_message
 
     def find_spec(self, fullname: str, path, target=None):
         module_info = self.loader._resolve_module(fullname)

{vellum_ai-1.7.10 → vellum_ai-1.7.11}/ee/vellum_ee/workflows/tests/test_serialize_module.py

@@ -96,6 +96,54 @@ def test_serialize_module_includes_additional_files():
     assert "CONSTANT_VALUE" in additional_files["utils/constants.py"]
 
 
+def test_serialize_module_with_pydantic_array():
+    """
+    Test that serialize_module correctly serializes arrays of Pydantic models in workflow inputs.
+
+    This test verifies that when a workflow has inputs containing a List[PydanticModel],
+    the serialization properly converts the Pydantic models to JSON format.
+    """
+    module_path = "tests.workflows.pydantic_array_serialization"
+
+    # WHEN we serialize it
+    result = BaseWorkflowDisplay.serialize_module(module_path)
+
+    assert hasattr(result, "exec_config")
+    assert hasattr(result, "errors")
+    assert isinstance(result.exec_config, dict)
+    assert isinstance(result.errors, list)
+
+    input_variables = result.exec_config["input_variables"]
+    assert len(input_variables) == 1
+
+    items_input = input_variables[0]
+    assert items_input["key"] == "items"
+    assert items_input["type"] == "JSON"
+    # TODO: In the future, this should be a custom type based on an OpenAPI schema (important-comment)
+
+    assert result.dataset is not None
+    assert isinstance(result.dataset, list)
+    assert len(result.dataset) == 2
+
+    first_scenario = result.dataset[0]
+    assert first_scenario["label"] == "Scenario 1"
+    assert "items" in first_scenario["inputs"]
+    items = first_scenario["inputs"]["items"]
+    assert isinstance(items, list)
+    assert len(items) == 3
+    assert items[0]["name"] == "item1"
+    assert items[0]["value"] == 10
+    assert items[0]["is_active"] is True
+
+    second_scenario = result.dataset[1]
+    assert second_scenario["label"] == "Custom Test"
+    assert "items" in second_scenario["inputs"]
+    test_items = second_scenario["inputs"]["items"]
+    assert len(test_items) == 2
+    assert test_items[0]["name"] == "test1"
+    assert test_items[0]["value"] == 100
+
+
 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.

{vellum_ai-1.7.10 → vellum_ai-1.7.11}/ee/vellum_ee/workflows/tests/test_server.py

@@ -584,6 +584,111 @@ class BrokenNode(BaseNode):
     assert "UndefinedClass" in error_message or "not defined" in error_message
 
 
+def test_load_from_module__module_not_found_error():
+    """
+    Tests that a ModuleNotFoundError raises WorkflowInitializationException with user-facing message.
+    """
+    # GIVEN a workflow module that imports a non-existent module
+    files = {
+        "__init__.py": "",
+        "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+from .non_existent_module import SomeClass
+
+class Workflow(BaseWorkflow):
+    graph = None
+""",
+    }
+
+    namespace = str(uuid4())
+
+    # AND the virtual file loader is registered
+    sys.meta_path.append(VirtualFileFinder(files, namespace, source_module="test"))
+
+    # WHEN we attempt to load the workflow
+    # THEN it should raise WorkflowInitializationException
+    with pytest.raises(WorkflowInitializationException) as exc_info:
+        BaseWorkflow.load_from_module(namespace)
+
+    # AND the error message should be user-friendly and show source_module instead of namespace
+    error_message = str(exc_info.value)
+    assert error_message == "Workflow module not found: No module named 'test.non_existent_module'"
+
+
+def test_load_from_module__module_not_found_error_with_external_package():
+    """
+    Tests that when ModuleNotFoundError occurs for an external package (not containing the namespace),
+    the exception includes vellum_on_error_action set to CREATE_CUSTOM_IMAGE in raw_data.
+    """
+
+    # GIVEN a workflow module that imports a non-existent external package
+    files = {
+        "__init__.py": "",
+        "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+import some_external_package
+
+class Workflow(BaseWorkflow):
+    graph = None
+""",
+    }
+
+    namespace = str(uuid4())
+
+    # AND the virtual file loader is registered
+    finder = VirtualFileFinder(files, namespace, source_module="test")
+    sys.meta_path.append(finder)
+
+    # WHEN we attempt to load the workflow
+    # THEN it should raise WorkflowInitializationException
+    with pytest.raises(WorkflowInitializationException) as exc_info:
+        BaseWorkflow.load_from_module(namespace)
+
+    # AND the error message should be user-friendly
+    error_message = str(exc_info.value)
+    assert "Workflow module not found:" in error_message
+    assert "some_external_package" in error_message
+
+    assert exc_info.value.raw_data is not None
+    assert exc_info.value.raw_data["vellum_on_error_action"] == "CREATE_CUSTOM_IMAGE"
+
+
+def test_load_from_module__module_not_found_error_with_internal_package():
+    """
+    Tests that when ModuleNotFoundError occurs for an internal module (containing the namespace),
+    the exception does NOT include vellum_on_error_action in raw_data.
+    """
+
+    # GIVEN a workflow module that imports a non-existent internal module
+    files = {
+        "__init__.py": "",
+        "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+from .non_existent_module import SomeClass
+
+class Workflow(BaseWorkflow):
+    graph = None
+""",
+    }
+
+    namespace = str(uuid4())
+
+    # AND the virtual file loader is registered
+    finder = VirtualFileFinder(files, namespace, source_module="test")
+    sys.meta_path.append(finder)
+
+    # WHEN we attempt to load the workflow
+    # THEN it should raise WorkflowInitializationException
+    with pytest.raises(WorkflowInitializationException) as exc_info:
+        BaseWorkflow.load_from_module(namespace)
+
+    # AND the error message should be user-friendly
+    error_message = str(exc_info.value)
+    assert "Workflow module not found:" in error_message
+
+    assert exc_info.value.raw_data is None
+
+
 def test_serialize_module__tool_calling_node_with_single_tool():
     """Test that serialize_module works with a tool calling node that has a single tool."""
 

{vellum_ai-1.7.10 → vellum_ai-1.7.11}/pyproject.toml

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

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

{vellum_ai-1.7.10 → vellum_ai-1.7.11}/src/vellum/workflows/events/tests/test_event.py

@@ -93,6 +93,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                     "display_context": None,
                     "initial_state": None,
                     "workflow_version_exec_config": None,
+                    "server_metadata": None,
                 },
                 "parent": None,
                 "links": None,

{vellum_ai-1.7.10 → vellum_ai-1.7.11}/src/vellum/workflows/events/workflow.py

@@ -83,6 +83,9 @@ class WorkflowExecutionInitiatedBody(_BaseWorkflowExecutionBody, Generic[InputsT
     # This field will be populated during serialization by the serialize_body method
     workflow_version_exec_config: Optional[Any] = None
 
+    # This field can be populated with arbitrary server metadata during event enrichment
+    server_metadata: Optional[Dict[str, Any]] = None
+
     @field_serializer("inputs")
     def serialize_inputs(self, inputs: InputsType, _info: Any) -> Dict[str, Any]:
         return default_serializer(inputs)

{vellum_ai-1.7.10 → vellum_ai-1.7.11}/src/vellum/workflows/exceptions.py

@@ -58,10 +58,12 @@ class WorkflowInitializationException(Exception):
         message: str,
         workflow_definition: Optional[Type["BaseWorkflow"]] = None,
         code: WorkflowErrorCode = WorkflowErrorCode.INVALID_INPUTS,
+        raw_data: Optional[Dict[str, Any]] = None,
     ):
 
         self.message = message
         self.code = code
+        self.raw_data = raw_data
         self.definition = workflow_definition if workflow_definition is not None else import_workflow_class()
         super().__init__(message)
 
@@ -70,4 +72,5 @@ class WorkflowInitializationException(Exception):
         return WorkflowError(
             message=self.message,
             code=self.code,
+            raw_data=self.raw_data,
         )

{vellum_ai-1.7.10 → vellum_ai-1.7.11}/src/vellum/workflows/integrations/mcp_service.py

@@ -1,6 +1,7 @@
 import asyncio
 import json
 import logging
+import traceback
 from typing import Any, Dict, List, Optional
 
 import httpx
@@ -226,6 +227,8 @@ class MCPService:
             raise NodeException(
                 message=f"Error executing MCP operation '{operation}': {str(e)}",
                 code=WorkflowErrorCode.NODE_EXECUTION,
+                stacktrace=traceback.format_exc(),
+                raw_data={"operation": operation, "error_type": type(e).__name__, "error_message": str(e)},
             )
 
     def list_tools(self, server: MCPServer) -> List[Dict[str, Any]]:
@@ -249,11 +252,15 @@ class MCPService:
                 )
             )
             return result
+        except NodeException:
+            raise
         except Exception as e:
             logger.error(f"Error executing MCP tool '{tool_def.name}': {e}")
             raise NodeException(
                 message=f"Error executing MCP tool '{tool_def.name}': {str(e)}",
                 code=WorkflowErrorCode.NODE_EXECUTION,
+                stacktrace=traceback.format_exc(),
+                raw_data={"tool_name": tool_def.name, "error_type": type(e).__name__, "error_message": str(e)},
             )
 
     def hydrate_tool_definitions(self, server_def: MCPServer) -> List[MCPToolDefinition]: