vellum-ai 1.2.2__py3-none-any.whl → 1.2.4__py3-none-any.whl

vellum_cli/__init__.py

@@ -68,6 +68,7 @@ with the provided module or be available for use. The Workflow Sandbox must also
 @click.option("--deployment-name", type=str, help="Unique name for the Deployment")
 @click.option("--deployment-description", type=str, help="Description for the Deployment")
 @click.option("--release-tag", help="Release Tag for the Deployment", multiple=True)
+@click.option("--release-description", type=str, help="Description for the Release")
 @click.option(
     "--dry-run",
     is_flag=True,
@@ -87,6 +88,7 @@ def workflows_push(
     deployment_name: Optional[str],
     deployment_description: Optional[str],
     release_tag: Optional[List[str]],
+    release_description: Optional[str],
     dry_run: Optional[bool],
     strict: Optional[bool],
     workspace: Optional[str],
@@ -104,6 +106,7 @@ def workflows_push(
         deployment_name=deployment_name,
         deployment_description=deployment_description,
         release_tags=release_tag,
+        release_description=release_description,
         dry_run=dry_run,
         strict=strict,
         workspace=workspace,
@@ -118,6 +121,7 @@ def workflows_push(
 @click.option("--deployment-name", type=str, help="Unique name for the Deployment")
 @click.option("--deployment-description", type=str, help="Description for the Deployment")
 @click.option("--release-tag", help="Release Tag for the Deployment", multiple=True)
+@click.option("--release-description", type=str, help="Description for the Release")
 @click.option(
     "--dry-run",
     is_flag=True,
@@ -137,6 +141,7 @@ def push_module(
     deployment_name: Optional[str],
     deployment_description: Optional[str],
     release_tag: Optional[List[str]],
+    release_description: Optional[str],
     dry_run: Optional[bool],
     strict: Optional[bool],
     workspace: Optional[str],
@@ -152,6 +157,7 @@ def push_module(
             deployment_name=deployment_name,
             deployment_description=deployment_description,
             release_tags=release_tag,
+            release_description=release_description,
             dry_run=dry_run,
             strict=strict,
             workspace=workspace,

vellum_cli/config.py

@@ -36,6 +36,7 @@ class WorkflowDeploymentConfig(UniversalBaseModel):
     name: Optional[str] = None
     description: Optional[str] = None
     release_tags: Optional[List[str]] = None
+    release_description: Optional[str] = None
 
     def merge(self, other: "WorkflowDeploymentConfig") -> "WorkflowDeploymentConfig":
         return WorkflowDeploymentConfig(
@@ -44,6 +45,7 @@ class WorkflowDeploymentConfig(UniversalBaseModel):
             name=self.name or other.name,
             description=self.description or other.description,
             release_tags=self.release_tags or other.release_tags,
+            release_description=self.release_description or other.release_description,
         )
 
 

vellum_cli/push.py

@@ -28,6 +28,7 @@ def push_command(
     deployment_name: Optional[str] = None,
     deployment_description: Optional[str] = None,
     release_tags: Optional[List[str]] = None,
+    release_description: Optional[str] = None,
     dry_run: Optional[bool] = None,
     strict: Optional[bool] = None,
     workspace: Optional[str] = None,
@@ -142,6 +143,7 @@ def push_command(
                 name=deployment_name or cli_deployment_config.name or to_kebab_case(module_name),
                 description=deployment_description or cli_deployment_config.description,
                 release_tags=release_tags or cli_deployment_config.release_tags,
+                release_description=release_description or cli_deployment_config.release_description,
             )
         except ValidationError as e:
             for error in e.errors():
@@ -286,6 +288,7 @@ Visit at: {base_url}/workflow-sandboxes/{response.workflow_sandbox_id}"""
             name=deployment_config.name if deploy else None,
             description=deployment_config.description if deploy else None,
             release_tags=deployment_config.release_tags if deploy else None,
+            release_description=getattr(deployment_config, "release_description", None) if deploy else None,
         )
         workflow_config.deployments.append(stored_deployment_config)
 

vellum_cli/tests/test_pull.py

@@ -393,6 +393,7 @@ def test_pull__workflow_deployment_with_no_config(vellum_client):
                             "name": "my-deployment",
                             "description": None,
                             "release_tags": None,
+                            "release_description": None,
                         }
                     ],
                     "container_image_tag": None,
@@ -641,6 +642,7 @@ def test_pull__sandbox_id_with_other_workflow_deployment_in_lock(vellum_client,
                         "name": None,
                         "description": None,
                         "release_tags": None,
+                        "release_description": None,
                     },
                 ],
                 "container_image_name": None,

vellum_cli/tests/test_push.py

@@ -1042,6 +1042,45 @@ def test_push__deploy_with_release_tags_success(mock_module, vellum_client):
     assert "Updated vellum.lock.json file." in result.output
 
 
+@pytest.mark.usefixtures("info_log_level")
+def test_push__deploy_with_release_description_success(mock_module, vellum_client):
+    # GIVEN a single workflow configured
+    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 successfully
+    workflow_deployment_id = str(uuid4())
+    vellum_client.workflows.push.return_value = WorkflowPushResponse(
+        workflow_sandbox_id=str(uuid4()),
+        workflow_deployment_id=workflow_deployment_id,
+    )
+
+    # WHEN calling `vellum workflows push` with --deploy and --release-description
+    runner = CliRunner()
+    result = runner.invoke(
+        cli_main, ["workflows", "push", module, "--deploy", "--release-description", "This is a test release"]
+    )
+
+    # THEN it should succeed
+    assert result.exit_code == 0, result.output
+
+    # AND we should have called the push API with the correct deployment config
+    vellum_client.workflows.push.assert_called_once()
+    call_args = vellum_client.workflows.push.call_args.kwargs
+
+    # AND the deployment_config should contain the release description
+    deployment_config_str = call_args["deployment_config"]
+    deployment_config = json.loads(deployment_config_str)
+    assert deployment_config["release_description"] == "This is a test release"
+
+    # AND should show success message
+    assert "Successfully pushed" in result.output
+    assert "Updated vellum.lock.json file." in result.output
+
+
 def test_push__deploy_stores_deployment_config_in_lock_file(mock_module, vellum_client):
     # GIVEN a single workflow
     temp_dir = mock_module.temp_dir

vellum_ee/workflows/display/nodes/vellum/error_node.py

@@ -2,7 +2,7 @@ from uuid import UUID
 from typing import Any, ClassVar, Generic, Optional, TypeVar
 
 from vellum.workflows.nodes import ErrorNode
-from vellum.workflows.types.core import JsonArray, JsonObject
+from vellum.workflows.types.core import JsonObject
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
@@ -20,10 +20,6 @@ class BaseErrorNodeDisplay(BaseNodeDisplay[_ErrorNodeType], Generic[_ErrorNodeTy
 
     __serializable_inputs__ = {ErrorNode.error}
 
-    def serialize_ports(self, display_context: "WorkflowDisplayContext") -> JsonArray:
-        """Error nodes have no ports."""
-        return []
-
     def serialize(self, display_context: WorkflowDisplayContext, **_kwargs) -> JsonObject:
         node_id = self.node_id
         error_source_input_id = self.node_input_ids_by_name.get(

vellum_ee/workflows/display/nodes/vellum/final_output_node.py

@@ -2,7 +2,7 @@ from uuid import UUID
 from typing import ClassVar, Generic, Optional, TypeVar
 
 from vellum.workflows.nodes.displayable.final_output_node import FinalOutputNode
-from vellum.workflows.types.core import JsonArray, JsonObject
+from vellum.workflows.types.core import JsonObject
 from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import to_kebab_case
@@ -19,10 +19,6 @@ NODE_INPUT_KEY = "node_input"
 class BaseFinalOutputNodeDisplay(BaseNodeDisplay[_FinalOutputNodeType], Generic[_FinalOutputNodeType]):
     output_name: ClassVar[Optional[str]] = None
 
-    def serialize_ports(self, display_context: "WorkflowDisplayContext") -> JsonArray:
-        """Final output nodes have no ports."""
-        return []
-
     def serialize(self, display_context: WorkflowDisplayContext, **_kwargs) -> JsonObject:
         node = self._node
         node_id = self.node_id

vellum_ee/workflows/display/nodes/vellum/tests/test_tool_calling_node.py

@@ -191,6 +191,7 @@ def test_serialize_node__tool_calling_node__mcp_server_api_key():
                     {
                         "type": "MCP_SERVER",
                         "name": "my-mcp-server",
+                        "description": "",
                         "url": "https://my-mcp-server.com",
                         "authorization_type": "API_KEY",
                         "bearer_token_value": None,
@@ -243,6 +244,7 @@ def test_serialize_node__tool_calling_node__mcp_server_no_authorization():
                     {
                         "type": "MCP_SERVER",
                         "name": "my-mcp-server",
+                        "description": "",
                         "url": "https://my-mcp-server.com",
                         "authorization_type": None,
                         "bearer_token_value": None,

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

@@ -52,6 +52,7 @@ def test_serialize_workflow():
                     {
                         "type": "MCP_SERVER",
                         "name": "github",
+                        "description": "",
                         "url": "https://api.githubcopilot.com/mcp/",
                         "authorization_type": "BEARER_TOKEN",
                         "bearer_token_value": "GITHUB_PERSONAL_ACCESS_TOKEN",

vellum_ee/workflows/display/utils/events.py

@@ -0,0 +1,24 @@
+from vellum.workflows.events.workflow import WorkflowExecutionInitiatedEvent
+from vellum_ee.workflows.display.utils.registry import (
+    get_parent_display_context_from_event,
+    register_workflow_display_class,
+    register_workflow_display_context,
+)
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+def event_enricher(event: WorkflowExecutionInitiatedEvent) -> WorkflowExecutionInitiatedEvent:
+    workflow_definition = event.body.workflow_definition
+    workflow_display = get_workflow_display(
+        workflow_class=workflow_definition,
+        parent_display_context=get_parent_display_context_from_event(event),
+        dry_run=True,
+    )
+    register_workflow_display_context(event.span_id, workflow_display.display_context)
+
+    if event.body.workflow_definition.is_dynamic:
+        register_workflow_display_class(workflow_definition, workflow_display.__class__)
+        workflow_version_exec_config = workflow_display.serialize()
+        setattr(event.body, "workflow_version_exec_config", workflow_version_exec_config)
+
+    return event

vellum_ee/workflows/display/utils/tests/test_events.py

@@ -0,0 +1,69 @@
+import pytest
+from uuid import uuid4
+from typing import Optional
+
+from vellum.workflows.events.workflow import WorkflowExecutionInitiatedBody, WorkflowExecutionInitiatedEvent
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.workflows.base import BaseWorkflow
+from vellum_ee.workflows.display.utils.events import event_enricher
+
+
+@pytest.mark.parametrize(
+    "is_dynamic,expected_config",
+    [
+        (False, None),
+        (
+            True,
+            {
+                "workflow_raw_data": {
+                    "nodes": [
+                        {
+                            "id": "86607b18-7872-49f3-a592-fda1428f70aa",
+                            "type": "ENTRYPOINT",
+                            "inputs": [],
+                            "data": {
+                                "label": "Entrypoint Node",
+                                "source_handle_id": "d1fe8f4c-53d7-43a0-b210-73ebdc60bf57",
+                            },
+                            "display_data": {"position": {"x": 0.0, "y": -50.0}},
+                            "base": None,
+                            "definition": None,
+                        }
+                    ],
+                    "edges": [],
+                    "display_data": {"viewport": {"x": 0.0, "y": 0.0, "zoom": 1.0}},
+                    "definition": {
+                        "name": "TestWorkflow",
+                        "module": ["vellum_ee", "workflows", "display", "utils", "tests", "test_events"],
+                    },
+                    "output_values": [],
+                },
+                "input_variables": [],
+                "state_variables": [],
+                "output_variables": [],
+            },
+        ),
+    ],
+)
+def test_event_enricher_static_workflow(is_dynamic: bool, expected_config: Optional[dict]):
+    """Test event_enricher with a static workflow (is_dynamic=False)."""
+    # GIVEN a workflow class with the specified is_dynamic value
+    _is_dynamic = is_dynamic
+
+    class TestWorkflow(BaseWorkflow):
+        is_dynamic = _is_dynamic
+
+    event: WorkflowExecutionInitiatedEvent = WorkflowExecutionInitiatedEvent(
+        trace_id=uuid4(),
+        span_id=uuid4(),
+        body=WorkflowExecutionInitiatedBody(
+            workflow_definition=TestWorkflow,
+            inputs=BaseInputs(),
+        ),
+    )
+
+    # WHEN the event_enricher is called with mocked dependencies
+    event_enricher(event)
+
+    # AND workflow_version_exec_config is set to the expected config
+    assert event.body.workflow_version_exec_config == expected_config

vellum_ee/workflows/tests/test_server.py

@@ -8,6 +8,7 @@ from vellum.client.types.number_vellum_value import NumberVellumValue
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.nodes import BaseNode
 from vellum.workflows.state.context import WorkflowContext
+from vellum.workflows.utils.uuids import generate_workflow_deployment_prefix
 from vellum_ee.workflows.display.workflows.base_workflow_display import BaseWorkflowDisplay
 from vellum_ee.workflows.server.virtual_file_loader import VirtualFileFinder
 
@@ -566,3 +567,97 @@ class Workflow(BaseWorkflow[Inputs, BaseState]):
 
     # THEN the serialization should complete successfully
     assert result is not None
+
+
+def test_resolve_workflow_deployment__returns_workflow_with_generated_files():
+    """
+    Test that resolve_workflow_deployment returns a workflow with artifacts
+    in generated_files using the correct prefix format.
+    """
+    # GIVEN a deployment name and release tag
+    deployment_name = "test_deployment"
+    release_tag = "LATEST"
+
+    expected_prefix = generate_workflow_deployment_prefix(deployment_name, release_tag)
+
+    # Create a simple test node for the resolved workflow
+    test_node_code = """
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.outputs import BaseOutputs
+
+class TestNode(BaseNode):
+    template = "Hello"
+
+    class Outputs(BaseOutputs):
+        result: str
+
+    def run(self):
+        return self.Outputs(result="Hello, {template}")
+"""
+
+    mock_workflow_code = """
+from vellum.workflows import BaseWorkflow
+from .nodes.test_node import TestNode
+
+class ResolvedWorkflow(BaseWorkflow):
+    graph = TestNode
+"""
+
+    # Create parent workflow files that reference the subworkflow deployment
+    parent_workflow_code = """
+from vellum.workflows import BaseWorkflow
+from .nodes.subworkflow_deployment_node import TestSubworkflowDeploymentNode
+
+class ParentWorkflow(BaseWorkflow):
+    graph = TestSubworkflowDeploymentNode
+"""
+
+    parent_node_code = """
+from vellum.workflows.nodes import SubworkflowDeploymentNode
+from vellum.workflows.outputs import BaseOutputs
+
+class TestSubworkflowDeploymentNode(SubworkflowDeploymentNode):
+    deployment = "test_deployment"
+
+    class Outputs(BaseOutputs):
+        result: str
+
+    subworkflow_inputs = {"message": "test"}
+"""
+
+    files = {
+        "__init__.py": "",
+        "workflow.py": parent_workflow_code,
+        "nodes/__init__.py": """
+from .subworkflow_deployment_node import TestSubworkflowDeploymentNode
+
+__all__ = ["TestSubworkflowDeploymentNode"]
+""",
+        "nodes/subworkflow_deployment_node.py": parent_node_code,
+        f"{expected_prefix}/__init__.py": "",
+        f"{expected_prefix}/workflow.py": mock_workflow_code,
+        f"{expected_prefix}/nodes/__init__.py": """
+from .test_node import TestNode
+
+__all__ = ["TestNode"]
+""",
+        f"{expected_prefix}/nodes/test_node.py": test_node_code,
+    }
+
+    namespace = str(uuid4())
+
+    # AND the virtual file loader is registered
+    finder = VirtualFileFinder(files, namespace)
+    sys.meta_path.append(finder)
+
+    # WHEN we execute the root workflow
+    Workflow = BaseWorkflow.load_from_module(namespace)
+    workflow = Workflow(context=WorkflowContext(generated_files=files, namespace=namespace))
+
+    # THEN the workflow should be successfully initialized
+    assert workflow
+
+    event = workflow.run()
+
+    # AND the method should return a workflow (not None) - this will pass once implemented
+    assert event.name == "workflow.execution.fulfilled"