vellum-ai 1.2.3__py3-none-any.whl → 1.2.5__py3-none-any.whl

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/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

@@ -7,6 +7,24 @@ from vellum_ee.workflows.display.utils.registry import (
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
 
+def _should_mark_workflow_dynamic(event: WorkflowExecutionInitiatedEvent) -> bool:
+    """
+    Check if workflow should be marked as dynamic based on execution context.
+    Returns True if parent.type == WORKFLOW_RELEASE_TAG and parent.parent.type == WORKFLOW_NODE.
+    """
+    if not event.parent:
+        return False
+
+    parent = event.parent
+    if parent.type != "WORKFLOW_RELEASE_TAG":
+        return False
+
+    if not parent.parent or parent.parent.type != "WORKFLOW_NODE":
+        return False
+
+    return True
+
+
 def event_enricher(event: WorkflowExecutionInitiatedEvent) -> WorkflowExecutionInitiatedEvent:
     workflow_definition = event.body.workflow_definition
     workflow_display = get_workflow_display(
@@ -16,7 +34,7 @@ def event_enricher(event: WorkflowExecutionInitiatedEvent) -> WorkflowExecutionI
     )
     register_workflow_display_context(event.span_id, workflow_display.display_context)
 
-    if event.body.workflow_definition.is_dynamic:
+    if event.body.workflow_definition.is_dynamic or _should_mark_workflow_dynamic(event):
         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)

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

@@ -2,8 +2,10 @@ import pytest
 from uuid import uuid4
 from typing import Optional
 
+from vellum.workflows.events.types import NodeParentContext, WorkflowDeploymentParentContext
 from vellum.workflows.events.workflow import WorkflowExecutionInitiatedBody, WorkflowExecutionInitiatedEvent
 from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_ee.workflows.display.utils.events import event_enricher
 
@@ -67,3 +69,43 @@ def test_event_enricher_static_workflow(is_dynamic: bool, expected_config: Optio
 
     # AND workflow_version_exec_config is set to the expected config
     assert event.body.workflow_version_exec_config == expected_config
+
+
+def test_event_enricher_marks_subworkflow_deployment_as_dynamic():
+    """Test that event_enricher treats subworkflow deployments as dynamic."""
+
+    class TestWorkflow(BaseWorkflow):
+        is_dynamic = False
+
+        class Outputs(BaseOutputs):
+            pass
+
+    event: WorkflowExecutionInitiatedEvent = WorkflowExecutionInitiatedEvent(
+        trace_id=uuid4(),
+        span_id=uuid4(),
+        parent=WorkflowDeploymentParentContext(
+            span_id=uuid4(),
+            deployment_id=uuid4(),
+            deployment_name="test-deployment",
+            deployment_history_item_id=uuid4(),
+            release_tag_id=uuid4(),
+            release_tag_name="test-tag",
+            workflow_version_id=uuid4(),
+            external_id=None,
+            metadata=None,
+            parent=NodeParentContext(
+                span_id=uuid4(),
+                node_definition=TestWorkflow,
+                parent=None,
+            ),
+        ),
+        body=WorkflowExecutionInitiatedBody(
+            workflow_definition=TestWorkflow,
+            inputs=BaseInputs(),
+        ),
+    )
+
+    enriched_event = event_enricher(event)
+
+    assert hasattr(enriched_event.body, "workflow_version_exec_config")
+    assert enriched_event.body.workflow_version_exec_config is not None