vellum-ai 0.14.70__tar.gz → 0.14.72__tar.gz

{vellum_ai-0.14.70 → vellum_ai-0.14.72}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 0.14.70
+Version: 0.14.72
 Summary: 
 License: MIT
 Requires-Python: >=3.9,<4.0

{vellum_ai-0.14.70 → vellum_ai-0.14.72}/ee/vellum_cli/image_push.py

@@ -30,12 +30,8 @@ def image_push_command(
         if not os.path.exists(source):
             handle_cli_error(logger, "Dockerfile not found", f"Dockerfile does not exist: {source}")
 
-        source_dir = os.path.dirname(source)
-        dockerfile_name = os.path.basename(source)
-
         build_result = subprocess.run(
-            ["docker", "buildx", "build", "-f", dockerfile_name, "--platform=linux/amd64", "-t", image, "."],
-            cwd=source_dir,
+            ["docker", "buildx", "build", "-f", source, "--platform=linux/amd64", "-t", image, "."],
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
         )

{vellum_ai-0.14.70 → vellum_ai-0.14.72}/ee/vellum_cli/push.py

@@ -242,6 +242,13 @@ def push_command(
 {json.dumps(response.proposed_diffs, indent=2)}
 """
         )  # type: ignore[attr-defined]
+
+        error_list = list(workflow_display.errors)
+        has_errors = len(error_list) > 0
+        has_diffs = response.proposed_diffs is not None and response.proposed_diffs
+
+        if has_errors or has_diffs:
+            exit(1)
     else:
         default_api_url = client._client_wrapper._environment.default
         base_url = default_api_url.split("/v1")[0].replace("//api.", "//app.")

{vellum_ai-0.14.70 → vellum_ai-0.14.72}/ee/vellum_cli/tests/test_image_push.py

@@ -209,13 +209,12 @@ def test_image_push_with_source_success(
         "buildx",
         "build",
         "-f",
-        "Dockerfile",
+        dockerfile_path,
         "--platform=linux/amd64",
         "-t",
         "myimage:latest",
         ".",
     ]
-    assert build_call[1]["cwd"] == mock_temp_dir
 
     assert "Docker build completed successfully" in result.output
     assert "Image successfully pushed" in result.output

{vellum_ai-0.14.70 → vellum_ai-0.14.72}/ee/vellum_cli/tests/test_push.py

@@ -444,8 +444,8 @@ class ExampleWorkflow(BaseWorkflow):
     runner = CliRunner(mix_stderr=True)
     result = runner.invoke(cli_main, ["push", module, "--dry-run"])
 
-    # THEN it should succeed
-    assert result.exit_code == 0
+    # THEN it should fail with exit code 1 due to errors
+    assert result.exit_code == 1
 
     # AND we should have called the push API with the dry-run option
     vellum_client.workflows.push.assert_called_once()
@@ -459,6 +459,37 @@ class ExampleWorkflow(BaseWorkflow):
     assert "iterable_item_added" in result.output
 
 
+def test_push__dry_run_option_no_errors_returns_success(mock_module, vellum_client):
+    """Test that dry-run returns exit code 0 when there are no errors or diffs"""
+    # GIVEN a workflow module with a valid workflow (using the same pattern as happy path test)
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
+    _ensure_workflow_py(temp_dir, module)
+
+    # AND the push API call returns successfully with no errors and no diffs
+    vellum_client.workflows.push.return_value = WorkflowPushResponse(
+        workflow_sandbox_id=str(uuid4()),
+        proposed_diffs=None,
+    )
+
+    # WHEN calling `vellum push` with dry-run
+    runner = CliRunner(mix_stderr=True)
+    result = runner.invoke(cli_main, ["push", module, "--dry-run"])
+
+    # THEN it should succeed with exit code 0
+    assert result.exit_code == 0
+
+    # AND we should have called the push API with the dry-run option
+    vellum_client.workflows.push.assert_called_once()
+    call_args = vellum_client.workflows.push.call_args.kwargs
+    assert call_args["dry_run"] is True
+
+    # AND the report should be in the output
+    assert "## Errors" in result.output
+    assert "No errors found." in result.output
+    assert "## Proposed Diffs" in result.output
+
+
 def test_push__strict_option_returns_diffs(mock_module, vellum_client):
     # GIVEN a single workflow configured
     temp_dir = mock_module.temp_dir

{vellum_ai-0.14.70 → vellum_ai-0.14.72}/ee/vellum_ee/workflows/display/nodes/utils.py

@@ -8,11 +8,11 @@ _T = TypeVar("_T")
 
 
 @overload
-def raise_if_descriptor(_node_attr: BaseDescriptor[_T]) -> _T: ...
+def raise_if_descriptor(node_attr: BaseDescriptor[_T]) -> _T: ...
 
 
 @overload
-def raise_if_descriptor(_node_attr: _T) -> _T: ...
+def raise_if_descriptor(node_attr: _T) -> _T: ...
 
 
 def raise_if_descriptor(node_attr: Union[NodeReference[_T], _T]) -> Optional[_T]:

{vellum_ai-0.14.70 → vellum_ai-0.14.72}/ee/vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py

@@ -2,6 +2,7 @@ from uuid import UUID
 from typing import Callable, Dict, Generic, List, Optional, Tuple, Type, TypeVar, Union
 
 from vellum import FunctionDefinition, PromptBlock, RichTextChildBlock, VellumVariable
+from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.nodes import InlinePromptNode
 from vellum.workflows.types.core import JsonObject
 from vellum.workflows.utils.functions import compile_function_definition
@@ -18,9 +19,10 @@ _InlinePromptNodeType = TypeVar("_InlinePromptNodeType", bound=InlinePromptNode)
 
 
 class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generic[_InlinePromptNodeType]):
-    __serializable_inputs__ = {InlinePromptNode.prompt_inputs, InlinePromptNode.functions}
+    __serializable_inputs__ = {
+        InlinePromptNode.prompt_inputs,
+    }
     __unserializable_attributes__ = {
-        InlinePromptNode.blocks,
         InlinePromptNode.parameters,
         InlinePromptNode.settings,
         InlinePromptNode.expand_meta,
@@ -45,7 +47,9 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
         ml_model = str(raise_if_descriptor(node.ml_model))
 
         blocks: list = [
-            self._generate_prompt_block(block, input_variable_id_by_name, [i]) for i, block in enumerate(node_blocks)
+            self._generate_prompt_block(block, input_variable_id_by_name, [i])
+            for i, block in enumerate(node_blocks)
+            if not isinstance(block, BaseDescriptor)
         ]
 
         functions = (

{vellum_ai-0.14.70 → vellum_ai-0.14.72}/ee/vellum_ee/workflows/display/nodes/vellum/search_node.py

@@ -7,6 +7,7 @@ from vellum import (
     VellumValueLogicalConditionGroupRequest,
     VellumValueLogicalConditionRequest,
 )
+from vellum.workflows.nodes.displayable.bases.types import MetadataLogicalCondition, MetadataLogicalConditionGroup
 from vellum.workflows.nodes.displayable.search_node import SearchNode
 from vellum.workflows.references import OutputReference
 from vellum.workflows.types.core import JsonArray, JsonObject
@@ -88,7 +89,8 @@ class BaseSearchNodeDisplay(BaseNodeDisplay[_SearchNodeType], Generic[_SearchNod
         node_inputs: Dict[str, NodeInput] = {}
 
         options = raise_if_descriptor(node.options)
-        filters = options.filters if options else None
+        raw_filters = raise_if_descriptor(node.filters)
+        filters = raw_filters if raw_filters else options.filters if options else None
 
         external_id_filters = filters.external_ids if filters else None
 
@@ -104,17 +106,21 @@ class BaseSearchNodeDisplay(BaseNodeDisplay[_SearchNodeType], Generic[_SearchNod
                 raw_metadata_filters, display_context=display_context
             )
 
-        result_merging = options.result_merging if options else None
+        raw_result_merging = raise_if_descriptor(node.result_merging)
+        result_merging = raw_result_merging if raw_result_merging else options.result_merging if options else None
         result_merging_enabled = True if result_merging and result_merging.enabled else False
 
         raw_weights = raise_if_descriptor(node.weights)
         weights = raw_weights if raw_weights is not None else options.weights if options is not None else None
 
+        raw_limit = raise_if_descriptor(node.limit)
+        limit = raw_limit if raw_limit is not None else options.limit if options is not None else None
+
         node_input_names_and_values = [
             ("query", node.query),
             ("document_index_id", node.document_index),
             ("weights", weights.dict() if weights else None),
-            ("limit", options.limit if options else None),
+            ("limit", limit),
             ("separator", raise_if_descriptor(node.chunk_separator)),
             (
                 "result_merging_enabled",
@@ -141,7 +147,12 @@ class BaseSearchNodeDisplay(BaseNodeDisplay[_SearchNodeType], Generic[_SearchNod
 
     def _serialize_logical_expression(
         self,
-        logical_expression: Union[VellumValueLogicalConditionGroupRequest, VellumValueLogicalConditionRequest],
+        logical_expression: Union[
+            VellumValueLogicalConditionGroupRequest,
+            VellumValueLogicalConditionRequest,
+            MetadataLogicalConditionGroup,
+            MetadataLogicalCondition,
+        ],
         display_context: WorkflowDisplayContext,
         path: List[int] = [],
     ) -> Tuple[JsonObject, List[NodeInput]]:
@@ -175,10 +186,10 @@ class BaseSearchNodeDisplay(BaseNodeDisplay[_SearchNodeType], Generic[_SearchNod
 
             lhs_query_input_id: UUID = self.metadata_filter_input_id_by_operand_id.get(
                 UUID(lhs_variable_id)
-            ) or uuid4_from_hash(f"{self.node_id}|{hash(tuple(path))}")
+            ) or uuid4_from_hash(f"{self.node_id}|lhs|{hash(tuple(path))}")
             rhs_query_input_id: UUID = self.metadata_filter_input_id_by_operand_id.get(
                 UUID(rhs_variable_id)
-            ) or uuid4_from_hash(f"{self.node_id}|{hash(tuple(path))}")
+            ) or uuid4_from_hash(f"{self.node_id}|rhs|{hash(tuple(path))}")
 
             return (
                 {
@@ -206,5 +217,57 @@ class BaseSearchNodeDisplay(BaseNodeDisplay[_SearchNodeType], Generic[_SearchNod
                     ),
                 ],
             )
+
+        elif isinstance(logical_expression, MetadataLogicalConditionGroup):
+            conditions = []
+            variables = []
+            for idx, metadata_condition in enumerate(logical_expression.conditions):
+                serialized_condition, serialized_variables = self._serialize_logical_expression(
+                    metadata_condition, display_context=display_context, path=path + [idx]
+                )
+                conditions.append(serialized_condition)
+                variables.extend(serialized_variables)
+
+            return (
+                {
+                    "type": "LOGICAL_CONDITION_GROUP",
+                    "combinator": logical_expression.combinator,
+                    "conditions": conditions,
+                    "negated": logical_expression.negated,
+                },
+                variables,
+            )
+
+        elif isinstance(logical_expression, MetadataLogicalCondition):
+            lhs_variable = logical_expression.lhs_variable
+            rhs_variable = logical_expression.rhs_variable
+
+            lhs_query_input_id = uuid4_from_hash(f"{self.node_id}|lhs|{hash(tuple(path))}")
+            rhs_query_input_id = uuid4_from_hash(f"{self.node_id}|rhs|{hash(tuple(path))}")
+
+            return (
+                {
+                    "type": "LOGICAL_CONDITION",
+                    "lhs_variable_id": str(lhs_query_input_id),
+                    "operator": logical_expression.operator,
+                    "rhs_variable_id": str(rhs_query_input_id),
+                },
+                [
+                    create_node_input(
+                        self.node_id,
+                        f"vellum-query-builder-variable-{lhs_query_input_id}",
+                        lhs_variable,
+                        display_context,
+                        input_id=lhs_query_input_id,
+                    ),
+                    create_node_input(
+                        self.node_id,
+                        f"vellum-query-builder-variable-{rhs_query_input_id}",
+                        rhs_variable,
+                        display_context,
+                        input_id=rhs_query_input_id,
+                    ),
+                ],
+            )
         else:
             raise ValueError(f"Unsupported logical expression type: {type(logical_expression)}")

vellum_ai-0.14.72/ee/vellum_ee/workflows/display/nodes/vellum/tests/test_search_node.py

@@ -0,0 +1,104 @@
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs import BaseInputs
+from vellum.workflows.nodes.displayable import SearchNode
+from vellum.workflows.nodes.displayable.bases.types import (
+    MetadataLogicalCondition,
+    MetadataLogicalConditionGroup,
+    SearchFilters,
+)
+from vellum.workflows.state.base import BaseState
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+def test_search_filters_with_input_reference():
+    """Test that SearchFilters with MetadataLogicalCondition using input references can be serialized"""
+
+    # GIVEN a search node with a metadata filter that uses an input reference
+    class TestInputs(BaseInputs):
+        file_id: str
+
+    class MySearchNode(SearchNode):
+        query = "my query"
+        document_index = "document_index"
+        filters = SearchFilters(
+            external_ids=None,
+            metadata=MetadataLogicalConditionGroup(
+                combinator="AND",
+                negated=False,
+                conditions=[MetadataLogicalCondition(lhs_variable="ID", operator="=", rhs_variable=TestInputs.file_id)],
+            ),
+        )
+
+    # AND a workflow with the Search Node
+    class Workflow(BaseWorkflow[TestInputs, BaseState]):
+        graph = MySearchNode
+
+    # WHEN the workflow is serialized
+    workflow_display = get_workflow_display(workflow_class=Workflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the node should properly serialize the filter reference
+    serialized_search_node = next(
+        node for node in serialized_workflow["workflow_raw_data"]["nodes"] if node["id"] == str(MySearchNode.__id__)
+    )
+
+    serialized_metadata_filter = next(
+        inp for inp in serialized_search_node["inputs"] if inp["key"] == "metadata_filters"
+    )
+
+    assert serialized_metadata_filter == {
+        "id": "4a9f96aa-ba3b-4c4e-9ce4-370fe64f717f",
+        "key": "metadata_filters",
+        "value": {
+            "combinator": "OR",
+            "rules": [
+                {
+                    "data": {
+                        "type": "JSON",
+                        "value": {
+                            "combinator": "AND",
+                            "conditions": [
+                                {
+                                    "lhs_variable_id": "9aedaffa-c2a4-4c37-9969-184e1ff43ded",
+                                    "operator": "=",
+                                    "rhs_variable_id": "c2151ef1-ad98-4940-b0e9-28dabe47a951",
+                                    "type": "LOGICAL_CONDITION",
+                                }
+                            ],
+                            "negated": False,
+                            "type": "LOGICAL_CONDITION_GROUP",
+                        },
+                    },
+                    "type": "CONSTANT_VALUE",
+                }
+            ],
+        },
+    }
+
+    # AND the LHS filter references should be present as node inputs
+    serialized_lhs_input = next(
+        inp for inp in serialized_search_node["inputs"] if inp["id"] == "9aedaffa-c2a4-4c37-9969-184e1ff43ded"
+    )
+    assert serialized_lhs_input["value"] == {
+        "combinator": "OR",
+        "rules": [
+            {
+                "data": {"type": "STRING", "value": "ID"},
+                "type": "CONSTANT_VALUE",
+            }
+        ],
+    }
+
+    # AND the RHS filter references should be present as node inputs
+    serialized_rhs_input = next(
+        inp for inp in serialized_search_node["inputs"] if inp["id"] == "c2151ef1-ad98-4940-b0e9-28dabe47a951"
+    )
+    assert serialized_rhs_input["value"] == {
+        "combinator": "OR",
+        "rules": [
+            {
+                "data": {"input_variable_id": "e2f4fff9-1277-47cb-8988-12f8ada450ba"},
+                "type": "INPUT_VARIABLE",
+            }
+        ],
+    }

{vellum_ai-0.14.70 → vellum_ai-0.14.72}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_inline_prompt_node_serialization.py

@@ -174,6 +174,34 @@ def test_serialize_workflow():
                     "name": "ml_model",
                     "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "gpt-4o"}},
                 },
+                {
+                    "id": "25f935f3-363f-4ead-a5a0-db234ca67e1e",
+                    "name": "blocks",
+                    "value": {
+                        "type": "CONSTANT_VALUE",
+                        "value": {
+                            "type": "JSON",
+                            "value": [
+                                {
+                                    "block_type": "CHAT_MESSAGE",
+                                    "state": None,
+                                    "cache_config": None,
+                                    "chat_role": "SYSTEM",
+                                    "chat_source": None,
+                                    "chat_message_unterminated": None,
+                                    "blocks": [
+                                        {
+                                            "block_type": "JINJA",
+                                            "state": None,
+                                            "cache_config": None,
+                                            "template": "What's your favorite {{noun}}?",
+                                        }
+                                    ],
+                                }
+                            ],
+                        },
+                    },
+                },
                 {
                     "id": "ffabe7d2-8ab6-4201-9d41-c4d7be1386e1",
                     "name": "prompt_inputs",
@@ -355,3 +383,57 @@ def test_serialize_workflow_with_descriptor_functions():
         "node_output_id": "470fadb9-b8b5-477e-a502-5209d398bcf9",
         "type": "NODE_OUTPUT",
     }
+
+
+def test_serialize_workflow_with_descriptor_blocks():
+    """Test that serialization handles BaseDescriptor instances in blocks list."""
+
+    class TestInputs(BaseInputs):
+        noun: str
+
+    class UpstreamNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            results: list
+
+        def run(self) -> Outputs:
+            return self.Outputs(results=["test"])
+
+    class TestInlinePromptNodeWithDescriptorBlocks(InlinePromptNode):
+        ml_model = "gpt-4o"
+        blocks = [UpstreamNode.Outputs.results[0]]  # type: ignore
+        prompt_inputs = {"noun": TestInputs.noun}
+
+    class TestWorkflow(BaseWorkflow[TestInputs, BaseState]):
+        graph = UpstreamNode >> TestInlinePromptNodeWithDescriptorBlocks
+
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    serialized: dict = workflow_display.serialize()
+
+    prompt_nodes = [node for node in serialized["workflow_raw_data"]["nodes"] if node["type"] == "PROMPT"]
+    prompt_node = prompt_nodes[0]
+
+    blocks = prompt_node["data"]["exec_config"]["prompt_template_block_data"]["blocks"]
+    descriptor_blocks = [block for block in blocks if not isinstance(block, dict) or not block.get("block_type")]
+    assert len(descriptor_blocks) == 0, "BaseDescriptor blocks should not appear in serialized blocks"
+
+    blocks_attr = next((attr for attr in prompt_node["attributes"] if attr["name"] == "blocks"), None)
+    assert blocks_attr is not None, "blocks attribute should be present when blocks contain BaseDescriptor"
+    assert blocks_attr["value"]["type"] == "ARRAY_REFERENCE", "blocks attribute should be serialized as ARRAY_REFERENCE"
+    assert blocks_attr["value"]["items"] == [
+        {
+            "type": "BINARY_EXPRESSION",
+            "lhs": {
+                "type": "NODE_OUTPUT",
+                "node_id": str(UpstreamNode.__id__),
+                "node_output_id": str(UpstreamNode.__output_ids__["results"]),
+            },
+            "operator": "accessField",
+            "rhs": {
+                "type": "CONSTANT_VALUE",
+                "value": {
+                    "type": "NUMBER",
+                    "value": 0.0,
+                },
+            },
+        }
+    ]

{vellum_ai-0.14.70 → vellum_ai-0.14.72}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_search_node_serialization.py

@@ -167,7 +167,7 @@ def test_serialize_workflow():
                     "rules": [
                         {
                             "type": "INPUT_VARIABLE",
-                            "data": {"input_variable_id": "8ffffeb2-79b3-4105-acc7-78b0267da955"},
+                            "data": {"input_variable_id": "b118247f-96dd-4b3e-8289-9f277483c520"},
                         }
                     ],
                     "combinator": "OR",
@@ -180,7 +180,7 @@ def test_serialize_workflow():
                     "rules": [
                         {
                             "type": "INPUT_VARIABLE",
-                            "data": {"input_variable_id": "8ffffeb2-79b3-4105-acc7-78b0267da955"},
+                            "data": {"input_variable_id": "aae2c10a-88b7-40bd-87a2-5e1e60c1e906"},
                         }
                     ],
                     "combinator": "OR",
@@ -193,7 +193,7 @@ def test_serialize_workflow():
                     "rules": [
                         {
                             "type": "INPUT_VARIABLE",
-                            "data": {"input_variable_id": "f5eee974-b0c3-4775-bc8a-679a9e99d7ba"},
+                            "data": {"input_variable_id": "c9611a62-d1f5-4b41-bf9c-1aa3355760b4"},
                         }
                     ],
                     "combinator": "OR",
@@ -206,7 +206,7 @@ def test_serialize_workflow():
                     "rules": [
                         {
                             "type": "INPUT_VARIABLE",
-                            "data": {"input_variable_id": "f5eee974-b0c3-4775-bc8a-679a9e99d7ba"},
+                            "data": {"input_variable_id": "f374640e-a5c0-470e-ac71-c36c2b198c00"},
                         }
                     ],
                     "combinator": "OR",

vellum_ai-0.14.72/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_workflow_input_parameterization_error.py

@@ -0,0 +1,37 @@
+import pytest
+
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum_ee.workflows.display.utils.exceptions import UnsupportedSerializationException
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+def test_workflow_serialization_error_when_node_references_unparameterized_inputs():
+    """Test that a helpful error is raised when a node references inputs not parameterized by the workflow."""
+
+    class CustomInputs(BaseInputs):
+        custom_input: str
+
+    class TestNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            output = CustomInputs.custom_input
+
+    class TestWorkflow(BaseWorkflow):
+        graph = TestNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            result = TestNode.Outputs.output
+
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+
+    with pytest.raises(UnsupportedSerializationException) as exc_info:
+        workflow_display.serialize()
+
+    error_message = str(exc_info.value)
+    expected_message = (
+        "Inputs class 'CustomInputs' referenced during serialization of 'TestWorkflow' "
+        "without parameterizing this Workflow with this Inputs definition. "
+        "Update your Workflow definition to 'TestWorkflow(BaseWorkflow[CustomInputs, BaseState])'."
+    )
+    assert error_message == expected_message

{vellum_ai-0.14.70 → vellum_ai-0.14.72}/ee/vellum_ee/workflows/display/utils/expressions.py

@@ -211,7 +211,16 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
         return serialize_value(display_context, child_descriptor)
 
     if isinstance(value, WorkflowInputReference):
-        workflow_input_display = display_context.global_workflow_input_displays[value]
+        try:
+            workflow_input_display = display_context.global_workflow_input_displays[value]
+        except KeyError:
+            inputs_class_name = value.inputs_class.__name__
+            workflow_class_name = display_context.workflow_display_class.infer_workflow_class().__name__
+            raise UnsupportedSerializationException(
+                f"Inputs class '{inputs_class_name}' referenced during serialization of '{workflow_class_name}' "
+                f"without parameterizing this Workflow with this Inputs definition. Update your Workflow "
+                f"definition to '{workflow_class_name}(BaseWorkflow[{inputs_class_name}, BaseState])'."
+            )
         return {
             "type": "WORKFLOW_INPUT",
             "input_variable_id": str(workflow_input_display.id),