vellum-workflow-server 0.14.68__tar.gz → 0.14.69__tar.gz

{vellum_workflow_server-0.14.68 → vellum_workflow_server-0.14.69}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-workflow-server
-Version: 0.14.68
+Version: 0.14.69
 Summary: 
 License: AGPL
 Requires-Python: >=3.9.0,<4
@@ -28,7 +28,7 @@ Requires-Dist: pebble (==5.0.7)
 Requires-Dist: pyjwt (==2.10.0)
 Requires-Dist: python-dotenv (==1.0.1)
 Requires-Dist: sentry-sdk[flask] (==2.20.0)
-Requires-Dist: vellum-ai (==0.14.68)
+Requires-Dist: vellum-ai (==0.14.69)
 Description-Content-Type: text/markdown
 
 # Vellum Workflow Runner Server

{vellum_workflow_server-0.14.68 → vellum_workflow_server-0.14.69}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vellum-workflow-server"
-version = "0.14.68"
+version = "0.14.69"
 description = ""
 readme = "README.md"
 authors = []
@@ -41,7 +41,7 @@ flask = "2.3.3"
 orderly-set = "5.2.2"
 pebble = "5.0.7"
 gunicorn = "23.0.0"
-vellum-ai = "0.14.68"
+vellum-ai = "0.14.69"
 python-dotenv = "1.0.1"
 sentry-sdk = {extras = ["flask"], version = "2.20.0"}
 

vellum_workflow_server-0.14.69/src/workflow_server/api/tests/test_workflow_view.py

@@ -0,0 +1,228 @@
+import logging
+import re
+from unittest.mock import patch
+from uuid import UUID
+
+from workflow_server.server import create_app
+
+
+def test_version_route():
+    flask_app = create_app()
+
+    with flask_app.test_client() as test_client:
+        response = test_client.get("/workflow/version")
+        assert response.status_code == 200
+        assert re.match(r"[0-9]*\.[0-9]*\.[0-9]*", response.json["sdk_version"])
+        assert response.json["server_version"] == "local"
+
+
+def test_version_route__with_single_node_file(tmp_path):
+    # GIVEN a temporary custom_nodes directory with a test node
+    custom_nodes_dir = tmp_path / "vellum_custom_nodes"
+    custom_nodes_dir.mkdir()
+
+    node_file = custom_nodes_dir / "test_node.py"
+    node_file.write_text(
+        """
+from vellum.workflows.nodes import BaseNode
+
+class TestNode(BaseNode):
+    \"""A test node for processing data.
+
+    This is a detailed description of what the node does.
+    \"""
+    label = "Test Node"
+"""
+    )
+
+    flask_app = create_app()
+
+    # WHEN we make a request to the version route
+    with patch("os.getcwd", return_value=str(tmp_path)), flask_app.test_client() as test_client:
+        response = test_client.get("/workflow/version")
+
+    # THEN we should get a successful response
+    assert response.status_code == 200
+
+    # AND we should find exactly one node
+    nodes = response.json["nodes"]
+    assert len(nodes) == 1
+
+    # AND the node should have the correct metadata
+    node = nodes[0]
+    assert UUID(node["id"])
+    assert node["module"] == "vellum_custom_nodes"
+    assert node["name"] == "TestNode"
+    assert node["label"] == "Test Node"
+    assert "A test node for processing data." in node["description"]
+    assert "This is a detailed description" in node["description"]
+
+
+def test_version_route__with_nodes_in_multiple_files(tmp_path):
+    # GIVEN a temporary custom_nodes directory
+    custom_nodes_dir = tmp_path / "vellum_custom_nodes"
+    custom_nodes_dir.mkdir()
+
+    # AND a first node file
+    first_node_file = custom_nodes_dir / "first_node.py"
+    first_node_file.write_text(
+        """
+from vellum.workflows.nodes import BaseNode
+
+class SomeNode(BaseNode):
+    \"""This is Some Node.\"""
+    label = "Some node"
+"""
+    )
+
+    # AND a second node file
+    second_node_file = custom_nodes_dir / "second_node.py"
+    second_node_file.write_text(
+        """
+from vellum.workflows.nodes import BaseNode
+
+class SomeOtherNode(BaseNode):
+    \"""This is Some Other Node.\"""
+    label = "Some other node"
+"""
+    )
+
+    flask_app = create_app()
+
+    # WHEN we make a request to the version route
+    with patch("os.getcwd", return_value=str(tmp_path)), flask_app.test_client() as test_client:
+        response = test_client.get("/workflow/version")
+
+    # THEN we should get a successful response
+    assert response.status_code == 200
+
+    # AND we should find both nodes
+    nodes = response.json["nodes"]
+    assert len(nodes) == 2
+
+    # AND the first node should have correct metadata
+    some_node = nodes[0]
+    assert some_node["label"] == "Some node"
+    assert some_node["description"] == "This is Some Node."
+    assert UUID(some_node["id"])
+    assert some_node["module"] == "vellum_custom_nodes"
+
+    # AND the second node should have correct metadata
+    some_other_node = nodes[1]
+    assert some_other_node["label"] == "Some other node"
+    assert some_other_node["description"] == "This is Some Other Node."
+    assert UUID(some_other_node["id"])
+    assert some_other_node["module"] == "vellum_custom_nodes"
+
+
+def test_version_route__no_custom_nodes_dir(tmp_path):
+    # GIVEN a Flask application and an empty temp directory
+    flask_app = create_app()
+
+    # WHEN we make a request to the version route
+    with patch("os.getcwd", return_value=str(tmp_path)), flask_app.test_client() as test_client:
+        response = test_client.get("/workflow/version")
+
+    # THEN we should get a successful response
+    assert response.status_code == 200
+
+    # AND the nodes list should be empty
+    assert response.json["nodes"] == []
+
+
+def test_version_route__with_multiple_nodes_in_file(tmp_path):
+    # Create a temporary custom_nodes directory with multiple nodes in one file
+    custom_nodes_dir = tmp_path / "vellum_custom_nodes"
+    custom_nodes_dir.mkdir()
+
+    # Create a test node file with multiple nodes
+    node_file = custom_nodes_dir / "multiple_nodes.py"
+    node_file.write_text(
+        """
+from vellum.workflows.nodes import BaseNode
+
+class ProcessingNode(BaseNode):
+    \"""Processes input data.\"""
+    label = "Processing Node"
+
+class TransformationNode(BaseNode):
+    \"""Transforms data format.\"""
+    label = "Transformation Node"
+
+# This class should not be discovered
+class HelperClass:
+    pass
+"""
+    )
+
+    flask_app = create_app()
+
+    # Mock the current working directory to point to our temp directory
+    with patch("os.getcwd", return_value=str(tmp_path)), flask_app.test_client() as test_client:
+        response = test_client.get("/workflow/version")
+
+        assert response.status_code == 200
+        nodes = response.json["nodes"]
+        assert len(nodes) == 2
+
+        # Nodes should be discovered regardless of their order in the file
+        node_names = {node["name"] for node in nodes}
+        assert node_names == {"ProcessingNode", "TransformationNode"}
+
+
+def test_version_route__with_invalid_node_file(tmp_path, caplog):
+    caplog.set_level(logging.WARNING)
+
+    # GIVEN a temporary custom_nodes directory
+    custom_nodes_dir = tmp_path / "vellum_custom_nodes"
+    custom_nodes_dir.mkdir()
+
+    # AND a valid node file
+    valid_node_file = custom_nodes_dir / "valid_node.py"
+    valid_node_file.write_text(
+        """
+from vellum.workflows.nodes import BaseNode
+
+class SomeNode(BaseNode):
+    \"\"\"This is Some Node.\"\"\"
+    label = "Some node"
+"""
+    )
+
+    # AND an invalid node file with syntax error of missing colon in the class
+    invalid_node_file = custom_nodes_dir / "invalid_node.py"
+    invalid_node_file.write_text(
+        """
+from vellum.workflows.nodes import BaseNode
+
+class BrokenNode(BaseNode)
+    \"\"\"This node has a syntax error.\"\"\"
+    label = "Broken Node"
+"""
+    )
+
+    flask_app = create_app()
+
+    # WHEN we make a request to the version route
+    with patch("os.getcwd", return_value=str(tmp_path)), flask_app.test_client() as test_client:
+        response = test_client.get("/workflow/version")
+
+    # THEN we should get a successful response
+    assert response.status_code == 200
+
+    # AND we should find only the valid node
+    nodes = response.json["nodes"]
+    assert len(nodes) == 1
+
+    # AND the valid node should have correct metadata
+    valid_node = nodes[0]
+    assert valid_node["label"] == "Some node"
+    assert valid_node["description"] == "This is Some Node."
+    assert UUID(valid_node["id"])
+    assert valid_node["module"] == "vellum_custom_nodes"
+
+    # AND the error should be logged with full traceback
+    assert len(caplog.records) > 0
+    error_message = caplog.records[0].message
+    assert "Failed to load node from module invalid_node" in error_message
+    assert "invalid_node.py, line 4" in error_message

{vellum_workflow_server-0.14.68 → vellum_workflow_server-0.14.69}/src/workflow_server/api/workflow_view.py

@@ -1,8 +1,13 @@
 from datetime import datetime
+import importlib
+import inspect
 import json
 import logging
 from multiprocessing import Queue, set_start_method
+import os
+import pkgutil
 from queue import Empty
+import sys
 import time
 import traceback
 from uuid import uuid4
@@ -11,6 +16,7 @@ from typing import Generator, Iterator, Union
 from flask import Blueprint, Response, current_app as app, request, stream_with_context
 from pydantic import ValidationError
 
+from vellum.workflows.nodes import BaseNode
 from workflow_server.config import MEMORY_LIMIT_MB
 from workflow_server.core.events import (
     STREAM_FINISHED_EVENT,
@@ -35,6 +41,8 @@ set_start_method("fork", force=True)
 
 logger = logging.getLogger(__name__)
 
+CUSTOM_NODES_DIRECTORY = "vellum_custom_nodes"
+
 
 @bp.route("/stream", methods=["POST"])
 def stream_workflow_route() -> Response:
@@ -322,6 +330,40 @@ def stream_node_route() -> Response:
 def get_version_route() -> tuple[dict, int]:
     resp = get_version()
 
+    try:
+        # Discover nodes in the container
+        nodes = []
+
+        # Look for custom_nodes directory in the container
+        custom_nodes_path = os.path.join(os.getcwd(), CUSTOM_NODES_DIRECTORY)
+        if os.path.exists(custom_nodes_path):
+            # Add the custom_nodes directory to Python path so we can import from it
+            sys.path.append(os.path.dirname(custom_nodes_path))
+
+            # Import all Python files in the custom_nodes directory
+            for _, name, _ in pkgutil.iter_modules([custom_nodes_path]):
+                try:
+                    module = importlib.import_module(f"{CUSTOM_NODES_DIRECTORY}.{name}")
+                    for _, obj in inspect.getmembers(module):
+                        # Look for classes that inherit from BaseNode
+                        if inspect.isclass(obj) and obj != BaseNode and issubclass(obj, BaseNode):
+                            nodes.append(
+                                {
+                                    "id": str(uuid4()),
+                                    "module": CUSTOM_NODES_DIRECTORY,
+                                    "name": obj.__name__,
+                                    "label": obj().label if hasattr(obj, "label") else obj.__name__,  # type: ignore
+                                    "description": inspect.getdoc(obj) or "",
+                                }
+                            )
+                except Exception as e:
+                    logger.warning(f"Failed to load node from module {name}: {str(e)}", exc_info=True)
+
+        resp["nodes"] = nodes
+    except Exception as e:
+        logger.exception(f"Failed to discover nodes: {str(e)}")
+        resp["nodes"] = []
+
     return resp, 200
 
 

vellum_workflow_server-0.14.68/src/workflow_server/api/tests/test_workflow_view.py

@@ -1,13 +0,0 @@
-import re
-
-from workflow_server.server import create_app
-
-
-def test_version_route():
-    flask_app = create_app()
-
-    with flask_app.test_client() as test_client:
-        response = test_client.get("/workflow/version")
-        assert response.status_code == 200
-        assert re.match(r"[0-9]*\.[0-9]*\.[0-9]*", response.json["sdk_version"])
-        assert response.json["server_version"] == "local"