vellum-workflow-server 1.9.6.post1__py3-none-any.whl → 1.10.7__py3-none-any.whl

{vellum_workflow_server-1.9.6.post1.dist-info → vellum_workflow_server-1.10.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-workflow-server
-Version: 1.9.6.post1
+Version: 1.10.7
 Summary: 
 License: AGPL
 Requires-Python: >=3.9.0,<4
@@ -26,10 +26,10 @@ Requires-Dist: gunicorn (==23.0.0)
 Requires-Dist: orderly-set (==5.2.2)
 Requires-Dist: pebble (==5.0.7)
 Requires-Dist: pyjwt (==2.10.0)
-Requires-Dist: python-dotenv (==1.0.1)
+Requires-Dist: python-dotenv (==1.2.1)
 Requires-Dist: retrying (==1.3.4)
 Requires-Dist: sentry-sdk[flask] (==2.20.0)
-Requires-Dist: vellum-ai (==1.9.6)
+Requires-Dist: vellum-ai (==1.10.7)
 Description-Content-Type: text/markdown
 
 # Vellum Workflow Runner Server

{vellum_workflow_server-1.9.6.post1.dist-info → vellum_workflow_server-1.10.7.dist-info}/RECORD

@@ -5,22 +5,23 @@ workflow_server/api/healthz_view.py,sha256=itiRvBDBXncrw8Kbbc73UZLwqMAhgHOR3uSre
 workflow_server/api/status_view.py,sha256=Jah8dBAVL4uOcRfsjKAOyfVONFyk9HQjXeRfjcIqhmA,514
 workflow_server/api/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 workflow_server/api/tests/test_input_display_mapping.py,sha256=drBZqMudFyB5wgiUOcMgRXz7E7ge-Qgxbstw4E4f0zE,2211
-workflow_server/api/tests/test_workflow_view.py,sha256=81kAHpijNp0rvb3ZjvceB5uFEriVWPeWHnK78-xoeTc,32343
-workflow_server/api/tests/test_workflow_view_stream_workflow_route.py,sha256=Yrp_DlLbbwZJe5WRLwdlFT17R8CQoCK9-jlQ1jUT_eM,40377
-workflow_server/api/workflow_view.py,sha256=XSVfHYgsy2k_QqTiue9Xx438Z4qprHbD0PeS8JI04sY,24547
+workflow_server/api/tests/test_workflow_view.py,sha256=B6B8mCirt3FvpPKRP_AyzPJ199k_gwLzAcQuWRkzEfA,32343
+workflow_server/api/tests/test_workflow_view_async_exec.py,sha256=eP_H2xI9SRfJdoJ6HPeynQecnxR50I_8aDCooF-YzIw,11952
+workflow_server/api/tests/test_workflow_view_stream_workflow_route.py,sha256=16ZxP_nuAIP1Cg4-4z6EQttn07SRY1GkVq2m53z6XaE,42389
+workflow_server/api/workflow_view.py,sha256=RiRO0Z_gCIbdcG9XX_PcB9j8Qx5K_2dXxxtkib6fezY,24601
 workflow_server/code_exec_runner.py,sha256=DLNNrinCRbnkSvlqVvSZ1wv_etI7r_kKAXNPGMj3jBk,2196
 workflow_server/config.py,sha256=I4hfTsjIbHxoSKylPCjKnrysPV0jO5nfRKwpKvEcfAE,2193
 workflow_server/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 workflow_server/core/cancel_workflow.py,sha256=QcEeYUIrxq4pub-z9BlGi5fLI3gVRml-56rMCW7j5Hc,2212
 workflow_server/core/events.py,sha256=24MA66DVQuaLJJcZrS8IL1Zq4Ohi9CoouKZ5VgoH3Cs,1402
-workflow_server/core/executor.py,sha256=lP69l8ATeSe88DOUPIO5mmwq1iuQ-02smw7Tr471wTY,17754
-workflow_server/core/utils.py,sha256=si0NB4Suurc-mn8NYdn59xM9CkPrfOP1aWEVrZvifDI,1929
-workflow_server/core/workflow_executor_context.py,sha256=uUlFF2PIfFzIzhHS25mpvO4wO97UWqQVArg7zC2xVcM,3490
+workflow_server/core/executor.py,sha256=xbySFdb9KHoqFDfiKMR77fViFVo3XEQ5ER54C1PlS8c,16948
+workflow_server/core/utils.py,sha256=mecVPqQkthrC4mpop3r8J3IWnBmKbDgqfCrSagyzVEg,2021
+workflow_server/core/workflow_executor_context.py,sha256=8faOdpU4cBeIbmOvg9VzD3eS5i_PKcH7tyNGzx_rehg,3899
 workflow_server/logging_config.py,sha256=Hvx1t8uhqMMinl-5qcef7ufUvzs6x14VRnCb7YZxEAg,1206
 workflow_server/server.py,sha256=pBl0OQmrLE-PbTDwTgsVmxgz_Ai3TVhFRaMnr6PX6Yk,1849
-workflow_server/start.py,sha256=Ams5ycqVbBorC7s6EI95BYzjpxzlo5mQbBnMNOkJS0w,2753
+workflow_server/start.py,sha256=dvV8EKUH_oaTbOzNmUolF7RpkPWW8IkFwlgqOV9BhZQ,2842
 workflow_server/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-workflow_server/utils/exit_handler.py,sha256=_FacDVi4zc3bfTA3D2mJsISePlJ8jpLrnGVo5-xZQFs,743
+workflow_server/utils/exit_handler.py,sha256=PzRpzmia4Ki33sJTWjsvjD5oLP4_qfS5SZg2uXnyqxE,1767
 workflow_server/utils/log_proxy.py,sha256=nugi6fOgAYKX2X9DIc39TG366rsmmDUPoEtG3gzma_Y,3088
 workflow_server/utils/oom_killer.py,sha256=dzaqSzi0jQ3MvALwwiYIO9r6VWLa5Ln9AY6l11WEexo,3050
 workflow_server/utils/sentry.py,sha256=pmGDoaFhJwUprjP_Vmz6bETitqKQulJ0vwRP-gYb2w4,2145
@@ -30,7 +31,7 @@ workflow_server/utils/tests/test_sentry_integration.py,sha256=14PfuW8AaQNNtqLmBs
 workflow_server/utils/tests/test_system_utils.py,sha256=_4GwXvVvU5BrATxUEWwQIPg0bzQXMWBtiBmjP8MTxJM,4314
 workflow_server/utils/tests/test_utils.py,sha256=0Nq6du8o-iBtTrip9_wgHES53JSiJbVdSXaBnPobw3s,6930
 workflow_server/utils/utils.py,sha256=m7iMJtor5SQLWu7jlJw-X5Q3nmbq69BCxTMv6qnFYrA,4835
-vellum_workflow_server-1.9.6.post1.dist-info/METADATA,sha256=69SUWrSyCFeBTIuN7NVAhHUTUBaNtUAgz8SrHFlEOag,2273
-vellum_workflow_server-1.9.6.post1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_workflow_server-1.9.6.post1.dist-info/entry_points.txt,sha256=uB_0yPkr7YV6RhEXzvFReUM8P4OQBlVXD6TN6eb9-oc,277
-vellum_workflow_server-1.9.6.post1.dist-info/RECORD,,
+vellum_workflow_server-1.10.7.dist-info/METADATA,sha256=fmGtKTAbZbiiO93Cw18heCPbkQUjjicY2bEXEg2TB5U,2269
+vellum_workflow_server-1.10.7.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_workflow_server-1.10.7.dist-info/entry_points.txt,sha256=uB_0yPkr7YV6RhEXzvFReUM8P4OQBlVXD6TN6eb9-oc,277
+vellum_workflow_server-1.10.7.dist-info/RECORD,,

workflow_server/api/tests/test_workflow_view.py

@@ -63,11 +63,11 @@ class TestNode(BaseNode):
             "comment": {"expanded": True, "value": "A test node for processing data."},
             "position": {"x": 0.0, "y": 0.0},
         },
-        "id": "7a8b251d-f5ca-462a-b293-071d219460fb",
+        "id": "6f4c9178-9f46-4723-bcb7-0bd59db54eca",
         "label": "Test Node",
         "outputs": [],
-        "ports": [{"id": "a3a0eefd-45d0-4f13-8c58-a836a9f7f9ed", "name": "default", "type": "DEFAULT"}],
-        "trigger": {"id": "a022e36c-9852-4772-9be3-3c6c147fd811", "merge_behavior": "AWAIT_ATTRIBUTES"},
+        "ports": [{"id": "4394823f-79a8-4dbc-99ae-06a1df6c7408", "name": "default", "type": "DEFAULT"}],
+        "trigger": {"id": "07240af1-67c6-4460-b53d-53f0b0f1b90e", "merge_behavior": "AWAIT_ATTRIBUTES"},
         "type": "GENERIC",
     }
 
@@ -127,11 +127,11 @@ class SomeOtherNode(BaseNode):
             "comment": {"expanded": True, "value": "This is Some Node."},
             "position": {"x": 0.0, "y": 0.0},
         },
-        "id": "1e559c2e-db82-41f0-9ceb-5e89b0c5a0a3",
+        "id": "89e84bac-5a5f-4f64-8083-7d3ebec98be1",
         "label": "Some Node",
         "outputs": [],
-        "ports": [{"id": "48e39e97-5fd4-471e-b4f2-51d3baf06456", "name": "default", "type": "DEFAULT"}],
-        "trigger": {"id": "e3381fb7-61fc-4c46-ae8e-51fc463b6a59", "merge_behavior": "AWAIT_ATTRIBUTES"},
+        "ports": [{"id": "2983ea5c-1d29-483a-b896-53098f5de4f1", "name": "default", "type": "DEFAULT"}],
+        "trigger": {"id": "6996efb0-5a20-4719-8835-34fe6552764a", "merge_behavior": "AWAIT_ATTRIBUTES"},
         "type": "GENERIC",
     }
 
@@ -150,11 +150,11 @@ class SomeOtherNode(BaseNode):
             "comment": {"expanded": True, "value": "This is Some Other Node."},
             "position": {"x": 0.0, "y": 0.0},
         },
-        "id": "7aee541b-b245-4c8a-9137-3e4631d5100c",
+        "id": "3cdbba02-8a34-4e0f-8b94-770a944dcaa3",
         "label": "Some Other Node",
         "outputs": [],
-        "ports": [{"id": "fb66b46a-d970-4bc9-83ea-70c154c57ddd", "name": "default", "type": "DEFAULT"}],
-        "trigger": {"id": "13fa2714-20b3-4bc3-ab79-621a188e3bfa", "merge_behavior": "AWAIT_ATTRIBUTES"},
+        "ports": [{"id": "1839bde5-2ad4-4723-b21b-2c55fa833a7a", "name": "default", "type": "DEFAULT"}],
+        "trigger": {"id": "c36df8a8-5624-45be-99c9-826cf511a951", "merge_behavior": "AWAIT_ATTRIBUTES"},
         "type": "GENERIC",
     }
 
@@ -222,11 +222,11 @@ class HelperClass:
                 "comment": {"expanded": True, "value": "Processes input data."},
                 "position": {"x": 0.0, "y": 0.0},
             },
-            "id": "f92c09f0-0434-46cb-829d-a73f801d6343",
+            "id": "7121bcb9-98a1-4907-bf9b-9734d773fd15",
             "label": "Processing Node",
             "outputs": [],
-            "ports": [{"id": "abaa2984-b312-4491-b069-e689759f72c8", "name": "default", "type": "DEFAULT"}],
-            "trigger": {"id": "35378c2b-f089-44af-ac37-efe4ea42c817", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "ports": [{"id": "de27da74-30e9-4e7b-95c2-92bdfc5bf042", "name": "default", "type": "DEFAULT"}],
+            "trigger": {"id": "e02bd85e-8b03-4b21-8b3e-f411042334ce", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "type": "GENERIC",
         }
 
@@ -240,11 +240,11 @@ class HelperClass:
                 "comment": {"expanded": True, "value": "Transforms data format."},
                 "position": {"x": 0.0, "y": 0.0},
             },
-            "id": "09ca32f7-c8f2-4469-97e5-1f288f85127a",
+            "id": "6a785cb0-f631-4f03-94c6-e82331c14c1a",
             "label": "Transformation Node",
             "outputs": [],
-            "ports": [{"id": "88778117-fbfc-4b44-964b-5a4994aa2f24", "name": "default", "type": "DEFAULT"}],
-            "trigger": {"id": "5d096263-7fbf-490a-83b7-e441852b5fb6", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "ports": [{"id": "67a13ea0-fd6b-44dc-af46-c72da06aa11f", "name": "default", "type": "DEFAULT"}],
+            "trigger": {"id": "08d4e317-baa8-478f-b278-99362e50e6b4", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "type": "GENERIC",
         }
 
@@ -306,11 +306,11 @@ class BrokenNode(BaseNode)
             "comment": {"expanded": True, "value": "This is Some Node."},
             "position": {"x": 0.0, "y": 0.0},
         },
-        "id": "1e559c2e-db82-41f0-9ceb-5e89b0c5a0a3",
+        "id": "a2706730-074b-4ea3-968a-25e68af1caed",
         "label": "Some Node",
         "outputs": [],
-        "ports": [{"id": "48e39e97-5fd4-471e-b4f2-51d3baf06456", "name": "default", "type": "DEFAULT"}],
-        "trigger": {"id": "e3381fb7-61fc-4c46-ae8e-51fc463b6a59", "merge_behavior": "AWAIT_ATTRIBUTES"},
+        "ports": [{"id": "e0ee3653-e071-4b91-9dfc-5e1dca9c665b", "name": "default", "type": "DEFAULT"}],
+        "trigger": {"id": "8d931b01-30ca-4c0d-b1b7-7c18379c83e6", "merge_behavior": "AWAIT_ATTRIBUTES"},
         "type": "GENERIC",
     }
 
@@ -371,12 +371,12 @@ class MyAdditionNode(BaseNode):
         "adornments": None,
         "attributes": [
             {
-                "id": "aed3bcbb-d243-4a77-bb5e-409e9a28e868",
+                "id": "4223b340-447f-46c2-b35d-30ef16c5ae17",
                 "name": "arg1",
                 "value": None,
             },
             {
-                "id": "9225d225-a41b-4642-8964-f28f58dcf4bf",
+                "id": "1de0f46a-95f6-4cd0-bb0f-e2414054d507",
                 "name": "arg2",
                 "value": None,
             },
@@ -387,11 +387,11 @@ class MyAdditionNode(BaseNode):
             "comment": {"expanded": True, "value": "Custom node that performs simple addition."},
             "position": {"x": 0.0, "y": 0.0},
         },
-        "id": "195cd69d-3d2d-41e4-a432-16c433cb8d34",
+        "id": "2464b610-fb6d-495b-b17c-933ee147f19f",
         "label": "My Addition Node",
-        "outputs": [{"id": "3d8e40cb-2aa8-44bd-ae6a-708a9fbc4779", "name": "result", "type": "NUMBER", "value": None}],
-        "ports": [{"id": "9a9e4ef6-febf-4093-a515-217bbb1373db", "name": "default", "type": "DEFAULT"}],
-        "trigger": {"id": "a5298668-d808-4a45-a62e-790943948e8a", "merge_behavior": "AWAIT_ATTRIBUTES"},
+        "outputs": [{"id": "f39d85c9-e7bf-45e1-bb67-f16225db0118", "name": "result", "type": "NUMBER", "value": None}],
+        "ports": [{"id": "bc489295-cd8a-4aa2-88bb-34446374100d", "name": "default", "type": "DEFAULT"}],
+        "trigger": {"id": "ff580cad-73d6-44fe-8f2c-4b8dc990ee70", "merge_behavior": "AWAIT_ATTRIBUTES"},
         "type": "GENERIC",
         "should_file_merge": True,
     }

workflow_server/api/tests/test_workflow_view_async_exec.py

@@ -0,0 +1,410 @@
+import pytest
+import logging
+import time
+from uuid import uuid4
+
+from workflow_server.server import create_app
+from workflow_server.utils.system_utils import get_active_process_count
+
+
+@pytest.fixture(autouse=True)
+def drain_background_threads():
+    """
+    Ensures background threads from previous tests complete before starting the next test.
+    This prevents cross-test interference in process count assertions.
+    """
+    baseline = get_active_process_count()
+    yield
+
+    deadline = time.time() + 15
+    while time.time() < deadline:
+        current_count = get_active_process_count()
+        if current_count == baseline:
+            break
+        time.sleep(0.1)
+
+
+def test_async_exec_route__happy_path():
+    """
+    Tests that the async-exec route successfully accepts a valid workflow and returns immediately.
+    """
+    # GIVEN a Flask application
+    flask_app = create_app()
+
+    # AND a valid workflow request
+    span_id = uuid4()
+    request_body = {
+        "execution_id": str(span_id),
+        "inputs": [],
+        "environment_api_key": "test",
+        "module": "workflow",
+        "timeout": 360,
+        "files": {
+            "__init__.py": "",
+            "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+
+class Workflow(BaseWorkflow):
+    class Outputs(BaseWorkflow.Outputs):
+        foo = "hello"
+""",
+        },
+    }
+
+    # WHEN we make a request to the async-exec route
+    with flask_app.test_client() as test_client:
+        response = test_client.post("/workflow/async-exec", json=request_body)
+
+    # THEN we should get a 200 response
+    assert response.status_code == 200
+
+    # AND the response should indicate success
+    assert response.json == {"success": True}
+
+
+def test_async_exec_route__with_inputs():
+    """
+    Tests that the async-exec route handles workflows with inputs correctly.
+    """
+    # GIVEN a Flask application
+    flask_app = create_app()
+
+    # AND a valid workflow request with inputs
+    span_id = uuid4()
+    request_body = {
+        "execution_id": str(span_id),
+        "inputs": [
+            {"name": "foo", "type": "STRING", "value": "hello"},
+        ],
+        "environment_api_key": "test",
+        "module": "workflow",
+        "timeout": 360,
+        "files": {
+            "__init__.py": "",
+            "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.state import BaseState
+from .inputs import Inputs
+
+class Workflow(BaseWorkflow[Inputs, BaseState]):
+    class Outputs(BaseWorkflow.Outputs):
+        foo = "hello"
+""",
+            "inputs.py": """\
+from vellum.workflows.inputs import BaseInputs
+
+class Inputs(BaseInputs):
+    foo: str
+""",
+        },
+    }
+
+    # WHEN we make a request to the async-exec route
+    with flask_app.test_client() as test_client:
+        response = test_client.post("/workflow/async-exec", json=request_body)
+
+    # THEN we should get a 200 response
+    assert response.status_code == 200
+
+    # AND the response should indicate success
+    assert response.json == {"success": True}
+
+
+def test_async_exec_route__with_state():
+    """
+    Tests that the async-exec route handles workflows with state correctly.
+    """
+    # GIVEN a Flask application
+    flask_app = create_app()
+
+    # AND a valid workflow request with state
+    span_id = uuid4()
+    request_body = {
+        "execution_id": str(span_id),
+        "state": {"foo": "bar"},
+        "environment_api_key": "test",
+        "module": "workflow",
+        "timeout": 360,
+        "files": {
+            "__init__.py": "",
+            "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs import BaseInputs
+from .state import State
+
+class Workflow(BaseWorkflow[BaseInputs, State]):
+    class Outputs(BaseWorkflow.Outputs):
+        foo = State.foo
+""",
+            "state.py": """\
+from vellum.workflows.state import BaseState
+
+class State(BaseState):
+    foo: str
+""",
+        },
+    }
+
+    # WHEN we make a request to the async-exec route
+    with flask_app.test_client() as test_client:
+        response = test_client.post("/workflow/async-exec", json=request_body)
+
+    # THEN we should get a 200 response
+    assert response.status_code == 200
+
+    # AND the response should indicate success
+    assert response.json == {"success": True}
+
+
+def test_async_exec_route__invalid_context():
+    """
+    Tests that the async-exec route returns 400 for invalid request context.
+    """
+    # GIVEN a Flask application
+    flask_app = create_app()
+
+    # AND an invalid request missing required fields
+    request_body = {
+        "inputs": [],
+    }
+
+    # WHEN we make a request to the async-exec route
+    with flask_app.test_client() as test_client:
+        response = test_client.post("/workflow/async-exec", json=request_body)
+
+    # THEN we should get a 400 response
+    assert response.status_code == 400
+
+    # AND the response should contain error details
+    assert "detail" in response.json
+    assert "Invalid context" in response.json["detail"]
+
+
+def test_async_exec_route__missing_files():
+    """
+    Tests that the async-exec route returns 400 when files are missing.
+    """
+    # GIVEN a Flask application
+    flask_app = create_app()
+
+    span_id = uuid4()
+    request_body = {
+        "execution_id": str(span_id),
+        "inputs": [],
+        "environment_api_key": "test",
+        "module": "workflow",
+        "timeout": 360,
+    }
+
+    # WHEN we make a request to the async-exec route
+    with flask_app.test_client() as test_client:
+        response = test_client.post("/workflow/async-exec", json=request_body)
+
+    # THEN we should get a 400 response
+    assert response.status_code == 400
+
+    # AND the response should contain error details
+    assert "detail" in response.json
+    assert "Invalid context" in response.json["detail"]
+
+
+def test_async_exec_route__with_syntax_error_in_workflow():
+    """
+    Tests that the async-exec route handles workflows with syntax errors gracefully.
+    """
+    # GIVEN a Flask application
+    flask_app = create_app()
+
+    span_id = uuid4()
+    request_body = {
+        "execution_id": str(span_id),
+        "inputs": [],
+        "environment_api_key": "test",
+        "module": "workflow",
+        "timeout": 360,
+        "files": {
+            "__init__.py": "",
+            "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+
+class Workflow(BaseWorkflow)
+    class Outputs(BaseWorkflow.Outputs):
+        foo = "hello"
+""",
+        },
+    }
+
+    # WHEN we make a request to the async-exec route
+    with flask_app.test_client() as test_client:
+        response = test_client.post("/workflow/async-exec", json=request_body)
+
+    # THEN we should get a 200 response (async execution is accepted)
+    assert response.status_code == 200
+
+    # AND the response should indicate success
+    assert response.json == {"success": True}
+
+
+def test_async_exec_route__with_invalid_inputs():
+    """
+    Tests that the async-exec route handles workflows with invalid inputs gracefully.
+    """
+    # GIVEN a Flask application
+    flask_app = create_app()
+
+    span_id = uuid4()
+    request_body = {
+        "execution_id": str(span_id),
+        "inputs": [],
+        "environment_api_key": "test",
+        "module": "workflow",
+        "timeout": 360,
+        "files": {
+            "__init__.py": "",
+            "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.state import BaseState
+from .inputs import Inputs
+
+class Workflow(BaseWorkflow[Inputs, BaseState]):
+    class Outputs(BaseWorkflow.Outputs):
+        foo = "hello"
+""",
+            "inputs.py": """\
+from vellum.workflows.inputs import BaseInputs
+
+class Inputs(BaseInputs):
+    foo: str
+""",
+        },
+    }
+
+    # WHEN we make a request to the async-exec route
+    with flask_app.test_client() as test_client:
+        response = test_client.post("/workflow/async-exec", json=request_body)
+
+    # THEN we should get a 200 response (async execution is accepted)
+    assert response.status_code == 200
+
+    # AND the response should indicate success
+    assert response.json == {"success": True}
+
+
+def test_async_exec_route__background_thread_completes(caplog):
+    """
+    Verifies that the async background worker thread runs to completion.
+    """
+    # GIVEN a Flask application with log capture enabled
+    caplog.set_level(logging.INFO, logger="workflow_server.api.workflow_view")
+    flask_app = create_app()
+
+    baseline = get_active_process_count()
+
+    # AND a valid workflow request
+    span_id = uuid4()
+    request_body = {
+        "execution_id": str(span_id),
+        "inputs": [],
+        "environment_api_key": "test",
+        "module": "workflow",
+        "timeout": 360,
+        "files": {
+            "__init__.py": "",
+            "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+
+class Workflow(BaseWorkflow):
+    class Outputs(BaseWorkflow.Outputs):
+        foo = "hello"
+""",
+        },
+    }
+
+    # WHEN we call the async-exec route
+    with flask_app.test_client() as test_client:
+        response = test_client.post("/workflow/async-exec", json=request_body)
+
+    # THEN we get immediate acceptance
+    assert response.status_code == 200
+    assert response.json == {"success": True}
+
+    # AND the background thread should complete
+    completion_deadline = time.time() + 15
+    saw_completion_log = False
+    while time.time() < completion_deadline:
+        if any("Workflow async exec completed" in rec.message for rec in caplog.records):
+            saw_completion_log = True
+            break
+        time.sleep(0.1)
+
+    # THEN we should observe the completion log
+    assert saw_completion_log, "Did not observe background completion log within 15 seconds"
+
+    cleanup_deadline = time.time() + 15
+    process_count_returned = False
+    while time.time() < cleanup_deadline:
+        current_count = get_active_process_count()
+        if current_count == baseline:
+            process_count_returned = True
+            break
+        time.sleep(0.1)
+
+    current_count = get_active_process_count()
+    assert process_count_returned, (
+        f"Process count did not return to baseline within 15 seconds after completion log. "
+        f"Expected: {baseline}, Current: {current_count}"
+    )
+
+
+def test_async_exec_route__background_thread_completes_on_error(caplog):
+    """
+    Verifies that the background worker completes even when the workflow fails early.
+    """
+    # GIVEN a Flask application with log capture enabled
+    caplog.set_level(logging.INFO, logger="workflow_server.api.workflow_view")
+    flask_app = create_app()
+
+    baseline = get_active_process_count()
+
+    span_id = uuid4()
+    request_body = {
+        "execution_id": str(span_id),
+        "inputs": [],
+        "environment_api_key": "test",
+        "module": "workflow",
+        "timeout": 360,
+        "files": {
+            "__init__.py": "",
+            "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+
+class Workflow(BaseWorkflow)
+    class Outputs(BaseWorkflow.Outputs):
+        foo = "hello"
+""",
+        },
+    }
+
+    # WHEN we call the async-exec route
+    with flask_app.test_client() as test_client:
+        response = test_client.post("/workflow/async-exec", json=request_body)
+
+    # THEN we get immediate acceptance
+    assert response.status_code == 200
+    assert response.json == {"success": True}
+
+    # AND the background thread should complete and clean up resources
+    deadline = time.time() + 15
+    process_count_returned = False
+    while time.time() < deadline:
+        current_count = get_active_process_count()
+        if current_count == baseline:
+            process_count_returned = True
+            break
+        time.sleep(0.1)
+
+    current_count = get_active_process_count()
+    assert process_count_returned, (
+        f"Process count did not return to baseline on error within 15 seconds. "
+        f"Expected: {baseline}, Current: {current_count}"
+    )

workflow_server/api/tests/test_workflow_view_stream_workflow_route.py

@@ -1241,3 +1241,72 @@ class InvalidWorkflow(BaseWorkflow):
     assert events[3]["name"] == "vembda.execution.fulfilled"
     assert events[3]["span_id"] == str(span_id)
     assert events[3]["body"]["exit_code"] == 0
+
+
+@mock.patch("workflow_server.api.workflow_view.get_is_oom_killed")
+def test_stream_workflow_route__oom_does_not_set_timed_out_flag(mock_get_is_oom_killed):
+    """
+    Tests that when an OOM error occurs, we don't set the timed_out flag in the vembda fulfilled event.
+    """
+    # GIVEN a workflow that takes some time to execute
+    span_id = uuid4()
+    request_body = {
+        "timeout": 10,
+        "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 SlowNode(BaseNode):
+    class Outputs(BaseNode.Outputs):
+        value: str
+
+    def run(self) -> Outputs:
+        time.sleep(2)
+        return self.Outputs(value="hello world")
+
+
+class OOMWorkflow(BaseWorkflow):
+    graph = SlowNode
+    class Outputs(BaseWorkflow.Outputs):
+        final_value = SlowNode.Outputs.value
+
+""",
+        },
+    }
+
+    # WHEN we mock the OOM killer to trigger after a few checks
+    call_count = [0]
+
+    def mock_oom_side_effect():
+        call_count[0] += 1
+        if call_count[0] > 3:
+            return True
+        return False
+
+    mock_get_is_oom_killed.side_effect = mock_oom_side_effect
+
+    # AND we call the stream route
+    status_code, events = flask_stream(request_body)
+
+    # THEN we get a 200 response
+    assert status_code == 200
+
+    # AND we get the expected events
+    event_names = [e["name"] for e in events]
+
+    assert "vembda.execution.initiated" in event_names
+
+    # THEN the key assertion: if there's a vembda.execution.fulfilled event, it should NOT have timed_out=True
+    vembda_fulfilled_event = next(e for e in events if e["name"] == "vembda.execution.fulfilled")
+    assert (
+        vembda_fulfilled_event["body"].get("timed_out") is not True
+    ), "timed_out flag should not be set when OOM occurs"

workflow_server/api/workflow_view.py

@@ -528,6 +528,7 @@ def serialize_route() -> Response:
     files = data.get("files", {})
     workspace_api_key = data.get("workspace_api_key")
     is_new_server = data.get("is_new_server", False)
+    module = data.get("module")
 
     if not files:
         return Response(
@@ -540,7 +541,7 @@ def serialize_route() -> Response:
 
     # Generate a unique namespace for this serialization request
     namespace = get_random_namespace()
-    virtual_finder = VirtualFileFinder(files, namespace)
+    virtual_finder = VirtualFileFinder(files, namespace, source_module=module)
 
     headers = {
         "X-Vellum-Is-New-Server": str(is_new_server).lower(),

workflow_server/core/executor.py

@@ -11,7 +11,7 @@ from threading import Event as ThreadingEvent
 import time
 from traceback import format_exc
 from uuid import UUID, uuid4
-from typing import Any, Callable, Generator, Iterator, Optional, Tuple, Type
+from typing import Any, Callable, Generator, Iterator, Optional, Tuple
 
 from vellum_ee.workflows.display.utils.events import event_enricher
 from vellum_ee.workflows.server.virtual_file_loader import VirtualFileFinder
@@ -273,32 +273,11 @@ def stream_node(
     disable_redirect: bool = True,
 ) -> Iterator[dict]:
     workflow, namespace = _create_workflow(executor_context)
-    Node: Optional[Type[BaseNode]] = None
-
-    for workflow_node in workflow.get_nodes():
-        if executor_context.node_id and workflow_node.__id__ == executor_context.node_id:
-            Node = workflow_node
-            break
-        elif (
-            executor_context.node_module
-            and executor_context.node_name
-            and workflow_node.__name__ == executor_context.node_name
-            and workflow_node.__module__ == f"{namespace}.{executor_context.node_module}"
-        ):
-            Node = workflow_node
-            break
-
-    if not Node:
-        identifier = executor_context.node_id or f"{executor_context.node_module}.{executor_context.node_name}"
-        raise WorkflowInitializationException(
-            message=f"Node '{identifier}' not found in workflow",
-            workflow_definition=workflow.__class__,
-        )
 
     def call_node() -> Generator[dict[str, Any], Any, None]:
         executor_context.stream_start_time = time.time_ns()
 
-        for event in workflow.run_node(Node, inputs=executor_context.inputs):  # type: ignore[arg-type]
+        for event in workflow.run_node(executor_context.node_ref, inputs=executor_context.inputs):
             yield event.model_dump(mode="json")
 
     return _call_stream(
@@ -359,7 +338,9 @@ def _call_stream(
 def _create_workflow(executor_context: BaseExecutorContext) -> Tuple[BaseWorkflow, str]:
     namespace = _get_file_namespace(executor_context)
     if namespace != LOCAL_WORKFLOW_MODULE:
-        sys.meta_path.append(VirtualFileFinder(executor_context.files, namespace))
+        sys.meta_path.append(
+            VirtualFileFinder(executor_context.files, namespace, source_module=executor_context.module)
+        )
 
     workflow_context = _create_workflow_context(executor_context)
     Workflow = BaseWorkflow.load_from_module(namespace)

workflow_server/core/utils.py

@@ -2,6 +2,7 @@ from datetime import datetime
 from uuid import uuid4
 from typing import Optional
 
+from workflow_server.config import IS_ASYNC_MODE
 from workflow_server.core.events import VembdaExecutionFulfilledBody, VembdaExecutionFulfilledEvent
 from workflow_server.core.workflow_executor_context import BaseExecutorContext
 
@@ -46,6 +47,9 @@ def serialize_vembda_rejected_event(
 
 
 def is_events_emitting_enabled(executor_context: Optional[BaseExecutorContext]) -> bool:
+    if IS_ASYNC_MODE:
+        return True
+
     if not executor_context:
         return False
 

workflow_server/core/workflow_executor_context.py

@@ -3,7 +3,7 @@ from functools import cached_property
 import os
 import time
 from uuid import UUID
-from typing import Any, Optional
+from typing import Any, Optional, Union
 from typing_extensions import Self
 
 from flask import has_request_context, request
@@ -91,6 +91,18 @@ class NodeExecutorContext(BaseExecutorContext):
     node_module: Optional[str] = None
     node_name: Optional[str] = None
 
+    @property
+    def node_ref(self) -> Union[UUID, str]:
+        """
+        Returns the node reference for use with workflow.run_node().
+
+        Returns node_id if it exists, otherwise returns the combination
+        of node_module and node_name as a fully qualified string.
+        """
+        if self.node_id:
+            return self.node_id
+        return f"{self.node_module}.{self.node_name}"
+
     @model_validator(mode="after")
     def validate_node_identification(self) -> Self:
         if not self.node_id and not (self.node_module and self.node_name):

workflow_server/start.py

@@ -64,8 +64,8 @@ def start() -> None:
         "workers": int(os.getenv("GUNICORN_WORKERS", 2)),
         "threads": int(os.getenv("GUNICORN_THREADS", 9 if ENABLE_PROCESS_WRAPPER else 6)),
         # Aggressively try to avoid memory leaks when using non process mode
-        "max_requests": 120 if ENABLE_PROCESS_WRAPPER else 20,
-        "max_requests_jitter": 30 if ENABLE_PROCESS_WRAPPER else 10,
+        "max_requests": int(os.getenv("GUNICORN_MAX_REQUESTS", 120 if ENABLE_PROCESS_WRAPPER else 20)),
+        "max_requests_jitter": int(os.getenv("GUNICORN_MAX_REQUESTS_JITTER", 30 if ENABLE_PROCESS_WRAPPER else 10)),
         "worker_class": "gthread",
         "timeout": max_workflow_runtime_seconds,
         "logger_class": CustomGunicornLogger,

workflow_server/utils/exit_handler.py

@@ -1,15 +1,43 @@
+from datetime import datetime
 import logging
 import multiprocessing
 import signal
+from time import sleep
 from typing import Any
 
+from workflow_server.config import IS_ASYNC_MODE, is_development
+from workflow_server.utils.system_utils import get_active_process_count
+
 logger = logging.getLogger(__name__)
 process_killed_switch = multiprocessing.Event()
 
 
+def _wait_for_workers() -> None:
+    # Would be annoying to have this on for dev since would prevent reload restarts. Also disabling this
+    # for non async mode for now since it shouldn't be needed anyway cus we keep the requests open.
+    if is_development() and not IS_ASYNC_MODE:
+        return
+
+    start_time = datetime.now()
+    loops = 0
+
+    while get_active_process_count() > 0:
+        if loops % 30 == 0:
+            logger.info("Waiting for workflow processes to finish...")
+
+        # TODO needa pass in max workflow time here for VPC
+        if (datetime.now() - start_time).total_seconds() > 1800:
+            logger.warning("Max elapsed time waiting for workflow processes to complete exceeded, shutting down")
+            exit(1)
+
+        sleep(1)
+        loops += 1
+
+
 def gunicorn_exit_handler(_worker: Any) -> None:
+    logger.info("Received gunicorn kill signal")
     process_killed_switch.set()
-    logger.warning("Received gunicorn kill signal")
+    _wait_for_workers()
 
 
 def exit_handler(_signal: int, _frame: Any) -> None:
@@ -19,6 +47,7 @@ def exit_handler(_signal: int, _frame: Any) -> None:
     """
     process_killed_switch.set()
     logger.warning("Received kill signal")
+    _wait_for_workers()
     exit(1)