vellum-workflow-server 1.9.0.post2__tar.gz → 1.9.8.post2__tar.gz

{vellum_workflow_server-1.9.0.post2 → vellum_workflow_server-1.9.8.post2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-workflow-server
-Version: 1.9.0.post2
+Version: 1.9.8.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.9.0)
+Requires-Dist: vellum-ai (==1.9.8)
 Description-Content-Type: text/markdown
 
 # Vellum Workflow Runner Server

{vellum_workflow_server-1.9.0.post2 → vellum_workflow_server-1.9.8.post2}/pyproject.toml

@@ -3,7 +3,7 @@ name = "vellum-workflow-server"
 
 [tool.poetry]
 name = "vellum-workflow-server"
-version = "1.9.0.post2"
+version = "1.9.8.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.9.0"
+vellum-ai = "1.9.8"
 python-dotenv = "1.0.1"
 retrying = "1.3.4"
 sentry-sdk = {extras = ["flask"], version = "2.20.0"}

{vellum_workflow_server-1.9.0.post2 → vellum_workflow_server-1.9.8.post2}/src/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,
     }

{vellum_workflow_server-1.9.0.post2 → vellum_workflow_server-1.9.8.post2}/src/workflow_server/api/tests/test_workflow_view_stream_workflow_route.py

@@ -5,6 +5,7 @@ import io
 import json
 from queue import Empty
 import re
+import time
 from unittest import mock
 from uuid import uuid4
 
@@ -133,6 +134,8 @@ class Workflow(BaseWorkflow):
 
     with mock.patch("builtins.open", mock.mock_open(read_data="104857600")):
         # WHEN we call the stream route
+        ts_ns = time.time_ns()
+        request_body["vembda_service_initiated_timestamp"] = ts_ns
         status_code, events = both_stream_types(request_body)
 
     # THEN we get a 200 response
@@ -177,6 +180,15 @@ class Workflow(BaseWorkflow):
     assert "is_new_server" in server_metadata
     assert server_metadata["is_new_server"] is False
 
+    # AND the initiated event should have initiated_latency within a reasonable range
+    assert "initiated_latency" in server_metadata, "initiated_latency should be present in server_metadata"
+    initiated_latency = server_metadata["initiated_latency"]
+    assert isinstance(initiated_latency, int), "initiated_latency should be an integer (nanoseconds)"
+    # Latency should be positive and less than 60 seconds (60_000_000_000 nanoseconds) for CI
+    assert (
+        0 < initiated_latency < 60_000_000_000
+    ), f"initiated_latency should be between 0 and 60 seconds, got {initiated_latency} ns"
+
     assert events[2]["name"] == "workflow.execution.fulfilled", events[2]
     assert events[2]["body"]["workflow_definition"]["module"] == ["test", "workflow"]
 

{vellum_workflow_server-1.9.0.post2 → vellum_workflow_server-1.9.8.post2}/src/workflow_server/api/workflow_view.py

@@ -8,6 +8,7 @@ import os
 import pkgutil
 from queue import Empty
 import sys
+import threading
 import time
 import traceback
 from uuid import uuid4
@@ -71,19 +72,195 @@ WORKFLOW_INITIATION_TIMEOUT_SECONDS = 60
 @bp.route("/stream", methods=["POST"])
 def stream_workflow_route() -> Response:
     data = request.get_json()
+    try:
+        context = WorkflowExecutorContext.model_validate(data)
+    except ValidationError as e:
+        error_message = e.errors()[0]["msg"]
+        error_location = e.errors()[0]["loc"]
+
+        return Response(
+            json.dumps({"detail": f"Invalid context: {error_message} at {error_location}"}),
+            status=400,
+            content_type="application/json",
+        )
+
+    headers = _get_headers(context)
+
+    # We can exceed the concurrency count currently with long running workflows due to a knative issue. So here
+    # if we detect a memory problem just exit us early
+    if not wait_for_available_process():
+        return Response(
+            json.dumps(
+                {
+                    "detail": f"Workflow server concurrent request rate exceeded. "
+                    f"Process count: {get_active_process_count()}"
+                }
+            ),
+            status=429,
+            content_type="application/json",
+            headers=headers,
+        )
+
+    start_workflow_state = _start_workflow(context)
+    if isinstance(start_workflow_state, Response):
+        return start_workflow_state
+
+    workflow_events, vembda_initiated_event, process, span_id, headers = start_workflow_state
+
+    def generator() -> Generator[str, None, None]:
+        try:
+            yield "\n"
+            yield vembda_initiated_event.model_dump_json()
+            yield "\n"
+            for row in workflow_events:
+                yield "\n"
+                if isinstance(row, dict):
+                    dump = json.dumps(row)
+                    yield dump
+                else:
+                    yield row
+                yield "\n"
+            # Sometimes the connections get hung after they finish with the vembda fulfilled event
+            # if it happens during a knative scale down event. So we emit an END string so that
+            # we don't have to do string compares on all the events for performance.
+            yield "\n"
+            yield "END"
+            yield "\n"
+
+            logger.info(
+                f"Workflow stream completed, execution ID: {span_id}, process count: {get_active_process_count()}"
+            )
+        except GeneratorExit:
+            # These can happen either from Vembda disconnects (possibily from predict disconnects) or
+            # from knative activator gateway timeouts which are caused by idleTimeout or responseStartSeconds
+            # being exceeded.
+            app.logger.error(
+                "Client disconnected in the middle of the Workflow Stream",
+                extra={
+                    "sentry_tags": {
+                        "server_version": vembda_initiated_event.body.server_version,
+                        "sdk_version": vembda_initiated_event.body.sdk_version,
+                    }
+                },
+            )
+            return
+        except Exception as e:
+            logger.exception("Error during workflow response stream generator", extra={"error": e})
+            yield "\n"
+            yield "END"
+            yield "\n"
+            return
+        finally:
+            if ENABLE_PROCESS_WRAPPER:
+                try:
+                    if process and process.is_alive():
+                        process.kill()
+                    if process:
+                        increment_process_count(-1)
+                        remove_active_span_id(span_id)
+                except Exception as e:
+                    logger.error("Failed to kill process", e)
+            else:
+                increment_process_count(-1)
+                remove_active_span_id(span_id)
+
+    resp = Response(
+        stream_with_context(generator()),
+        status=200,
+        content_type="application/x-ndjson",
+        headers=headers,
+    )
+    return resp
 
+
+@bp.route("/async-exec", methods=["POST"])
+def async_exec_workflow() -> Response:
+    data = request.get_json()
     try:
         context = WorkflowExecutorContext.model_validate(data)
     except ValidationError as e:
         error_message = e.errors()[0]["msg"]
         error_location = e.errors()[0]["loc"]
 
+        # TODO need to convert this to a vembda event so that trigger'd execs can me notified
+        #  can either do it here in the workflow server or
         return Response(
             json.dumps({"detail": f"Invalid context: {error_message} at {error_location}"}),
             status=400,
             content_type="application/json",
         )
 
+    # Reject back to the queue handler if were low on memory here, though maybe we should update the is_available
+    # route to look at memory too. Don't send this response as an event. Though we might want some logic to catch
+    # if they have a workflow server that can never start a workflow because the base image uses so much memory.
+    if not wait_for_available_process():
+        return Response(
+            json.dumps({"detail": f"Server resources low." f"Process count: {get_active_process_count()}"}),
+            status=429,
+            content_type="application/json",
+        )
+
+    def run_workflow_background() -> None:
+        process: Optional[Process] = None
+        span_id: Optional[str] = None
+
+        try:
+            start_workflow_result = _start_workflow(context)
+            if isinstance(start_workflow_result, Response):
+                # TODO same here, should return this response as en event or it will get yeeted to the nether
+                # return start_workflow_result
+                return
+
+            workflow_events, vembda_initiated_event, process, span_id, headers = start_workflow_result
+
+            for _ in workflow_events:
+                # This is way inefficient in process mode since were just having the main proc stream the events
+                # to nowhere wasting memory I/O and cpu.
+                continue
+            logger.info(
+                f"Workflow async exec completed, execution ID: {span_id}, process count: {get_active_process_count()}"
+            )
+        except Exception as e:
+            logger.exception("Error during workflow async background worker", e)
+        finally:
+            if ENABLE_PROCESS_WRAPPER:
+                try:
+                    if process and process.is_alive():
+                        process.kill()
+                    if process:
+                        increment_process_count(-1)
+                        if span_id:
+                            remove_active_span_id(span_id)
+                except Exception as e:
+                    logger.error("Failed to kill process", e)
+            else:
+                increment_process_count(-1)
+                if span_id:
+                    remove_active_span_id(span_id)
+
+    thread = threading.Thread(target=run_workflow_background)
+    thread.start()
+
+    return Response(
+        json.dumps({"success": True}),
+        status=200,
+        content_type="application/json",
+    )
+
+
+def _start_workflow(
+    context: WorkflowExecutorContext,
+) -> Union[
+    Response,
+    tuple[
+        Iterator[Union[str, dict]],
+        VembdaExecutionInitiatedEvent,
+        Optional[Process],
+        str,
+        dict[str, str],
+    ],
+]:
+    headers = _get_headers(context)
     logger.info(
         f"Starting Workflow Server Request, trace ID: {context.trace_id}, "
         f"process count: {get_active_process_count()}, process wrapper: {ENABLE_PROCESS_WRAPPER}"
@@ -100,29 +277,7 @@ def stream_workflow_route() -> Response:
         parent=None,
     )
 
-    process_output_queue: Queue[Union[str, dict]] = Queue()
-
-    headers = {
-        "X-Vellum-SDK-Version": vembda_initiated_event.body.sdk_version,
-        "X-Vellum-Server-Version": vembda_initiated_event.body.server_version,
-        "X-Vellum-Events-Emitted": str(is_events_emitting_enabled(context)),
-    }
-
-    # We can exceed the concurrency count currently with long running workflows due to a knative issue. So here
-    # if we detect a memory problem just exit us early
-    if not wait_for_available_process():
-        return Response(
-            json.dumps(
-                {
-                    "detail": f"Workflow server concurrent request rate exceeded. "
-                    f"Process count: {get_active_process_count()}"
-                }
-            ),
-            status=429,
-            content_type="application/json",
-            headers=headers,
-        )
-
+    output_queue: Queue[Union[str, dict]] = Queue()
     cancel_signal = MultiprocessingEvent()
     timeout_signal = MultiprocessingEvent()
 
@@ -131,7 +286,7 @@ def stream_workflow_route() -> Response:
         try:
             process = stream_workflow_process_timeout(
                 executor_context=context,
-                queue=process_output_queue,
+                queue=output_queue,
                 cancel_signal=cancel_signal,
                 timeout_signal=timeout_signal,
             )
@@ -139,10 +294,10 @@ def stream_workflow_route() -> Response:
         except Exception as e:
             logger.exception(e)
 
-            process_output_queue.put(create_vembda_rejected_event(context, traceback.format_exc()))
+            output_queue.put(create_vembda_rejected_event(context, traceback.format_exc()))
 
         try:
-            first_item = process_output_queue.get(timeout=WORKFLOW_INITIATION_TIMEOUT_SECONDS)
+            first_item = output_queue.get(timeout=WORKFLOW_INITIATION_TIMEOUT_SECONDS)
         except Empty:
             logger.error("Request timed out trying to initiate the Workflow")
 
@@ -291,72 +446,9 @@ def stream_workflow_route() -> Response:
                 break
             yield event
 
-    workflow_events = process_events(process_output_queue)
+    workflow_events = process_events(output_queue)
 
-    def generator() -> Generator[str, None, None]:
-        try:
-            yield "\n"
-            yield vembda_initiated_event.model_dump_json()
-            yield "\n"
-            for row in workflow_events:
-                yield "\n"
-                if isinstance(row, dict):
-                    dump = json.dumps(row)
-                    yield dump
-                else:
-                    yield row
-                yield "\n"
-            # Sometimes the connections get hung after they finish with the vembda fulfilled event
-            # if it happens during a knative scale down event. So we emit an END string so that
-            # we don't have to do string compares on all the events for performance.
-            yield "\n"
-            yield "END"
-            yield "\n"
-
-            logger.info(
-                f"Workflow stream completed, execution ID: {span_id}, process count: {get_active_process_count()}"
-            )
-        except GeneratorExit:
-            # These can happen either from Vembda disconnects (possibily from predict disconnects) or
-            # from knative activator gateway timeouts which are caused by idleTimeout or responseStartSeconds
-            # being exceeded.
-            app.logger.error(
-                "Client disconnected in the middle of the Workflow Stream",
-                extra={
-                    "sentry_tags": {
-                        "server_version": vembda_initiated_event.body.server_version,
-                        "sdk_version": vembda_initiated_event.body.sdk_version,
-                    }
-                },
-            )
-            return
-        except Exception as e:
-            logger.exception("Error during workflow response stream generator", extra={"error": e})
-            yield "\n"
-            yield "END"
-            yield "\n"
-            return
-        finally:
-            if ENABLE_PROCESS_WRAPPER:
-                try:
-                    if process and process.is_alive():
-                        process.kill()
-                    if process:
-                        increment_process_count(-1)
-                        remove_active_span_id(span_id)
-                except Exception as e:
-                    logger.error("Failed to kill process", e)
-            else:
-                increment_process_count(-1)
-                remove_active_span_id(span_id)
-
-    resp = Response(
-        stream_with_context(generator()),
-        status=200,
-        content_type="application/x-ndjson",
-        headers=headers,
-    )
-    return resp
+    return workflow_events, vembda_initiated_event, process, span_id, headers
 
 
 @bp.route("/stream-node", methods=["POST"])
@@ -436,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(
@@ -448,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(),
@@ -564,3 +657,12 @@ def startup_error_generator(
             },
         )
         return
+
+
+def _get_headers(context: WorkflowExecutorContext) -> dict[str, Union[str, Any]]:
+    headers = {
+        "X-Vellum-SDK-Version": get_version()["sdk_version"],
+        "X-Vellum-Server-Version": get_version()["server_version"],
+        "X-Vellum-Events-Emitted": str(is_events_emitting_enabled(context)),
+    }
+    return headers

{vellum_workflow_server-1.9.0.post2 → vellum_workflow_server-1.9.8.post2}/src/workflow_server/core/executor.py

@@ -1,4 +1,4 @@
-from datetime import datetime
+from datetime import datetime, timezone
 from io import StringIO
 import json
 import logging
@@ -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
@@ -191,6 +191,7 @@ def stream_workflow(
             previous_execution_id=executor_context.previous_execution_id,
             timeout=executor_context.timeout,
             trigger=trigger,
+            execution_id=executor_context.workflow_span_id,
         )
     except WorkflowInitializationException as e:
         cancel_watcher_kill_switch.set()
@@ -272,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(
@@ -358,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)
@@ -449,6 +431,14 @@ def _enrich_event(event: WorkflowEvent, executor_context: Optional[BaseExecutorC
 
             if executor_context is not None:
                 metadata["is_new_server"] = executor_context.is_new_server
+
+                if executor_context.vembda_service_initiated_timestamp is not None and event.timestamp is not None:
+                    event_ts = event.timestamp
+                    if event_ts.tzinfo is None:
+                        event_ts = event_ts.replace(tzinfo=timezone.utc)
+                    event_ts_ns = int(event_ts.timestamp() * 1_000_000_000)
+                    initiated_latency = event_ts_ns - executor_context.vembda_service_initiated_timestamp
+                    metadata["initiated_latency"] = initiated_latency
         elif event.name == "workflow.execution.fulfilled" and is_deployment:
             metadata = {}
             memory_mb = get_memory_in_use_mb()

{vellum_workflow_server-1.9.0.post2 → vellum_workflow_server-1.9.8.post2}/src/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
 

{vellum_workflow_server-1.9.0.post2 → vellum_workflow_server-1.9.8.post2}/src/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
@@ -37,6 +37,10 @@ class BaseExecutorContext(UniversalBaseModel):
     feature_flags: Optional[dict[str, bool]] = None
     is_new_server: bool = False
     trigger_id: Optional[UUID] = None
+    # The actual 'execution id' of the workflow that we pass into the workflow
+    # when running in async mode.
+    workflow_span_id: Optional[UUID] = None
+    vembda_service_initiated_timestamp: Optional[int] = None
 
     @field_validator("inputs", mode="before")
     @classmethod
@@ -87,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):

{vellum_workflow_server-1.9.0.post2 → vellum_workflow_server-1.9.8.post2}/src/workflow_server/start.py

@@ -33,6 +33,7 @@ class CustomGunicornLogger(glogging.Logger):
         logger = logging.getLogger("gunicorn.access")
         logger.addFilter(HealthCheckFilter())
         logger.addFilter(SignalFilter())
+        logger.addFilter(StatusIsAvailableFilter())
 
 
 class HealthCheckFilter(logging.Filter):
@@ -45,6 +46,11 @@ class SignalFilter(logging.Filter):
         return "SIGTERM" not in record.getMessage()
 
 
+class StatusIsAvailableFilter(logging.Filter):
+    def filter(self, record: Any) -> bool:
+        return "/status/is_available" not in record.getMessage()
+
+
 def start() -> None:
     if not is_development():
         start_oom_killer_worker()

vellum_workflow_server-1.9.8.post2/src/workflow_server/utils/exit_handler.py

@@ -0,0 +1,56 @@
+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()
+    _wait_for_workers()
+
+
+def exit_handler(_signal: int, _frame: Any) -> None:
+    """
+    Gunicorn overrides this signal handler but theres periods where the gunicorn server
+    hasn't initialized or for local dev where this will get called.
+    """
+    process_killed_switch.set()
+    logger.warning("Received kill signal")
+    _wait_for_workers()
+    exit(1)
+
+
+def init_signal_handlers() -> None:
+    signal.signal(signal.SIGTERM, exit_handler)
+    signal.signal(signal.SIGINT, exit_handler)

vellum_workflow_server-1.9.0.post2/src/workflow_server/utils/exit_handler.py

@@ -1,27 +0,0 @@
-import logging
-import multiprocessing
-import signal
-from typing import Any
-
-logger = logging.getLogger(__name__)
-process_killed_switch = multiprocessing.Event()
-
-
-def gunicorn_exit_handler(_worker: Any) -> None:
-    process_killed_switch.set()
-    logger.warning("Received gunicorn kill signal")
-
-
-def exit_handler(_signal: int, _frame: Any) -> None:
-    """
-    Gunicorn overrides this signal handler but theres periods where the gunicorn server
-    hasn't initialized or for local dev where this will get called.
-    """
-    process_killed_switch.set()
-    logger.warning("Received kill signal")
-    exit(1)
-
-
-def init_signal_handlers() -> None:
-    signal.signal(signal.SIGTERM, exit_handler)
-    signal.signal(signal.SIGINT, exit_handler)