vellum-workflow-server 1.4.1.post2__tar.gz → 1.4.1.post3__tar.gz

{vellum_workflow_server-1.4.1.post2 → vellum_workflow_server-1.4.1.post3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-workflow-server
-Version: 1.4.1.post2
+Version: 1.4.1.post3
 Summary: 
 License: AGPL
 Requires-Python: >=3.9.0,<4

{vellum_workflow_server-1.4.1.post2 → vellum_workflow_server-1.4.1.post3}/pyproject.toml

@@ -3,7 +3,7 @@ name = "vellum-workflow-server"
 
 [tool.poetry]
 name = "vellum-workflow-server"
-version = "1.4.1.post2"
+version = "1.4.1.post3"
 description = ""
 readme = "README.md"
 authors = []

{vellum_workflow_server-1.4.1.post2 → vellum_workflow_server-1.4.1.post3}/src/workflow_server/api/tests/test_workflow_view_stream_workflow_route.py

@@ -373,7 +373,9 @@ from vellum.workflows.inputs import BaseInputs
     # THEN we get a 200 response
     assert status_code == 200, events
 
-    # THEN we get the expected events
+    # THEN we get the expected events: vembda initiated, workflow initiated, workflow rejected, vembda fulfilled
+    assert len(events) == 4
+
     assert events[0] == {
         "id": mock.ANY,
         "trace_id": mock.ANY,
@@ -389,7 +391,15 @@ from vellum.workflows.inputs import BaseInputs
         },
     }
 
-    assert events[1] == {
+    assert events[1]["name"] == "workflow.execution.initiated"
+
+    assert events[2]["name"] == "workflow.execution.rejected"
+    assert events[2]["span_id"] == events[1]["span_id"]
+    assert (
+        "Failed to initialize workflow: unexpected indent (inputs.py, line 3)" in events[2]["body"]["error"]["message"]
+    )
+
+    assert events[3] == {
         "id": mock.ANY,
         "trace_id": events[0]["trace_id"],
         "span_id": str(span_id),
@@ -400,15 +410,75 @@ from vellum.workflows.inputs import BaseInputs
         "name": "vembda.execution.fulfilled",
         "body": mock.ANY,
     }
-    assert events[1]["body"] == {
-        "exit_code": -1,
+    assert events[3]["body"] == {
+        "exit_code": 0,
         "log": "",
-        "stderr": "Failed to initialize workflow: unexpected indent (inputs.py, line 3)",
+        "stderr": "",
         "timed_out": False,
         "container_overhead_latency": mock.ANY,
     }
 
-    assert len(events) == 2
+
+def test_stream_workflow_route__invalid_inputs_initialization_events(both_stream_types):
+    """
+    Tests that invalid inputs initialization gets us back a workflow initiated and workflow rejected event.
+    """
+    # GIVEN a valid request body with valid inputs file but omitting required input to cause
+    # WorkflowInitializationException
+    span_id = uuid4()
+    request_body = {
+        "timeout": 360,
+        "execution_id": str(span_id),
+        "inputs": [
+            # Omit the required input to trigger WorkflowInitializationException
+        ],
+        "environment_api_key": "test",
+        "module": "workflow",
+        "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 call the stream route
+    status_code, events = both_stream_types(request_body)
+
+    # THEN we get a 200 response
+    assert status_code == 200, events
+
+    # THEN we get the expected events: vembda initiated, workflow initiated, workflow rejected, vembda fulfilled
+    assert len(events) == 4
+
+    # AND the first event should be vembda execution initiated
+    assert events[0]["name"] == "vembda.execution.initiated"
+    assert events[0]["span_id"] == str(span_id)
+
+    # AND the second event should be workflow execution initiated
+    assert events[1]["name"] == "workflow.execution.initiated"
+
+    # AND the third event should be workflow execution rejected
+    assert events[2]["name"] == "workflow.execution.rejected"
+    assert events[1]["span_id"] == events[2]["span_id"]
+    assert "Required input variables foo should have defined value" in events[2]["body"]["error"]["message"]
+
+    # AND the fourth event should be vembda execution fulfilled
+    assert events[3]["name"] == "vembda.execution.fulfilled"
+    assert events[3]["span_id"] == str(span_id)
+    assert events[3]["body"]["exit_code"] == 0
 
 
 @pytest.mark.parametrize(

{vellum_workflow_server-1.4.1.post2 → vellum_workflow_server-1.4.1.post3}/src/workflow_server/api/workflow_view.py

@@ -38,7 +38,6 @@ from workflow_server.core.events import (
 )
 from workflow_server.core.executor import stream_node_pebble_timeout, stream_workflow, stream_workflow_process_timeout
 from workflow_server.core.utils import (
-    create_vellum_client,
     create_vembda_rejected_event,
     is_events_emitting_enabled,
     serialize_vembda_rejected_event,
@@ -47,6 +46,7 @@ from workflow_server.core.workflow_executor_context import (
     DEFAULT_TIMEOUT_SECONDS,
     NodeExecutorContext,
     WorkflowExecutorContext,
+    create_vellum_client,
 )
 from workflow_server.utils.oom_killer import get_is_oom_killed
 from workflow_server.utils.system_utils import (
@@ -169,11 +169,6 @@ def stream_workflow_route() -> Response:
                 span_id_emitted = True
                 for event in workflow_iterator:
                     yield event
-            except WorkflowInitializationException as e:
-                if not span_id_emitted:
-                    yield f"{SPAN_ID_EVENT}:{uuid4()}"
-
-                yield serialize_vembda_rejected_event(context, str(e))
             except Exception as e:
                 if not span_id_emitted:
                     yield f"{SPAN_ID_EVENT}:{uuid4()}"

{vellum_workflow_server-1.4.1.post2 → vellum_workflow_server-1.4.1.post3}/src/workflow_server/code_exec_runner.py

@@ -6,7 +6,6 @@ from threading import Event as ThreadingEvent
 from uuid import uuid4
 from typing import Optional
 
-from vellum.workflows.exceptions import WorkflowInitializationException
 from workflow_server.api.workflow_view import get_workflow_request_context
 from workflow_server.core.events import VembdaExecutionInitiatedBody, VembdaExecutionInitiatedEvent
 from workflow_server.core.executor import stream_workflow
@@ -47,18 +46,14 @@ def run_code_exec_stream() -> None:
 
         print(f"{_EVENT_LINE}{initiated_event}")  # noqa: T201
 
-        try:
-            stream_iterator, span_id = stream_workflow(
-                context,
-                disable_redirect=True,
-                # Timeouts are handled at the code exec level right now so just passing in an unused threading event
-                timeout_signal=ThreadingEvent(),
-            )
-            for line in stream_iterator:
-                print(f"{_EVENT_LINE}{json.dumps(line)}")  # noqa: T201
-        except WorkflowInitializationException as e:
-            fulfilled_event = serialize_vembda_rejected_event(context, str(e))
-            print(f"{_EVENT_LINE}{fulfilled_event}")  # noqa: T201
+        stream_iterator, span_id = stream_workflow(
+            context,
+            disable_redirect=True,
+            # Timeouts are handled at the code exec level right now so just passing in an unused threading event
+            timeout_signal=ThreadingEvent(),
+        )
+        for line in stream_iterator:
+            print(f"{_EVENT_LINE}{json.dumps(line)}")  # noqa: T201
     except Exception as e:
         logger.exception(e)
 

{vellum_workflow_server-1.4.1.post2 → vellum_workflow_server-1.4.1.post3}/src/workflow_server/core/executor.py

@@ -20,10 +20,10 @@ from vellum_ee.workflows.display.utils.events import event_enricher
 from vellum_ee.workflows.display.workflows import BaseWorkflowDisplay
 from vellum_ee.workflows.server.virtual_file_loader import VirtualFileFinder
 
-from vellum import Vellum
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.emitters.base import BaseWorkflowEmitter
 from vellum.workflows.emitters.vellum_emitter import VellumEmitter
+from vellum.workflows.events.exception_handling import stream_initialization_exception
 from vellum.workflows.events.types import BaseEvent
 from vellum.workflows.events.workflow import WorkflowEventDisplayContext
 from vellum.workflows.exceptions import WorkflowInitializationException
@@ -44,7 +44,7 @@ from workflow_server.core.events import (
     VembdaExecutionFulfilledBody,
     VembdaExecutionFulfilledEvent,
 )
-from workflow_server.core.utils import create_vellum_client, is_events_emitting_enabled, serialize_vembda_rejected_event
+from workflow_server.core.utils import is_events_emitting_enabled, serialize_vembda_rejected_event
 from workflow_server.core.workflow_executor_context import (
     DEFAULT_TIMEOUT_SECONDS,
     BaseExecutorContext,
@@ -110,11 +110,6 @@ def _stream_workflow_wrapper(
         for event in stream_iterator:
             queue.put(json.dumps(event))
 
-    except WorkflowInitializationException as e:
-        if not span_id_emitted:
-            queue.put(f"{SPAN_ID_EVENT}:{uuid4()}")
-
-        queue.put(serialize_vembda_rejected_event(executor_context, str(e)))
     except Exception as e:
         if not span_id_emitted:
             queue.put(f"{SPAN_ID_EVENT}:{uuid4()}")
@@ -168,27 +163,28 @@ def stream_workflow(
     disable_redirect: bool = True,
     cancel_signal: Optional[ThreadingEvent] = None,
 ) -> tuple[Iterator[dict], UUID]:
-    workflow, namespace = _gather_workflow(executor_context)
-    workflow_inputs = _get_workflow_inputs(executor_context, workflow.__class__)
-    display_context = _gather_display_context(workflow, namespace)
-    workflow_state = (
-        workflow.deserialize_state(
-            executor_context.state,
-            workflow_inputs=workflow_inputs or BaseInputs(),
+    cancel_watcher_kill_switch = ThreadingEvent()
+    try:
+        workflow, namespace = _gather_workflow(executor_context)
+        workflow_inputs = _get_workflow_inputs(executor_context, workflow.__class__)
+
+        display_context = _gather_display_context(workflow, namespace)
+        workflow_state = (
+            workflow.deserialize_state(
+                executor_context.state,
+                workflow_inputs=workflow_inputs or BaseInputs(),
+            )
+            if executor_context.state
+            else None
+        )
+        run_from_node = _get_run_from_node(executor_context, workflow)
+        node_output_mocks = MockNodeExecution.validate_all(
+            executor_context.node_output_mocks,
+            workflow.__class__,
         )
-        if executor_context.state
-        else None
-    )
-    run_from_node = _get_run_from_node(executor_context, workflow)
-    node_output_mocks = MockNodeExecution.validate_all(
-        executor_context.node_output_mocks,
-        workflow.__class__,
-    )
 
-    cancel_watcher_kill_switch = ThreadingEvent()
-    cancel_signal = cancel_signal or ThreadingEvent()
+        cancel_signal = cancel_signal or ThreadingEvent()
 
-    try:
         stream = workflow.stream(
             inputs=workflow_inputs,
             state=workflow_state,
@@ -198,6 +194,26 @@ def stream_workflow(
             entrypoint_nodes=[run_from_node] if run_from_node else None,
             previous_execution_id=executor_context.previous_execution_id,
         )
+    except WorkflowInitializationException as e:
+        cancel_watcher_kill_switch.set()
+        initialization_exception_stream = stream_initialization_exception(e)
+
+        def _stream_generator() -> Generator[dict[str, Any], Any, None]:
+            for event in initialization_exception_stream:
+                yield _dump_event(
+                    event=event,
+                    executor_context=executor_context,
+                )
+
+        return (
+            _call_stream(
+                executor_context=executor_context,
+                stream_generator=_stream_generator,
+                disable_redirect=disable_redirect,
+                timeout_signal=timeout_signal,
+            ),
+            initialization_exception_stream.span_id,
+        )
     except Exception:
         cancel_watcher_kill_switch.set()
         logger.exception("Failed to generate Workflow Stream")
@@ -230,7 +246,6 @@ def stream_workflow(
                 yield _dump_event(
                     event=event,
                     executor_context=executor_context,
-                    client=workflow.context.vellum_client,
                 )
         except Exception as e:
             logger.exception("Failed to generate event from Workflow Stream")
@@ -377,18 +392,13 @@ def _create_workflow(executor_context: BaseExecutorContext, namespace: str) -> B
 
 
 def _create_workflow_context(executor_context: BaseExecutorContext) -> WorkflowContext:
-    vellum_client = create_vellum_client(
-        api_key=executor_context.environment_api_key,
-        api_version=executor_context.api_version,
-    )
-
     if executor_context.environment_variables:
         os.environ.update(executor_context.environment_variables)
 
     namespace = _get_file_namespace(executor_context)
 
     return WorkflowContext(
-        vellum_client=vellum_client,
+        vellum_client=executor_context.vellum_client,
         execution_context=executor_context.execution_context,
         generated_files=executor_context.files,
         namespace=namespace,
@@ -408,9 +418,11 @@ def _get_file_namespace(executor_context: BaseExecutorContext) -> str:
     )
 
 
-def _dump_event(event: BaseEvent, executor_context: BaseExecutorContext, client: Vellum) -> dict:
+def _dump_event(event: BaseEvent, executor_context: BaseExecutorContext) -> dict:
     module_base = executor_context.module.split(".")
-    dump = event.model_dump(mode="json", context={"event_enricher": lambda event: event_enricher(event, client)})
+    dump = event.model_dump(
+        mode="json", context={"event_enricher": lambda event: event_enricher(event, executor_context.vellum_client)}
+    )
     if dump["name"] in {
         "workflow.execution.initiated",
         "workflow.execution.fulfilled",

{vellum_workflow_server-1.4.1.post2 → vellum_workflow_server-1.4.1.post3}/src/workflow_server/core/utils.py

@@ -1,10 +1,7 @@
 from datetime import datetime
-import os
 from uuid import uuid4
 from typing import Optional
 
-from vellum import ApiVersionEnum, Vellum, VellumEnvironment
-from workflow_server.config import IS_VPC, VELLUM_API_URL_HOST, VELLUM_API_URL_PORT
 from workflow_server.core.events import VembdaExecutionFulfilledBody, VembdaExecutionFulfilledEvent
 from workflow_server.core.workflow_executor_context import BaseExecutorContext
 
@@ -51,42 +48,3 @@ def is_events_emitting_enabled(executor_context: Optional[BaseExecutorContext])
         return False
 
     return executor_context.feature_flags.get("vembda-event-emitting-enabled") or False
-
-
-def create_vellum_client(
-    api_key: str,
-    api_version: Optional[ApiVersionEnum] = None,
-) -> Vellum:
-    """
-    Create a VellumClient with proper environment configuration.
-
-    Args:
-        api_key: The API key for the Vellum client
-        api_version: Optional API version to use
-
-    Returns:
-        Configured Vellum client instance
-
-    Note: Ideally we replace this with `vellum.workflows.vellum_client.create_vellum_client`
-    """
-    if IS_VPC:
-        environment = VellumEnvironment(
-            default=os.getenv("VELLUM_DEFAULT_API_URL", VellumEnvironment.PRODUCTION.default),
-            documents=os.getenv("VELLUM_DOCUMENTS_API_URL", VellumEnvironment.PRODUCTION.documents),
-            predict=os.getenv("VELLUM_PREDICT_API_URL", VellumEnvironment.PRODUCTION.predict),
-        )
-    elif os.getenv("USE_LOCAL_VELLUM_API") == "true":
-        VELLUM_API_URL = f"http://{VELLUM_API_URL_HOST}:{VELLUM_API_URL_PORT}"
-        environment = VellumEnvironment(
-            default=VELLUM_API_URL,
-            documents=VELLUM_API_URL,
-            predict=VELLUM_API_URL,
-        )
-    else:
-        environment = VellumEnvironment.PRODUCTION
-
-    return Vellum(
-        api_key=api_key,
-        environment=environment,
-        api_version=api_version,
-    )

vellum_workflow_server-1.4.1.post3/src/workflow_server/core/workflow_executor_context.py

@@ -0,0 +1,99 @@
+from dataclasses import field
+import os
+from uuid import UUID
+from typing import Any, Optional
+
+from _pytest.compat import cached_property
+
+from vellum import ApiVersionEnum, Vellum, VellumEnvironment
+from vellum.client.core import UniversalBaseModel
+from vellum.workflows.context import ExecutionContext
+from workflow_server.config import IS_VPC, VELLUM_API_URL_HOST, VELLUM_API_URL_PORT
+
+DEFAULT_TIMEOUT_SECONDS = 60 * 30
+
+
+def create_vellum_client(
+    api_key: str,
+    api_version: Optional[ApiVersionEnum] = None,
+) -> Vellum:
+    """
+    Create a VellumClient with proper environment configuration.
+
+    Args:
+        api_key: The API key for the Vellum client
+        api_version: Optional API version to use
+
+    Returns:
+        Configured Vellum client instance
+
+    Note: Ideally we replace this with `vellum.workflows.vellum_client.create_vellum_client`
+    """
+    if IS_VPC:
+        environment = VellumEnvironment(
+            default=os.getenv("VELLUM_DEFAULT_API_URL", VellumEnvironment.PRODUCTION.default),
+            documents=os.getenv("VELLUM_DOCUMENTS_API_URL", VellumEnvironment.PRODUCTION.documents),
+            predict=os.getenv("VELLUM_PREDICT_API_URL", VellumEnvironment.PRODUCTION.predict),
+        )
+    elif os.getenv("USE_LOCAL_VELLUM_API") == "true":
+        VELLUM_API_URL = f"http://{VELLUM_API_URL_HOST}:{VELLUM_API_URL_PORT}"
+        environment = VellumEnvironment(
+            default=VELLUM_API_URL,
+            documents=VELLUM_API_URL,
+            predict=VELLUM_API_URL,
+        )
+    else:
+        environment = VellumEnvironment.PRODUCTION
+
+    return Vellum(
+        api_key=api_key,
+        environment=environment,
+        api_version=api_version,
+    )
+
+
+class BaseExecutorContext(UniversalBaseModel):
+    inputs: dict
+    state: Optional[dict] = None
+    timeout: int = DEFAULT_TIMEOUT_SECONDS
+    files: dict[str, str]
+    environment_api_key: str
+    api_version: Optional[ApiVersionEnum] = None
+    execution_id: UUID
+    module: str
+    execution_context: ExecutionContext = field(default_factory=ExecutionContext)
+    request_start_time: int
+    stream_start_time: int = 0
+    vembda_public_url: Optional[str] = None
+    node_output_mocks: Optional[list[Any]] = None
+    environment_variables: Optional[dict[str, str]] = None
+    previous_execution_id: Optional[UUID] = None
+    feature_flags: Optional[dict[str, bool]] = None
+
+    @property
+    def container_overhead_latency(self) -> int:
+        return self.stream_start_time - self.request_start_time if self.stream_start_time else -1
+
+    @property
+    def trace_id(self) -> UUID:
+        return self.execution_context.trace_id
+
+    @cached_property
+    def vellum_client(self) -> Vellum:
+        return create_vellum_client(
+            api_key=self.environment_api_key,
+            api_version=self.api_version,
+        )
+
+    def __hash__(self) -> int:
+        # do we think we need anything else for a unique hash for caching?
+        return hash(str(self.execution_id))
+
+
+class WorkflowExecutorContext(BaseExecutorContext):
+    node_id: Optional[UUID] = None  # Sent during run from node UX
+
+
+class NodeExecutorContext(BaseExecutorContext):
+    node_module: str
+    node_name: str

vellum_workflow_server-1.4.1.post2/src/workflow_server/core/workflow_executor_context.py

@@ -1,49 +0,0 @@
-from dataclasses import field
-from uuid import UUID
-from typing import Any, Optional
-
-from vellum.client.core import UniversalBaseModel
-from vellum.client.types.api_version_enum import ApiVersionEnum
-from vellum.workflows.context import ExecutionContext
-
-DEFAULT_TIMEOUT_SECONDS = 60 * 30
-
-
-class BaseExecutorContext(UniversalBaseModel):
-    inputs: dict
-    state: Optional[dict] = None
-    timeout: int = DEFAULT_TIMEOUT_SECONDS
-    files: dict[str, str]
-    environment_api_key: str
-    api_version: Optional[ApiVersionEnum] = None
-    execution_id: UUID
-    module: str
-    execution_context: ExecutionContext = field(default_factory=ExecutionContext)
-    request_start_time: int
-    stream_start_time: int = 0
-    vembda_public_url: Optional[str] = None
-    node_output_mocks: Optional[list[Any]] = None
-    environment_variables: Optional[dict[str, str]] = None
-    previous_execution_id: Optional[UUID] = None
-    feature_flags: Optional[dict[str, bool]] = None
-
-    @property
-    def container_overhead_latency(self) -> int:
-        return self.stream_start_time - self.request_start_time if self.stream_start_time else -1
-
-    @property
-    def trace_id(self) -> UUID:
-        return self.execution_context.trace_id
-
-    def __hash__(self) -> int:
-        # do we think we need anything else for a unique hash for caching?
-        return hash(str(self.execution_id))
-
-
-class WorkflowExecutorContext(BaseExecutorContext):
-    node_id: Optional[UUID] = None  # Sent during run from node UX
-
-
-class NodeExecutorContext(BaseExecutorContext):
-    node_module: str
-    node_name: str