vellum-workflow-server 0.14.69__tar.gz → 0.14.70.post1__tar.gz

{vellum_workflow_server-0.14.69 → vellum_workflow_server-0.14.70.post1}/PKG-INFO

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

{vellum_workflow_server-0.14.69 → vellum_workflow_server-0.14.70.post1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vellum-workflow-server"
-version = "0.14.69"
+version = "0.14.70.post1"
 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.69"
+vellum-ai = "0.14.70"
 python-dotenv = "1.0.1"
 sentry-sdk = {extras = ["flask"], version = "2.20.0"}
 

vellum_workflow_server-0.14.70.post1/src/workflow_server/api/tests/test_input_display_mapping.py

@@ -0,0 +1,61 @@
+from uuid import uuid4
+
+from workflow_server.server import create_app
+
+
+def test_input_conversion_with_display_mapping():
+    """
+    Test that validates input conversion behavior for future WorkflowDisplay refactor.
+
+    This test demonstrates the expected behavior when inputs are converted from UI names
+    to SDK attribute names using WorkflowDisplay's inputs_display mapping, rather than
+    the current snake_case conversion approach.
+
+    The test passes on main branch by using the current conversion logic, but establishes
+    the expected input/output patterns for the future refactor.
+    """
+    span_id = uuid4()
+    request_body = {
+        "execution_id": str(span_id),
+        "inputs": [
+            {"name": "User Message", "type": "STRING", "value": "Hello world"},
+            {"name": "123-config", "type": "STRING", "value": "config-value"},
+            {"name": "API-Key", "type": "STRING", "value": "test-key"},
+        ],
+        "environment_api_key": "test",
+        "module": "workflow",
+        "timeout": 360,
+        "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):
+        result = "success"
+""",
+            "inputs.py": """
+from vellum.workflows.inputs import BaseInputs
+
+class Inputs(BaseInputs):
+    user_message: str
+    input_123_config: str
+    api_key: str
+""",
+        },
+    }
+
+    flask_app = create_app()
+    with flask_app.test_client() as test_client:
+        response = test_client.post("/workflow/stream", json=request_body)
+        status_code = response.status_code
+
+    assert status_code == 200, f"Request failed with status {status_code}: {response.data}"
+
+    response_lines = [line for line in response.data.decode().split("\n") if line and line not in ["WAITING", "END"]]
+    assert len(response_lines) > 0, "No response events received"
+
+    fulfilled_events = [line for line in response_lines if "workflow.execution.fulfilled" in line]
+    assert len(fulfilled_events) > 0, "No workflow.execution.fulfilled event received"

{vellum_workflow_server-0.14.69 → vellum_workflow_server-0.14.70.post1}/src/workflow_server/api/tests/test_workflow_view_stream_workflow_route.py

@@ -743,3 +743,44 @@ class EndNodeDisplay(BaseNodeDisplay[EndNode]):
     assert len(events) > 3, json.dumps(events[-1])
     assert events[2]["name"] == "node.execution.initiated", json.dumps(events[-1])
     assert events[2]["body"]["inputs"] == {"fruit": "cherry"}
+
+
+def test_stream_workflow_route__with_environment_variables(both_stream_types):
+    # GIVEN a valid request body with environment variables
+    span_id = uuid4()
+    request_body = {
+        "execution_id": str(span_id),
+        "inputs": [],
+        "environment_api_key": "test",
+        "module": "workflow",
+        "timeout": 360,
+        "environment_variables": {"TEST_ENV_VAR": "test_value", "ANOTHER_VAR": "another_value"},
+        "files": {
+            "__init__.py": "",
+            "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.references import EnvironmentVariableReference
+
+class Workflow(BaseWorkflow):
+    class Outputs(BaseWorkflow.Outputs):
+        env_var_value = EnvironmentVariableReference(name="TEST_ENV_VAR", default="not_found")
+        another_var_value = EnvironmentVariableReference(name="ANOTHER_VAR", default="not_found")
+""",
+        },
+    }
+
+    # 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
+    assert events[0]["name"] == "vembda.execution.initiated"
+    assert events[1]["name"] == "workflow.execution.initiated"
+    assert events[2]["name"] == "workflow.execution.fulfilled"
+
+    # AND the environment variables are accessible in the workflow
+    outputs = events[2]["body"]["outputs"]
+    assert outputs["env_var_value"] == "test_value"
+    assert outputs["another_var_value"] == "another_value"

{vellum_workflow_server-0.14.69 → vellum_workflow_server-0.14.70.post1}/src/workflow_server/core/executor.py

@@ -342,6 +342,9 @@ def _create_workflow_context(executor_context: BaseExecutorContext) -> WorkflowC
     else:
         environment = VellumEnvironment.PRODUCTION
 
+    if executor_context.environment_variables:
+        os.environ.update(executor_context.environment_variables)
+
     return WorkflowContext(
         vellum_client=Vellum(
             api_key=executor_context.environment_api_key,

{vellum_workflow_server-0.14.69 → vellum_workflow_server-0.14.70.post1}/src/workflow_server/core/workflow_executor_context.py

@@ -22,6 +22,7 @@ class BaseExecutorContext(UniversalBaseModel):
     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
 
     @property
     def container_overhead_latency(self) -> int:

{vellum_workflow_server-0.14.69 → vellum_workflow_server-0.14.70.post1}/src/workflow_server/utils/tests/test_utils.py

@@ -10,7 +10,11 @@ from vellum import (
     VellumError,
     VellumImage,
 )
-from workflow_server.utils.utils import convert_json_inputs_to_vellum
+from workflow_server.utils.utils import (
+    convert_json_inputs_to_vellum,
+    to_python_safe_snake_case,
+    to_valid_python_identifier,
+)
 
 
 @pytest.mark.parametrize(
@@ -134,10 +138,57 @@ def test_input_variables_with_uppercase_gets_sanitized():
     ]
 
     expected = {
-        "foo": "<example-string-value>",
+        "Foo": "<example-string-value>",
         "foo_var": "<another-example-string-value>",
     }
 
     actual = convert_json_inputs_to_vellum(inputs)
 
     assert expected == actual
+
+
+@pytest.mark.parametrize(
+    ["input_string", "safety_prefix", "expected"],
+    [
+        ("Foo", "input", "Foo"),
+        ("test", "input", "test"),
+        ("myVariable", "input", "myVariable"),
+        ("validName123", "input", "validName123"),
+        ("Foo-Var", "input", "foo_var"),
+        ("My Variable", "input", "my_variable"),
+        ("test-case", "input", "test_case"),
+        ("CamelCase", "input", "CamelCase"),
+        ("123", "input", "input_123"),
+        ("_a", "input", "input_a"),
+        ("_123", "input", "input_123"),
+        ("test@#$", "input", "test"),
+        ("@#$test", "input", "test"),
+        ("123", "_", "_123"),
+        ("123", "var", "var_123"),
+        ("123", "var_", "var_123"),
+    ],
+)
+def test_to_valid_python_identifier(input_string, safety_prefix, expected):
+    actual = to_valid_python_identifier(input_string, safety_prefix)
+    assert expected == actual
+
+
+@pytest.mark.parametrize(
+    ["input_string", "safety_prefix", "expected"],
+    [
+        ("Foo", "input", "foo"),
+        ("Foo-Var", "input", "foo_var"),
+        ("CamelCase", "input", "camel_case"),
+        ("test", "input", "test"),
+        ("My Variable", "input", "my_variable"),
+        ("123", "input", "input_123"),
+        ("_a", "input", "input_a"),
+        ("_123", "input", "input_123"),
+        ("123", "_", "_123"),
+        ("123", "var", "var_123"),
+        ("123", "var_", "var_123"),
+    ],
+)
+def test_to_python_safe_snake_case(input_string, safety_prefix, expected):
+    actual = to_python_safe_snake_case(input_string, safety_prefix)
+    assert expected == actual

{vellum_workflow_server-0.14.69 → vellum_workflow_server-0.14.70.post1}/src/workflow_server/utils/utils.py

@@ -22,7 +22,7 @@ def convert_json_inputs_to_vellum(inputs: List[dict]) -> dict:
     for input in inputs:
         value = input["value"]
         # sync with vellum-python-sdks/ee/codegen/src/context/input-variable-context.ts
-        name = to_python_safe_snake_case(input["name"], "input")
+        name = to_valid_python_identifier(input["name"], "input")
         type = input["type"]
 
         if type == "CHAT_HISTORY":
@@ -58,7 +58,7 @@ def to_python_safe_snake_case(string: str, safety_prefix: str = "_") -> str:
     # Strip special characters from start of string
     cleaned_str = re.sub(r"^[^a-zA-Z0-9_]+", "", string)
 
-    # Check if cleaned string starts with a number or underscore
+    # Check if cleaned string starts with a number or an underscore
     starts_with_unsafe = bool(re.match(r"^[\d_]", cleaned_str))
 
     # Convert to snake case
@@ -74,6 +74,22 @@ def to_python_safe_snake_case(string: str, safety_prefix: str = "_") -> str:
     return f"{cleaned_safety_prefix}{snake_case}" if starts_with_unsafe else snake_case
 
 
+def to_valid_python_identifier(string: str, safety_prefix: str = "_") -> str:
+    # Strip special characters from start of string
+    cleaned_str = re.sub(r"^[^a-zA-Z0-9_]+", "", string)
+
+    # Check if cleaned string starts with a number or an underscore
+    starts_with_unsafe = bool(re.match(r"^[\d_]", cleaned_str))
+
+    # Check if the string is already a valid Python identifier (preserve case)
+    is_valid_python_identifier = bool(re.match(r"^[a-zA-Z][a-zA-Z0-9]*$", cleaned_str))
+
+    if is_valid_python_identifier and not starts_with_unsafe:
+        return cleaned_str
+
+    return to_python_safe_snake_case(string, safety_prefix)
+
+
 def get_obj_size(obj: Any) -> int:
     marked = {id(obj)}
     obj_q = [obj]