vellum-workflow-server 0.14.67__py3-none-any.whl → 0.14.68.post1__py3-none-any.whl

{vellum_workflow_server-0.14.67.dist-info → vellum_workflow_server-0.14.68.post1.dist-info}/METADATA

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

{vellum_workflow_server-0.14.67.dist-info → vellum_workflow_server-0.14.68.post1.dist-info}/RECORD

@@ -3,9 +3,9 @@ workflow_server/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 workflow_server/api/auth_middleware.py,sha256=IlZaCiwZ5nwQqk5sYQorvOFj7lt0p1ZSSEqUxfiFaW0,2458
 workflow_server/api/healthz_view.py,sha256=itiRvBDBXncrw8Kbbc73UZLwqMAhgHOR3uSre_dAfgY,404
 workflow_server/api/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-workflow_server/api/tests/test_workflow_view.py,sha256=dSAeIAeZZGtPA2bN1njuoTTYenqi7ZY-poOpEy1LcZ8,402
+workflow_server/api/tests/test_workflow_view.py,sha256=wlVFBmKcoI-RdzfGPioeW46k6zaXyUeIerPc6m4aQls,7150
 workflow_server/api/tests/test_workflow_view_stream_workflow_route.py,sha256=wWW4sukIUmHnL525MLSAB2E5P6CeASnhsCoKQXEgPcI,21297
-workflow_server/api/workflow_view.py,sha256=6i8O2p6WYAy0DUv-gqyoY-6gIGWGLhmTmfyryJPkr08,12387
+workflow_server/api/workflow_view.py,sha256=duiMnAZ7PRpoPz63s9z37pxUxGR-9yAi3qxG9APXCao,14244
 workflow_server/code_exec_runner.py,sha256=tfijklTVkX4y45jeFTfrY2hVhdwo0VrLFc3SMeIiVYs,3096
 workflow_server/config.py,sha256=Jk1kmncI7g2LTIujssIpncD_eQoIowL_5oARQ6XpkJ0,1281
 workflow_server/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -23,7 +23,7 @@ workflow_server/utils/sentry.py,sha256=Pr3xKvHdk0XFSpXgy-55bWI4J3bbf_36gjDyLOs7o
 workflow_server/utils/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 workflow_server/utils/tests/test_utils.py,sha256=MKGY4F_jnRdwqyQ8Krhlk7MpMEPql5MDATcwBaxpIEA,4786
 workflow_server/utils/utils.py,sha256=dpFeUQW7cmiH2-aLsO65jAa4RubfvptWNkW1ZkvDlmE,3710
-vellum_workflow_server-0.14.67.dist-info/METADATA,sha256=LMdZ-Nk9tl4FWMIBeBvyEJY7ZHW5h0-QRl6f70mebHE,2237
-vellum_workflow_server-0.14.67.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_workflow_server-0.14.67.dist-info/entry_points.txt,sha256=uB_0yPkr7YV6RhEXzvFReUM8P4OQBlVXD6TN6eb9-oc,277
-vellum_workflow_server-0.14.67.dist-info/RECORD,,
+vellum_workflow_server-0.14.68.post1.dist-info/METADATA,sha256=8nKE924gHjUlK3hYNOR_AXBVsVOH_QG9Sip7B3WFR_0,2243
+vellum_workflow_server-0.14.68.post1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_workflow_server-0.14.68.post1.dist-info/entry_points.txt,sha256=uB_0yPkr7YV6RhEXzvFReUM8P4OQBlVXD6TN6eb9-oc,277
+vellum_workflow_server-0.14.68.post1.dist-info/RECORD,,

workflow_server/api/tests/test_workflow_view.py

@@ -1,4 +1,7 @@
+import logging
 import re
+from unittest.mock import patch
+from uuid import UUID
 
 from workflow_server.server import create_app
 
@@ -11,3 +14,215 @@ def test_version_route():
         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

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