vellum-workflow-server 1.11.21__py3-none-any.whl → 1.12.3__py3-none-any.whl

{vellum_workflow_server-1.11.21.dist-info → vellum_workflow_server-1.12.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-workflow-server
-Version: 1.11.21
+Version: 1.12.3
 Summary: 
 License: AGPL
 Requires-Python: >=3.9.0,<4
@@ -30,7 +30,7 @@ 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.21)
+Requires-Dist: vellum-ai (==1.12.3)
 Description-Content-Type: text/markdown
 
 # Vellum Workflow Runner Server

{vellum_workflow_server-1.11.21.dist-info → vellum_workflow_server-1.12.3.dist-info}/RECORD

@@ -7,16 +7,16 @@ workflow_server/api/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 workflow_server/api/tests/test_input_display_mapping.py,sha256=drBZqMudFyB5wgiUOcMgRXz7E7ge-Qgxbstw4E4f0zE,2211
 workflow_server/api/tests/test_workflow_view.py,sha256=I2sd11ptKDqbylzB9rKqkMXeZoh8ttad3zIhNus86vk,32491
 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=QilhiYv3_iaF-xvbmqUqqQqqVIZC4KgBe1u8Ku1q52s,42511
-workflow_server/api/workflow_view.py,sha256=1VSHGY0VXPnJQTz4XIX_sBiYFlTdByHH7RSAoOHBdtk,26650
+workflow_server/api/tests/test_workflow_view_stream_workflow_route.py,sha256=PLHU7rZUVZqToSEuo6uJI4PTLdmaR1qBYiv9k_86A4w,48140
+workflow_server/api/workflow_view.py,sha256=qPIN6iicMQVngy-Jr7dtOT3wqdFW2Bl3N_hbPdyTCAs,28177
 workflow_server/code_exec_runner.py,sha256=vJlCQ8FkcG8RfCZ34Ea2Xt6J7dNkU5EqA-KxRkbVOeo,2219
 workflow_server/config.py,sha256=I4hfTsjIbHxoSKylPCjKnrysPV0jO5nfRKwpKvEcfAE,2193
 workflow_server/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 workflow_server/core/cancel_workflow.py,sha256=uMPZg_rQ6iKZBLuxgwla1NYwhkcbO0gLh8QYBfU_2_0,2371
 workflow_server/core/events.py,sha256=24MA66DVQuaLJJcZrS8IL1Zq4Ohi9CoouKZ5VgoH3Cs,1402
-workflow_server/core/executor.py,sha256=7mJDuP8uedCAygNorp2Vscy6w7xHHqNZ_jxJXkJZzeY,17112
+workflow_server/core/executor.py,sha256=-FT4x05ijlnERY4BnghFAoF8sxx2yjQBrkrVf_anXHQ,17172
 workflow_server/core/utils.py,sha256=mecVPqQkthrC4mpop3r8J3IWnBmKbDgqfCrSagyzVEg,2021
-workflow_server/core/workflow_executor_context.py,sha256=8faOdpU4cBeIbmOvg9VzD3eS5i_PKcH7tyNGzx_rehg,3899
+workflow_server/core/workflow_executor_context.py,sha256=SXO5aVgO9rdsp7LSYJZkNIky-GvYwY3lJNBdgWK5KjE,3940
 workflow_server/logging_config.py,sha256=Hvx1t8uhqMMinl-5qcef7ufUvzs6x14VRnCb7YZxEAg,1206
 workflow_server/server.py,sha256=pBl0OQmrLE-PbTDwTgsVmxgz_Ai3TVhFRaMnr6PX6Yk,1849
 workflow_server/start.py,sha256=dvV8EKUH_oaTbOzNmUolF7RpkPWW8IkFwlgqOV9BhZQ,2842
@@ -29,9 +29,9 @@ workflow_server/utils/system_utils.py,sha256=3jNv113zRkKJ0928i2Vm6TqFHrDulteQu1k
 workflow_server/utils/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 workflow_server/utils/tests/test_sentry_integration.py,sha256=14PfuW8AaQNNtqLmBs16EPe5T3f_iTI7YJMCRtiboZk,4502
 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=dwUBP_0ngq6q-y2IFrjEWbGvao2roDR-VAekN6z57kE,5078
-vellum_workflow_server-1.11.21.dist-info/METADATA,sha256=WEJ5yhlrLvZjT0HHImwf0MlRjS6FwAUBTlghLEdbeWY,2277
-vellum_workflow_server-1.11.21.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_workflow_server-1.11.21.dist-info/entry_points.txt,sha256=uB_0yPkr7YV6RhEXzvFReUM8P4OQBlVXD6TN6eb9-oc,277
-vellum_workflow_server-1.11.21.dist-info/RECORD,,
+workflow_server/utils/tests/test_utils.py,sha256=8gbgZyzVdJteDbTdIbpiwJh6q4J2kQBcpkd9yjXnGEc,6882
+workflow_server/utils/utils.py,sha256=QeSDrM-AnniomRM4oqYWxhFkSqEKmGfzx_qpL-bfflU,5690
+vellum_workflow_server-1.12.3.dist-info/METADATA,sha256=KJ_bpPg8nN1vpJhQJlwC2dNYK9LZcRQhCJl7Mp4VrBc,2275
+vellum_workflow_server-1.12.3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_workflow_server-1.12.3.dist-info/entry_points.txt,sha256=uB_0yPkr7YV6RhEXzvFReUM8P4OQBlVXD6TN6eb9-oc,277
+vellum_workflow_server-1.12.3.dist-info/RECORD,,

workflow_server/api/tests/test_workflow_view_stream_workflow_route.py

@@ -1313,3 +1313,161 @@ 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"
+
+
+def test_stream_workflow_route__array_input_string_methods(both_stream_types):
+    """
+    Tests that array inputs of strings can have string methods called on them.
+
+    This is a regression test for APO-2423 where array inputs of strings were being
+    deserialized as VellumValue objects instead of plain strings, causing string
+    methods like .upper() to fail.
+    """
+
+    # GIVEN a workflow that takes an array of strings and calls .upper() on each item
+    span_id = uuid4()
+    request_body = {
+        "timeout": 360,
+        "execution_id": str(span_id),
+        "inputs": [
+            {
+                "name": "items",
+                "type": "ARRAY",
+                "value": [
+                    {"type": "STRING", "value": "hello"},
+                    {"type": "STRING", "value": "world"},
+                ],
+            },
+        ],
+        "environment_api_key": "test",
+        "module": "workflow",
+        "files": {
+            "__init__.py": "",
+            "workflow.py": """\
+from typing import List
+
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs import BaseInputs
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.state import BaseState
+
+
+class Inputs(BaseInputs):
+    items: List[str]
+
+
+class UppercaseNode(BaseNode):
+    items = Inputs.items
+
+    class Outputs(BaseNode.Outputs):
+        result: List[str]
+
+    def run(self) -> Outputs:
+        # This should work if items is a list of strings
+        # but will fail if items is a list of VellumValue objects
+        uppercased = [item.upper() for item in self.items]
+        return self.Outputs(result=uppercased)
+
+
+class Workflow(BaseWorkflow[Inputs, BaseState]):
+    graph = UppercaseNode
+
+    class Outputs(BaseWorkflow.Outputs):
+        result = UppercaseNode.Outputs.result
+""",
+        },
+    }
+
+    # 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
+
+    # AND we should get the expected events without errors
+    event_names = [e["name"] for e in events]
+    assert "vembda.execution.initiated" in event_names
+    assert "workflow.execution.initiated" in event_names
+    assert "workflow.execution.fulfilled" in event_names
+
+    # AND the workflow should NOT be rejected
+    assert "workflow.execution.rejected" not in event_names, (
+        f"Workflow was rejected when it should have succeeded. " f"Events: {events}"
+    )
+
+    # AND the output should be the uppercased strings
+    fulfilled_event = next(e for e in events if e["name"] == "workflow.execution.fulfilled")
+    assert fulfilled_event["body"]["outputs"]["result"] == ["HELLO", "WORLD"]

workflow_server/api/workflow_view.py

@@ -22,6 +22,7 @@ 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,
@@ -142,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": {
@@ -151,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})
@@ -218,6 +224,38 @@ def _emit_async_error_events(
         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()

workflow_server/core/executor.py

@@ -194,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()

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

workflow_server/utils/tests/test_utils.py

@@ -5,7 +5,6 @@ from vellum import (
     FunctionCall,
     SearchResult,
     SearchResultDocument,
-    StringVellumValue,
     VellumAudio,
     VellumDocument,
     VellumError,
@@ -104,7 +103,7 @@ from workflow_server.utils.utils import (
         ),
         (
             {"type": "ARRAY", "name": "array", "value": [{"type": "STRING", "value": "<example-string-value>"}]},
-            {"array": [StringVellumValue(value="<example-string-value>")]},
+            {"array": ["<example-string-value>"]},
         ),
         (
             {"type": "NUMBER", "name": "123", "value": 123},

workflow_server/utils/utils.py

@@ -6,6 +6,7 @@ from typing import Any, List
 
 from vellum import (
     ArrayInput,
+    ArrayVellumValue,
     ChatHistoryInput,
     ErrorInput,
     FunctionCallInput,
@@ -13,11 +14,26 @@ from vellum import (
     VellumAudio,
     VellumDocument,
     VellumImage,
+    VellumValue,
     VellumVideo,
 )
 from workflow_server.config import CONTAINER_IMAGE, is_development
 
 
+def unwrap_vellum_value(item: VellumValue) -> Any:
+    """Recursively unwrap VellumValue objects to their primitive values.
+
+    This is needed because ArrayInput.value returns List[VellumValue] objects,
+    but workflows expect primitive Python values (str, int, etc.).
+    """
+    if isinstance(item, ArrayVellumValue):
+        if item.value is None:
+            return None
+        return [unwrap_vellum_value(nested_item) for nested_item in item.value]
+    else:
+        return item.value
+
+
 def convert_json_inputs_to_vellum(inputs: List[dict]) -> dict:
     vellum_inputs: dict[str, Any] = {}
 
@@ -41,7 +57,8 @@ def convert_json_inputs_to_vellum(inputs: List[dict]) -> dict:
         elif type == "ERROR":
             vellum_inputs[name] = ErrorInput.model_validate(input).value
         elif type == "ARRAY":
-            vellum_inputs[name] = ArrayInput.model_validate(input).value
+            array_value = ArrayInput.model_validate(input).value
+            vellum_inputs[name] = [unwrap_vellum_value(item) for item in array_value]
         # Once we export *Input classes for these two cases, we can add the union to the WorkflowExecutorContext
         # model and simplify this method to just a {to_python_safe_snake_case(input.name): input.value} mapping
         elif type == "IMAGE":