vellum-workflow-server 1.5.6__tar.gz → 1.9.1.post2__tar.gz

{vellum_workflow_server-1.5.6 → vellum_workflow_server-1.9.1.post2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-workflow-server
-Version: 1.5.6
+Version: 1.9.1.post2
 Summary: 
 License: AGPL
 Requires-Python: >=3.9.0,<4
@@ -29,7 +29,7 @@ Requires-Dist: pyjwt (==2.10.0)
 Requires-Dist: python-dotenv (==1.0.1)
 Requires-Dist: retrying (==1.3.4)
 Requires-Dist: sentry-sdk[flask] (==2.20.0)
-Requires-Dist: vellum-ai (==1.5.6)
+Requires-Dist: vellum-ai (==1.9.1)
 Description-Content-Type: text/markdown
 
 # Vellum Workflow Runner Server

{vellum_workflow_server-1.5.6 → vellum_workflow_server-1.9.1.post2}/pyproject.toml

@@ -3,7 +3,7 @@ name = "vellum-workflow-server"
 
 [tool.poetry]
 name = "vellum-workflow-server"
-version = "1.5.6"
+version = "1.9.1.post2"
 description = ""
 readme = "README.md"
 authors = []
@@ -45,7 +45,7 @@ flask = "2.3.3"
 orderly-set = "5.2.2"
 pebble = "5.0.7"
 gunicorn = "23.0.0"
-vellum-ai = "1.5.6"
+vellum-ai = "1.9.1"
 python-dotenv = "1.0.1"
 retrying = "1.3.4"
 sentry-sdk = {extras = ["flask"], version = "2.20.0"}

{vellum_workflow_server-1.5.6 → vellum_workflow_server-1.9.1.post2}/src/workflow_server/api/auth_middleware.py

@@ -5,7 +5,7 @@ from flask import Flask, Request, Response
 import jwt
 from jwt import ExpiredSignatureError
 
-from workflow_server.config import IS_VPC, NAMESPACE, VEMBDA_PUBLIC_KEY, is_development
+from workflow_server.config import IS_ASYNC_MODE, IS_VPC, NAMESPACE, VEMBDA_PUBLIC_KEY, is_development
 
 
 class AuthMiddleware:
@@ -15,7 +15,7 @@ class AuthMiddleware:
     def __call__(self, environ: Dict[str, Any], start_response: Any) -> Any:
         try:
             request = Request(environ)
-            if not request.path.startswith("/healthz") and not is_development() and not IS_VPC:
+            if not request.path.startswith("/healthz") and not is_development() and not IS_VPC and not IS_ASYNC_MODE:
                 token = request.headers.get("X-Vembda-Signature")
                 if token:
                     decoded = jwt.decode(token, VEMBDA_PUBLIC_KEY, algorithms=["RS256"])

vellum_workflow_server-1.9.1.post2/src/workflow_server/api/status_view.py

@@ -0,0 +1,19 @@
+from typing import Tuple
+
+from flask import Blueprint, Response, jsonify
+
+from workflow_server.config import CONCURRENCY
+from workflow_server.utils.system_utils import get_active_process_count
+
+bp = Blueprint("status", __name__)
+
+
+@bp.route("/is_available", methods=["GET"])
+def is_available() -> Tuple[Response, int]:
+    resp = jsonify(
+        available=get_active_process_count() < CONCURRENCY,
+        process_count=get_active_process_count(),
+        max_concurrency=CONCURRENCY,
+    )
+
+    return resp, 200

{vellum_workflow_server-1.5.6 → vellum_workflow_server-1.9.1.post2}/src/workflow_server/api/tests/test_workflow_view.py

@@ -373,12 +373,12 @@ class MyAdditionNode(BaseNode):
             {
                 "id": "aed3bcbb-d243-4a77-bb5e-409e9a28e868",
                 "name": "arg1",
-                "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+                "value": None,
             },
             {
                 "id": "9225d225-a41b-4642-8964-f28f58dcf4bf",
                 "name": "arg2",
-                "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+                "value": None,
             },
         ],
         "base": {"module": ["vellum", "workflows", "nodes", "bases", "base"], "name": "BaseNode"},
@@ -429,7 +429,7 @@ class BrokenNode(BaseNode)  # Missing colon
     with flask_app.test_client() as test_client:
         response = test_client.post("/workflow/serialize", json={"files": {"broken_node.py": invalid_content}})
 
-    # THEN we should get a 4xx response
+    # THEN we should get a 400 response
     assert response.status_code == 400
 
     # AND the response should contain an error message
@@ -537,6 +537,57 @@ def test_serialize_route__with_invalid_workspace_api_key():
     assert "exec_config" in response.json
 
 
+def test_serialize_route__with_is_new_server_header():
+    """
+    Tests that the serialize route returns the is_new_server header.
+    """
+    # GIVEN a Flask application
+    flask_app = create_app()
+
+    workflow_files = {
+        "__init__.py": "",
+        "workflow.py": (
+            "from vellum.workflows import BaseWorkflow\n\n"
+            "class Workflow(BaseWorkflow):\n"
+            "    class Outputs(BaseWorkflow.Outputs):\n"
+            "        foo = 'hello'\n"
+        ),
+    }
+
+    # WHEN we make a request with is_new_server=True
+    with flask_app.test_client() as test_client:
+        response = test_client.post("/workflow/serialize", json={"files": workflow_files, "is_new_server": True})
+
+    # THEN we should get a successful response
+    assert response.status_code == 200
+
+    # AND the response should contain the is_new_server header set to true
+    assert "X-Vellum-Is-New-Server" in response.headers
+    assert response.headers["X-Vellum-Is-New-Server"] == "true"
+
+    # WHEN we make a request with is_new_server=False
+    with flask_app.test_client() as test_client:
+        response = test_client.post("/workflow/serialize", json={"files": workflow_files, "is_new_server": False})
+
+    # THEN we should get a successful response
+    assert response.status_code == 200
+
+    # AND the response should contain the is_new_server header set to false
+    assert "X-Vellum-Is-New-Server" in response.headers
+    assert response.headers["X-Vellum-Is-New-Server"] == "false"
+
+    # WHEN we make a request without is_new_server
+    with flask_app.test_client() as test_client:
+        response = test_client.post("/workflow/serialize", json={"files": workflow_files})
+
+    # THEN we should get a successful response
+    assert response.status_code == 200
+
+    # AND the response should contain the is_new_server header set to false (default)
+    assert "X-Vellum-Is-New-Server" in response.headers
+    assert response.headers["X-Vellum-Is-New-Server"] == "false"
+
+
 def test_stream_node_route__with_node_id():
     """
     Tests that the stream-node endpoint works with node_id.
@@ -729,3 +780,45 @@ class Workflow(BaseWorkflow):
     assert events[0]["name"] == "vembda.execution.initiated"
     assert events[1]["name"] == "vembda.execution.fulfilled"
     assert len(events) == 2
+
+
+def test_serialize_route__with_invalid_nested_set_graph():
+    """
+    Tests that a workflow with an invalid nested set graph structure raises a clear user-facing exception.
+    """
+    # GIVEN a Flask application
+    flask_app = create_app()
+
+    invalid_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
+"""
+
+    workflow_files = {
+        "__init__.py": "",
+        "workflow.py": invalid_workflow_content,
+    }
+
+    # WHEN we make a request to the serialize route
+    with flask_app.test_client() as test_client:
+        response = test_client.post("/workflow/serialize", json={"files": workflow_files})
+
+    # THEN we should get a 400 response
+    assert response.status_code == 400
+
+    # AND the response should contain a user-friendly error message
+    assert "detail" in response.json
+    error_detail = response.json["detail"]
+    assert "Serialization failed" in error_detail
+    assert "Invalid graph structure detected" in error_detail
+    assert "contact Vellum support" in error_detail

{vellum_workflow_server-1.5.6 → vellum_workflow_server-1.9.1.post2}/src/workflow_server/api/tests/test_workflow_view_stream_workflow_route.py

@@ -117,7 +117,7 @@ def test_stream_workflow_route__happy_path(both_stream_types):
         "execution_id": str(span_id),
         "inputs": [],
         "environment_api_key": "test",
-        "module": "workflow",
+        "module": "test",
         "timeout": 360,
         "files": {
             "__init__.py": "",
@@ -131,8 +131,9 @@ class Workflow(BaseWorkflow):
         },
     }
 
-    # WHEN we call the stream route
-    status_code, events = both_stream_types(request_body)
+    with mock.patch("builtins.open", mock.mock_open(read_data="104857600")):
+        # WHEN we call the stream route
+        status_code, events = both_stream_types(request_body)
 
     # THEN we get a 200 response
     assert status_code == 200, events
@@ -154,8 +155,37 @@ class Workflow(BaseWorkflow):
     }
 
     assert events[1]["name"] == "workflow.execution.initiated", events[1]
+    assert events[1]["body"]["workflow_definition"]["module"] == ["test", "workflow"]
     assert "display_context" in events[1]["body"], events[1]["body"]
+    display_context = events[1]["body"]["display_context"]
+    assert "node_displays" in display_context
+    assert "workflow_inputs" in display_context
+    assert "workflow_outputs" in display_context
+    assert isinstance(display_context["node_displays"], dict)
+    assert isinstance(display_context["workflow_inputs"], dict)
+    assert isinstance(display_context["workflow_outputs"], dict)
+    assert "foo" in display_context["workflow_outputs"]
+
+    # AND the initiated event should have server_metadata with version info and memory usage
+    assert "server_metadata" in events[1]["body"], events[1]["body"]
+    server_metadata = events[1]["body"]["server_metadata"]
+    assert server_metadata is not None, "server_metadata should not be None"
+    assert "server_version" in server_metadata
+    assert "sdk_version" in server_metadata
+    assert "memory_usage_mb" in server_metadata
+    assert isinstance(server_metadata["memory_usage_mb"], (int, float))
+    assert "is_new_server" in server_metadata
+    assert server_metadata["is_new_server"] is False
+
     assert events[2]["name"] == "workflow.execution.fulfilled", events[2]
+    assert events[2]["body"]["workflow_definition"]["module"] == ["test", "workflow"]
+
+    # AND the fulfilled event should have server_metadata with memory usage
+    assert "server_metadata" in events[2]["body"], events[2]["body"]
+    fulfilled_metadata = events[2]["body"]["server_metadata"]
+    assert fulfilled_metadata is not None, "fulfilled server_metadata should not be None"
+    assert "memory_usage_mb" in fulfilled_metadata
+    assert isinstance(fulfilled_metadata["memory_usage_mb"], (int, float))
 
     assert events[3] == {
         "id": mock.ANY,
@@ -234,6 +264,15 @@ class Inputs(BaseInputs):
 
     assert events[1]["name"] == "workflow.execution.initiated", events[1]
     assert "display_context" in events[1]["body"], events[1]["body"]
+    display_context = events[1]["body"]["display_context"]
+    assert "node_displays" in display_context
+    assert "workflow_inputs" in display_context
+    assert "workflow_outputs" in display_context
+    assert isinstance(display_context["node_displays"], dict)
+    assert isinstance(display_context["workflow_inputs"], dict)
+    assert isinstance(display_context["workflow_outputs"], dict)
+    assert "foo" in display_context["workflow_inputs"]
+    assert "foo" in display_context["workflow_outputs"]
     assert events[2]["name"] == "workflow.execution.fulfilled", events[2]
 
     assert events[3] == {
@@ -311,6 +350,14 @@ class State(BaseState):
 
     assert events[1]["name"] == "workflow.execution.initiated", events[1]
     assert "display_context" in events[1]["body"], events[1]["body"]
+    display_context = events[1]["body"]["display_context"]
+    assert "node_displays" in display_context
+    assert "workflow_inputs" in display_context
+    assert "workflow_outputs" in display_context
+    assert isinstance(display_context["node_displays"], dict)
+    assert isinstance(display_context["workflow_inputs"], dict)
+    assert isinstance(display_context["workflow_outputs"], dict)
+    assert "foo" in display_context["workflow_outputs"]
     assert events[2]["name"] == "workflow.execution.fulfilled", events[2]
     assert events[2]["body"]["outputs"] == {"foo": "bar"}
 
@@ -339,9 +386,15 @@ class State(BaseState):
 def test_stream_workflow_route__bad_indent_in_inputs_file(both_stream_types):
     # GIVEN a valid request body
     span_id = uuid4()
+    trace_id = uuid4()
+    parent_span_id = uuid4()
     request_body = {
         "timeout": 360,
         "execution_id": str(span_id),
+        "execution_context": {
+            "trace_id": str(trace_id),
+            "parent_context": {"span_id": str(parent_span_id)},
+        },
         "inputs": [
             {"name": "foo", "type": "STRING", "value": "hello"},
         ],
@@ -378,7 +431,7 @@ from vellum.workflows.inputs import BaseInputs
 
     assert events[0] == {
         "id": mock.ANY,
-        "trace_id": mock.ANY,
+        "trace_id": str(trace_id),
         "span_id": str(span_id),
         "timestamp": mock.ANY,
         "api_version": "2024-10-25",
@@ -392,11 +445,22 @@ from vellum.workflows.inputs import BaseInputs
     }
 
     assert events[1]["name"] == "workflow.execution.initiated"
+    assert events[1]["trace_id"] == str(trace_id), "workflow initiated event should use request trace_id"
+    assert events[1]["parent"] is not None, "workflow initiated event should have parent context"
+    assert events[1]["parent"]["span_id"] == str(
+        parent_span_id
+    ), "workflow initiated event parent should match request parent_context"
 
     assert events[2]["name"] == "workflow.execution.rejected"
+    assert events[2]["trace_id"] == str(trace_id), "workflow rejected event should use request trace_id"
     assert events[2]["span_id"] == events[1]["span_id"]
+    assert events[2]["parent"] is not None, "workflow rejected event should have parent context"
+    assert events[2]["parent"]["span_id"] == str(
+        parent_span_id
+    ), "workflow rejected event parent should match request parent_context"
     assert (
-        "Failed to initialize workflow: unexpected indent (inputs.py, line 3)" in events[2]["body"]["error"]["message"]
+        "Syntax Error raised while loading Workflow: "
+        "unexpected indent (inputs.py, line 3)" in events[2]["body"]["error"]["message"]
     )
 
     assert events[3] == {
@@ -570,6 +634,71 @@ class BasicCancellableWorkflow(BaseWorkflow):
         )
 
 
+def test_stream_workflow_route__timeout_emits_rejection_events():
+    """
+    Tests that when a workflow times out, we emit node and workflow rejection events.
+    """
+
+    span_id = uuid4()
+    request_body = {
+        "timeout": 1,
+        "execution_id": str(span_id),
+        "inputs": [],
+        "environment_api_key": "test",
+        "module": "workflow",
+        "files": {
+            "__init__.py": "",
+            "workflow.py": """\
+import time
+
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.workflows.base import BaseWorkflow
+
+
+class LongRunningNode(BaseNode):
+    class Outputs(BaseNode.Outputs):
+        value: str
+
+    def run(self) -> Outputs:
+        time.sleep(30)
+        return self.Outputs(value="hello world")
+
+
+class TimeoutWorkflow(BaseWorkflow):
+    graph = LongRunningNode
+    class Outputs(BaseWorkflow.Outputs):
+        final_value = LongRunningNode.Outputs.value
+
+""",
+        },
+    }
+
+    status_code, events = flask_stream(request_body)
+
+    assert status_code == 200
+
+    event_names = [e["name"] for e in events]
+
+    assert "vembda.execution.initiated" in event_names
+    assert "workflow.execution.initiated" in event_names
+    assert "node.execution.initiated" in event_names
+
+    assert "node.execution.rejected" in event_names, "Should emit node.execution.rejected on timeout"
+    node_execution_rejected = next(e for e in events if e["name"] == "node.execution.rejected")
+    assert "vellum/workflows/runner/runner.py" in node_execution_rejected["body"]["stacktrace"]
+
+    assert "workflow.execution.rejected" in event_names, "Should emit workflow.execution.rejected on timeout"
+    workflow_execution_rejected = next(e for e in events if e["name"] == "workflow.execution.rejected")
+    assert workflow_execution_rejected["body"]["error"]["code"] == "WORKFLOW_TIMEOUT"
+    # TODO: Uncomment once version 1.8.1 is released
+    # assert "stacktrace" in workflow_execution_rejected["body"]
+    # assert "vellum/workflows/runner/runner.py" in workflow_execution_rejected["body"]["stacktrace"]
+
+    assert "vembda.execution.fulfilled" in event_names
+    vembda_fulfilled = next(e for e in events if e["name"] == "vembda.execution.fulfilled")
+    assert vembda_fulfilled["body"]["timed_out"] is True
+
+
 def test_stream_workflow_route__very_large_events(both_stream_types):
     # GIVEN a valid request body
     span_id = uuid4()
@@ -1031,3 +1160,72 @@ class Workflow(BaseWorkflow):
     assert len(event_names) == 2, "Should include 2 events"
     assert "workflow.execution.initiated" in event_names, "Should include workflow.execution.initiated event"
     assert "workflow.execution.fulfilled" in event_names, "Should include workflow.execution.fulfilled event"
+
+
+def test_stream_workflow_route__with_invalid_nested_set_graph(both_stream_types):
+    """
+    Tests that a workflow with an invalid nested set graph structure raises a clear error in the stream response.
+    """
+    # GIVEN a Flask application and invalid workflow content with nested set graph
+    span_id = uuid4()
+
+    invalid_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
+"""
+
+    request_body = {
+        "timeout": 360,
+        "execution_id": str(span_id),
+        "inputs": [],
+        "environment_api_key": "test",
+        "module": "workflow",
+        "files": {
+            "__init__.py": "",
+            "workflow.py": invalid_workflow_content,
+        },
+    }
+
+    # WHEN we call the stream route
+    status_code, events = both_stream_types(request_body)
+
+    # THEN we get a 200 response
+    assert status_code == 200, events
+
+    # THEN we get the expected events: vembda initiated, workflow initiated, workflow rejected, vembda fulfilled
+    assert len(events) == 4
+
+    # AND the first event should be vembda execution initiated
+    assert events[0]["name"] == "vembda.execution.initiated"
+    assert events[0]["span_id"] == str(span_id)
+
+    # AND the second event should be workflow execution initiated
+    assert events[1]["name"] == "workflow.execution.initiated"
+
+    # AND the third event should be workflow execution rejected
+    assert events[2]["name"] == "workflow.execution.rejected"
+    assert events[1]["span_id"] == events[2]["span_id"]
+
+    # AND the error message should contain information about the invalid graph structure
+    error_message = events[2]["body"]["error"]["message"]
+    expected_message = (
+        "Invalid graph structure detected. "
+        "Nested sets or unsupported graph types are not allowed. "
+        "Please contact Vellum support for assistance with Workflow configuration."
+    )
+    assert error_message == expected_message
+
+    # AND the fourth event should be vembda execution fulfilled
+    assert events[3]["name"] == "vembda.execution.fulfilled"
+    assert events[3]["span_id"] == str(span_id)
+    assert events[3]["body"]["exit_code"] == 0