vellum-workflow-server 1.11.0.post1__tar.gz → 1.12.0.post1__tar.gz

{vellum_workflow_server-1.11.0.post1 → vellum_workflow_server-1.12.0.post1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-workflow-server
-Version: 1.11.0.post1
+Version: 1.12.0.post1
 Summary: 
 License: AGPL
 Requires-Python: >=3.9.0,<4
@@ -30,13 +30,15 @@ Requires-Dist: pyjwt (==2.10.0)
 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.11.0)
+Requires-Dist: vellum-ai (==1.12.0)
 Description-Content-Type: text/markdown
 
 # Vellum Workflow Runner Server
+
 This package is meant for installing on container images in order to use custom docker images when using Vellum Workflows.
 
 ## Example Dockerfile Usage:
+
 ```
 FROM python:3.11.6-slim-bookworm
 
@@ -49,7 +51,6 @@ RUN pip install --upgrade pip
 RUN pip --no-cache-dir install vellum-workflow-server==0.13.2
 
 ENV PYTHONUNBUFFERED 1
-ENV PYTHONDONTWRITEBYTECODE 1
 COPY ./base-image/code_exec_entrypoint.sh .
 RUN chmod +x /code_exec_entrypoint.sh
 
@@ -57,5 +58,6 @@ CMD ["vellum_start_server"]
 ```
 
 ## Skipping Publishes
+
 If you wish to automatically skip publishing a new version when merging to main you can add a [skip-publish] to your commit message. This is useful if your changes are not time sensitive and can just go out with the next release. This avoids causing new services being created causing extra cold starts for our customers and also keeps our public versioning more tidy.
 

{vellum_workflow_server-1.11.0.post1 → vellum_workflow_server-1.12.0.post1}/README.md

@@ -1,7 +1,9 @@
 # Vellum Workflow Runner Server
+
 This package is meant for installing on container images in order to use custom docker images when using Vellum Workflows.
 
 ## Example Dockerfile Usage:
+
 ```
 FROM python:3.11.6-slim-bookworm
 
@@ -14,7 +16,6 @@ RUN pip install --upgrade pip
 RUN pip --no-cache-dir install vellum-workflow-server==0.13.2
 
 ENV PYTHONUNBUFFERED 1
-ENV PYTHONDONTWRITEBYTECODE 1
 COPY ./base-image/code_exec_entrypoint.sh .
 RUN chmod +x /code_exec_entrypoint.sh
 
@@ -22,4 +23,5 @@ CMD ["vellum_start_server"]
 ```
 
 ## Skipping Publishes
+
 If you wish to automatically skip publishing a new version when merging to main you can add a [skip-publish] to your commit message. This is useful if your changes are not time sensitive and can just go out with the next release. This avoids causing new services being created causing extra cold starts for our customers and also keeps our public versioning more tidy.

{vellum_workflow_server-1.11.0.post1 → vellum_workflow_server-1.12.0.post1}/pyproject.toml

@@ -3,7 +3,7 @@ name = "vellum-workflow-server"
 
 [tool.poetry]
 name = "vellum-workflow-server"
-version = "1.11.0.post1"
+version = "1.12.0.post1"
 description = ""
 readme = "README.md"
 authors = []
@@ -46,7 +46,7 @@ orderly-set = "5.2.2"
 pebble = "5.0.7"
 gunicorn = "23.0.0"
 orjson = "3.11.4"
-vellum-ai = "1.11.0"
+vellum-ai = "1.12.0"
 python-dotenv = "1.2.1"
 retrying = "1.3.4"
 sentry-sdk = {extras = ["flask"], version = "2.20.0"}

{vellum_workflow_server-1.11.0.post1 → vellum_workflow_server-1.12.0.post1}/src/workflow_server/api/tests/test_workflow_view.py

@@ -389,7 +389,15 @@ class MyAdditionNode(BaseNode):
         },
         "id": "2464b610-fb6d-495b-b17c-933ee147f19f",
         "label": "My Addition Node",
-        "outputs": [{"id": "f39d85c9-e7bf-45e1-bb67-f16225db0118", "name": "result", "type": "NUMBER", "value": None}],
+        "outputs": [
+            {
+                "id": "f39d85c9-e7bf-45e1-bb67-f16225db0118",
+                "name": "result",
+                "type": "NUMBER",
+                "value": None,
+                "schema": {"type": "integer"},
+            }
+        ],
         "ports": [{"id": "bc489295-cd8a-4aa2-88bb-34446374100d", "name": "default", "type": "DEFAULT"}],
         "trigger": {"id": "ff580cad-73d6-44fe-8f2c-4b8dc990ee70", "merge_behavior": "AWAIT_ATTRIBUTES"},
         "type": "GENERIC",

{vellum_workflow_server-1.11.0.post1 → vellum_workflow_server-1.12.0.post1}/src/workflow_server/api/tests/test_workflow_view_stream_workflow_route.py

@@ -549,7 +549,10 @@ class Inputs(BaseInputs):
     # 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"]
-    assert "Required input variables foo should have defined value" in events[2]["body"]["error"]["message"]
+    actual_error_message = events[2]["body"]["error"]["message"]
+    assert "Required input variables" in actual_error_message
+    assert "foo" in actual_error_message
+    assert "should have defined value" in actual_error_message
 
     # AND the fourth event should be vembda execution fulfilled
     assert events[3]["name"] == "vembda.execution.fulfilled"
@@ -1310,3 +1313,76 @@ class OOMWorkflow(BaseWorkflow):
     assert (
         vembda_fulfilled_event["body"].get("timed_out") is not True
     ), "timed_out flag should not be set when OOM occurs"
+
+
+@mock.patch("workflow_server.api.workflow_view.ENABLE_PROCESS_WRAPPER", False)
+def test_stream_workflow_route__client_disconnect_emits_rejected_event():
+    """
+    Tests that when a client disconnects mid-stream (GeneratorExit), we emit a workflow execution
+    rejected event to the events.create API.
+    """
+    # GIVEN a valid request body for a workflow that yields multiple events
+    span_id = uuid4()
+    trace_id = uuid4()
+    request_body = {
+        "timeout": 360,
+        "execution_id": str(span_id),
+        "execution_context": {
+            "trace_id": str(trace_id),
+        },
+        "inputs": [],
+        "environment_api_key": "test",
+        "module": "workflow",
+        "files": {
+            "__init__.py": "",
+            "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+
+class Workflow(BaseWorkflow):
+    class Outputs(BaseWorkflow.Outputs):
+        foo = "hello"
+""",
+        },
+    }
+
+    # AND a mock to capture events.create calls
+    events_create_calls = []
+
+    def mock_events_create(request):
+        events_create_calls.append(request)
+
+    # WHEN we call the stream route and simulate a client disconnect
+    flask_app = create_app()
+    with flask_app.test_client() as test_client:
+        with mock.patch("workflow_server.core.workflow_executor_context.create_vellum_client") as mock_create_client:
+            mock_client = mock.MagicMock()
+            mock_client.events.create = mock_events_create
+            mock_create_client.return_value = mock_client
+
+            response = test_client.post("/workflow/stream", json=request_body)
+
+            # Get the response iterator and consume a few chunks to start the stream
+            response_iter = response.response
+            next(response_iter)
+
+            # Close the response to trigger GeneratorExit
+            response_iter.close()
+
+    # THEN the events.create API should have been called with rejected event
+    assert len(events_create_calls) > 0, "events.create should have been called on client disconnect"
+
+    # AND the call should include a workflow.execution.rejected event (sent as SDK event model)
+    last_call = events_create_calls[-1]
+    assert isinstance(last_call, list), "events.create should be called with a list"
+    assert len(last_call) == 1, "Should have exactly one rejected event"
+
+    rejected_event = last_call[0]
+    assert rejected_event.name == "workflow.execution.rejected", "Should be a rejected event"
+
+    # AND the rejected event should have the correct error message
+    assert "client disconnected" in rejected_event.body.error.message.lower()
+
+    # AND the rejected event should have a workflow_definition
+    # TODO: In the future, we should capture the real workflow_definition from the initiated event.
+    # For now, we use BaseWorkflow as a placeholder.
+    assert rejected_event.body.workflow_definition is not None, "Should have a workflow_definition"

{vellum_workflow_server-1.11.0.post1 → vellum_workflow_server-1.12.0.post1}/src/workflow_server/api/workflow_view.py

@@ -22,6 +22,14 @@ from vellum_ee.workflows.display.types import WorkflowDisplayContext
 from vellum_ee.workflows.display.workflows import BaseWorkflowDisplay
 from vellum_ee.workflows.server.virtual_file_loader import VirtualFileFinder
 
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.errors import WorkflowError, WorkflowErrorCode
+from vellum.workflows.events.workflow import (
+    WorkflowExecutionInitiatedBody,
+    WorkflowExecutionInitiatedEvent,
+    WorkflowExecutionRejectedBody,
+    WorkflowExecutionRejectedEvent,
+)
 from vellum.workflows.exceptions import WorkflowInitializationException
 from vellum.workflows.nodes import BaseNode
 from vellum.workflows.vellum_client import create_vellum_client
@@ -135,7 +143,7 @@ def stream_workflow_route() -> Response:
             # 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(
+            app.logger.warning(
                 "Client disconnected in the middle of the Workflow Stream",
                 extra={
                     "sentry_tags": {
@@ -144,6 +152,11 @@ def stream_workflow_route() -> Response:
                     }
                 },
             )
+            _emit_client_disconnect_events(
+                context,
+                span_id,
+                "Client disconnected in the middle of the Workflow Stream",
+            )
             return
         except Exception as e:
             logger.exception("Error during workflow response stream generator", extra={"error": e})
@@ -174,6 +187,75 @@ def stream_workflow_route() -> Response:
     return resp
 
 
+def _emit_async_error_events(
+    context: WorkflowExecutorContext, error_message: str, stacktrace: Optional[str] = None
+) -> None:
+    """
+    Emit workflow execution error events when async execution fails before or during workflow startup.
+
+    This ensures that errors in async mode are properly reported to Vellum's events API,
+    making them visible in the executions UI.
+    """
+    try:
+        workflow_span_id = context.workflow_span_id or str(uuid4())
+
+        initiated_event = WorkflowExecutionInitiatedEvent[Any, Any](
+            trace_id=context.trace_id,
+            span_id=workflow_span_id,
+            body=WorkflowExecutionInitiatedBody(inputs=context.inputs),
+            parent=context.execution_context.parent_context if context.execution_context else None,
+        )
+
+        rejected_event = WorkflowExecutionRejectedEvent(
+            trace_id=context.trace_id,
+            span_id=workflow_span_id,
+            body=WorkflowExecutionRejectedBody(
+                error=WorkflowError(
+                    message=error_message,
+                    code=WorkflowErrorCode.INTERNAL_ERROR,
+                ),
+                stacktrace=stacktrace,
+            ),
+            parent=context.execution_context.parent_context if context.execution_context else None,
+        )
+
+        context.vellum_client.events.create(request=[initiated_event, rejected_event])  # type: ignore[list-item]
+    except Exception as e:
+        logger.exception(f"Failed to emit async error events: {e}")
+
+
+def _emit_client_disconnect_events(
+    context: WorkflowExecutorContext,
+    workflow_span_id: str,
+    error_message: str,
+) -> None:
+    """
+    Emit workflow execution rejected event when a client disconnects mid-stream.
+
+    Since the workflow has already started streaming (the initiated event was already emitted),
+    we only need to emit the rejected event to properly close out the execution.
+    """
+    try:
+        # TODO: In the future, we should capture the real workflow_definition from the initiated event
+        # For now, we use BaseWorkflow as a placeholder
+        rejected_event = WorkflowExecutionRejectedEvent(
+            trace_id=context.trace_id,
+            span_id=workflow_span_id,
+            body=WorkflowExecutionRejectedBody(
+                workflow_definition=BaseWorkflow,
+                error=WorkflowError(
+                    message=error_message,
+                    code=WorkflowErrorCode.WORKFLOW_CANCELLED,
+                ),
+            ),
+            parent=context.execution_context.parent_context if context.execution_context else None,
+        )
+
+        context.vellum_client.events.create(request=[rejected_event])  # type: ignore[list-item]
+    except Exception as e:
+        logger.exception(f"Failed to emit client disconnect events: {e}")
+
+
 @bp.route("/async-exec", methods=["POST"])
 def async_exec_workflow() -> Response:
     data = request.get_json()
@@ -208,8 +290,8 @@ def async_exec_workflow() -> Response:
         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
+                error_detail = start_workflow_result.get_json().get("detail", "Unknown error during workflow startup")
+                _emit_async_error_events(context, error_detail)
                 return
 
             workflow_events, vembda_initiated_event, process, span_id, headers = start_workflow_result
@@ -223,6 +305,7 @@ def async_exec_workflow() -> Response:
             )
         except Exception as e:
             logger.exception("Error during workflow async background worker", e)
+            _emit_async_error_events(context, str(e), traceback.format_exc())
         finally:
             if ENABLE_PROCESS_WRAPPER:
                 try:
@@ -531,11 +614,18 @@ def serialize_route() -> Response:
     is_new_server = data.get("is_new_server", False)
     module = data.get("module")
 
+    headers = {
+        "X-Vellum-Is-New-Server": str(is_new_server).lower(),
+    }
+
     if not files:
+        error_message = "No files received"
+        logger.warning(error_message)
         return Response(
-            json.dumps({"detail": "No files received"}),
+            json.dumps({"detail": error_message}),
             status=400,
             content_type="application/json",
+            headers=headers,
         )
 
     client = create_vellum_client(api_key=workspace_api_key)
@@ -544,10 +634,6 @@ def serialize_route() -> Response:
     namespace = get_random_namespace()
     virtual_finder = VirtualFileFinder(files, namespace, source_module=module)
 
-    headers = {
-        "X-Vellum-Is-New-Server": str(is_new_server).lower(),
-    }
-
     try:
         sys.meta_path.append(virtual_finder)
         result = BaseWorkflowDisplay.serialize_module(namespace, client=client, dry_run=True)

{vellum_workflow_server-1.11.0.post1 → vellum_workflow_server-1.12.0.post1}/src/workflow_server/core/cancel_workflow.py

@@ -14,14 +14,18 @@ logger = logging.getLogger(__name__)
 
 
 def get_is_workflow_cancelled(execution_id: UUID, vembda_public_url: Optional[str]) -> bool:
-    response = requests.get(
-        f"{vembda_public_url}/vembda-public/cancel-workflow-execution-status/{execution_id}",
-        headers={"Accept": "application/json"},
-        timeout=5,
-    )
-    response.raise_for_status()
+    try:
+        response = requests.get(
+            f"{vembda_public_url}/vembda-public/cancel-workflow-execution-status/{execution_id}",
+            headers={"Accept": "application/json"},
+            timeout=5,
+        )
+        response.raise_for_status()
 
-    return response.json().get("cancelled")
+        return response.json().get("cancelled", False)
+    except Exception:
+        logger.exception("Error checking workflow cancellation status")
+        return False
 
 
 class CancelWorkflowWatcherThread(Thread):

{vellum_workflow_server-1.11.0.post1 → vellum_workflow_server-1.12.0.post1}/src/workflow_server/core/executor.py

@@ -14,6 +14,7 @@ from typing import Any, Callable, Generator, Iterator, Optional, Tuple
 
 import orjson
 from vellum_ee.workflows.display.utils.events import event_enricher
+from vellum_ee.workflows.display.utils.expressions import base_descriptor_validator
 from vellum_ee.workflows.server.virtual_file_loader import VirtualFileFinder
 
 from vellum.workflows import BaseWorkflow
@@ -177,6 +178,7 @@ def stream_workflow(
         node_output_mocks = MockNodeExecution.validate_all(
             executor_context.node_output_mocks,
             workflow.__class__,
+            descriptor_validator=base_descriptor_validator,
         )
 
         cancel_signal = cancel_signal or ThreadingEvent()
@@ -192,6 +194,7 @@ def stream_workflow(
             timeout=executor_context.timeout,
             trigger=trigger,
             execution_id=executor_context.workflow_span_id,
+            event_max_size=executor_context.event_max_size,
         )
     except WorkflowInitializationException as e:
         cancel_watcher_kill_switch.set()

{vellum_workflow_server-1.11.0.post1 → vellum_workflow_server-1.12.0.post1}/src/workflow_server/core/workflow_executor_context.py

@@ -41,6 +41,7 @@ class BaseExecutorContext(UniversalBaseModel):
     # when running in async mode.
     workflow_span_id: Optional[UUID] = None
     vembda_service_initiated_timestamp: Optional[int] = None
+    event_max_size: Optional[int] = None
 
     @field_validator("inputs", mode="before")
     @classmethod

{vellum_workflow_server-1.11.0.post1 → vellum_workflow_server-1.12.0.post1}/src/workflow_server/utils/utils.py

@@ -59,10 +59,19 @@ def convert_json_inputs_to_vellum(inputs: List[dict]) -> dict:
 
 
 def get_version() -> dict:
+    # Return hotswappable lock file so we can save it and reuse it
+    lock_file = None
+    try:
+        with open("/app/uv.lock", "r") as f:
+            lock_file = f.read()
+    except Exception:
+        pass
+
     return {
         "sdk_version": version("vellum-ai"),
         "server_version": "local" if is_development() else version("vellum-workflow-server"),
         "container_image": CONTAINER_IMAGE,
+        "lock_file": lock_file,
     }