vellum-ai 0.12.8__tar.gz → 0.12.9__tar.gz

{vellum_ai-0.12.8 → vellum_ai-0.12.9}/PKG-INFO

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

{vellum_ai-0.12.8 → vellum_ai-0.12.9}/ee/vellum_cli/tests/test_push.py

@@ -8,7 +8,7 @@ from uuid import uuid4
 from click.testing import CliRunner
 
 from vellum.client.types.workflow_push_response import WorkflowPushResponse
-from vellum.evaluations.utils.uuid import is_valid_uuid
+from vellum.utils.uuid import is_valid_uuid
 from vellum_cli import main as cli_main
 
 

{vellum_ai-0.12.8 → vellum_ai-0.12.9}/ee/vellum_ee/workflows/display/nodes/vellum/inline_subworkflow_node.py

@@ -61,6 +61,11 @@ class BaseInlineSubworkflowNodeDisplay(
         display_context: WorkflowDisplayContext,
     ) -> Tuple[List[NodeInput], List[VellumVariable]]:
         subworkflow_inputs = raise_if_descriptor(node.subworkflow_inputs)
+        subworkflow_entries = (
+            [(variable_name, variable_value) for variable_name, variable_value in subworkflow_inputs.items()]
+            if isinstance(subworkflow_inputs, dict)
+            else [(variable_ref.name, variable_value) for variable_ref, variable_value in subworkflow_inputs]
+        )
         node_inputs = [
             create_node_input(
                 node_id=node_id,
@@ -69,7 +74,7 @@ class BaseInlineSubworkflowNodeDisplay(
                 display_context=display_context,
                 input_id=self.workflow_input_ids_by_name.get(variable_name),
             )
-            for variable_name, variable_value in subworkflow_inputs.items()
+            for variable_name, variable_value in subworkflow_entries
         ]
         node_inputs_by_key = {node_input.key: node_input for node_input in node_inputs}
         workflow_inputs = [

vellum_ai-0.12.9/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_templating_node_serialization.py

@@ -0,0 +1,207 @@
+from deepdiff import DeepDiff
+
+from vellum_ee.workflows.display.workflows import VellumWorkflowDisplay
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+from tests.workflows.basic_templating_node.workflow_with_json_input import BasicTemplatingNodeWorkflowWithJson
+
+
+def test_serialize_workflow():
+    # GIVEN a Workflow that uses a vellum templating node",
+
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(
+        base_display_class=VellumWorkflowDisplay, workflow_class=BasicTemplatingNodeWorkflowWithJson
+    )
+
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN we should get a serialized representation of the Workflow
+    assert serialized_workflow.keys() == {
+        "workflow_raw_data",
+        "input_variables",
+        "output_variables",
+    }
+
+    # AND its input variables should be what we expect
+    input_variables = serialized_workflow["input_variables"]
+    assert len(input_variables) == 1
+    assert input_variables == [
+        {
+            "id": "f4435f88-703f-40e5-9197-d39b0e43ab72",
+            "key": "info",
+            "type": "JSON",
+            "default": None,
+            "required": True,
+            "extensions": {"color": None},
+        }
+    ]
+
+    # AND its output variables should be what we expect
+    output_variables = serialized_workflow["output_variables"]
+    assert len(output_variables) == 1
+    assert not DeepDiff(
+        [{"id": "62ec9b08-6437-4f8d-bc20-983d317bc348", "key": "result", "type": "JSON"}],
+        output_variables,
+        ignore_order=True,
+    )
+
+    # AND its raw data should be what we expect
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    assert workflow_raw_data.keys() == {"edges", "nodes", "display_data", "definition"}
+    assert len(workflow_raw_data["edges"]) == 2
+    assert len(workflow_raw_data["nodes"]) == 3
+
+    # AND each node should be serialized correctly
+    entrypoint_node = workflow_raw_data["nodes"][0]
+    assert entrypoint_node == {
+        "id": "09579c0a-acbf-4e04-8724-2230a8aa6534",
+        "type": "ENTRYPOINT",
+        "inputs": [],
+        "data": {"label": "Entrypoint Node", "source_handle_id": "34069190-0942-4e0c-8700-b33b9dea4ea0"},
+        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "definition": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"], "bases": []},
+    }
+
+    templating_node = workflow_raw_data["nodes"][1]
+    assert not DeepDiff(
+        {
+            "id": "51cbe21d-0232-4362-bc54-5bc283297aa6",
+            "type": "TEMPLATING",
+            "inputs": [
+                {
+                    "id": "7c775379-d589-4d79-b876-dcd224d72966",
+                    "key": "template",
+                    "value": {
+                        "rules": [
+                            {
+                                "type": "CONSTANT_VALUE",
+                                "data": {"type": "STRING", "value": "The meaning of {{ info }} is not known"},
+                            }
+                        ],
+                        "combinator": "OR",
+                    },
+                },
+                {
+                    "id": "bb712499-4265-4d71-bc14-0c3d8ca6a7de",
+                    "key": "info",
+                    "value": {
+                        "rules": [
+                            {
+                                "type": "INPUT_VARIABLE",
+                                "data": {"input_variable_id": "f4435f88-703f-40e5-9197-d39b0e43ab72"},
+                            }
+                        ],
+                        "combinator": "OR",
+                    },
+                },
+            ],
+            "data": {
+                "label": "Example Templating Node",
+                "output_id": "6834cae4-8173-4fa6-88f7-bc09d335bdd1",
+                "error_output_id": None,
+                "source_handle_id": "39317827-df43-4f5a-bfbc-20bffc839748",
+                "target_handle_id": "58427684-3848-498a-8299-c6b0fc70265d",
+                "template_node_input_id": "7c775379-d589-4d79-b876-dcd224d72966",
+                "output_type": "JSON",
+            },
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "definition": {
+                "name": "ExampleTemplatingNode",
+                "module": ["tests", "workflows", "basic_templating_node", "workflow_with_json_input"],
+                "bases": [
+                    {
+                        "name": "TemplatingNode",
+                        "module": ["vellum", "workflows", "nodes", "core", "templating_node", "node"],
+                    }
+                ],
+            },
+        },
+        templating_node,
+    )
+
+    final_output_node = workflow_raw_data["nodes"][-1]
+    assert not DeepDiff(
+        {
+            "id": "9f75228b-1d5b-4c30-a581-6087e6a1b738",
+            "type": "TERMINAL",
+            "data": {
+                "label": "Final Output",
+                "name": "result",
+                "target_handle_id": "16ba108e-61a8-4338-8a5b-4f1278d7fd7b",
+                "output_id": "62ec9b08-6437-4f8d-bc20-983d317bc348",
+                "output_type": "JSON",
+                "node_input_id": "310072db-6d07-4d29-8e5c-9c6909300925",
+            },
+            "inputs": [
+                {
+                    "id": "310072db-6d07-4d29-8e5c-9c6909300925",
+                    "key": "node_input",
+                    "value": {
+                        "rules": [
+                            {
+                                "type": "NODE_OUTPUT",
+                                "data": {
+                                    "node_id": "51cbe21d-0232-4362-bc54-5bc283297aa6",
+                                    "output_id": "6834cae4-8173-4fa6-88f7-bc09d335bdd1",
+                                },
+                            }
+                        ],
+                        "combinator": "OR",
+                    },
+                }
+            ],
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "definition": {
+                "name": "FinalOutputNode",
+                "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
+                "bases": [
+                    {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"], "bases": []}
+                ],
+            },
+        },
+        final_output_node,
+        ignore_order=True,
+    )
+
+    # AND each edge should be serialized correctly
+    serialized_edges = workflow_raw_data["edges"]
+    assert not DeepDiff(
+        [
+            {
+                "id": "9f753b40-68de-4186-838e-806a14853935",
+                "source_node_id": "09579c0a-acbf-4e04-8724-2230a8aa6534",
+                "source_handle_id": "34069190-0942-4e0c-8700-b33b9dea4ea0",
+                "target_node_id": "51cbe21d-0232-4362-bc54-5bc283297aa6",
+                "target_handle_id": "58427684-3848-498a-8299-c6b0fc70265d",
+                "type": "DEFAULT",
+            },
+            {
+                "id": "00cbff5c-5cce-4ef4-81b2-1a11d9b42597",
+                "source_node_id": "51cbe21d-0232-4362-bc54-5bc283297aa6",
+                "source_handle_id": "39317827-df43-4f5a-bfbc-20bffc839748",
+                "target_node_id": "9f75228b-1d5b-4c30-a581-6087e6a1b738",
+                "target_handle_id": "16ba108e-61a8-4338-8a5b-4f1278d7fd7b",
+                "type": "DEFAULT",
+            },
+        ],
+        serialized_edges,
+        ignore_order=True,
+    )
+
+    # AND the display data should be what we expect
+    display_data = workflow_raw_data["display_data"]
+    assert display_data == {
+        "viewport": {
+            "x": 0.0,
+            "y": 0.0,
+            "zoom": 1.0,
+        }
+    }
+
+    # AND the definition should be what we expect
+    definition = workflow_raw_data["definition"]
+    assert definition == {
+        "name": "BasicTemplatingNodeWorkflowWithJson",
+        "module": ["tests", "workflows", "basic_templating_node", "workflow_with_json_input"],
+    }

{vellum_ai-0.12.8 → vellum_ai-0.12.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vellum-ai"
-version = "0.12.8"
+version = "0.12.9"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-0.12.8 → vellum_ai-0.12.9}/src/vellum/client/core/client_wrapper.py

@@ -18,7 +18,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.12.8",
+            "X-Fern-SDK-Version": "0.12.9",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

{vellum_ai-0.12.8 → vellum_ai-0.12.9}/src/vellum/evaluations/resources.py

@@ -12,7 +12,6 @@ from vellum.evaluations.constants import DEFAULT_MAX_POLLING_DURATION_MS, DEFAUL
 from vellum.evaluations.exceptions import TestSuiteRunResultsException
 from vellum.evaluations.utils.env import get_api_key
 from vellum.evaluations.utils.paginator import PaginatedResults, get_all_results
-from vellum.evaluations.utils.uuid import is_valid_uuid
 from vellum.types import (
     ExternalTestCaseExecutionRequest,
     NamedTestCaseVariableValueRequest,
@@ -24,6 +23,7 @@ from vellum.types import (
     TestSuiteRunState,
 )
 from vellum.utils.typing import cast_not_optional
+from vellum.utils.uuid import is_valid_uuid
 
 logger = logging.getLogger(__name__)
 

{vellum_ai-0.12.8 → vellum_ai-0.12.9}/src/vellum/prompts/blocks/compilation.py

@@ -104,16 +104,16 @@ def compile_prompt_blocks(
                 chat_message_blocks = _compile_chat_messages_as_prompt_blocks(compiled_input.value)
                 compiled_blocks.extend(chat_message_blocks)
             else:
-                raise ValueError(f"Invalid input type for variable block: {compiled_input.type}")
+                raise PromptCompilationError(f"Invalid input type for variable block: {compiled_input.type}")
 
         elif block.block_type == "RICH_TEXT":
             value_block = _compile_rich_text_block_as_value_block(block=block, inputs=sanitized_inputs)
             compiled_blocks.append(value_block)
 
         elif block.block_type == "FUNCTION_DEFINITION":
-            raise ValueError("Function definitions shouldn't go through compilation process")
+            raise PromptCompilationError("Function definitions shouldn't go through compilation process")
         else:
-            raise ValueError(f"Unknown block_type: {block.block_type}")
+            raise PromptCompilationError(f"Unknown block_type: {block.block_type}")
 
     return compiled_blocks
 
@@ -172,7 +172,7 @@ def _compile_rich_text_block_as_value_block(
                     f"Input variable '{child_block.input_variable}' must be of type STRING or JSON"
                 )
         else:
-            raise ValueError(f"Invalid child block_type for RICH_TEXT: {child_block.block_type}")
+            raise PromptCompilationError(f"Invalid child block_type for RICH_TEXT: {child_block.block_type}")
 
     return CompiledValuePromptBlock(content=StringVellumValue(value=value), cache_config=block.cache_config)
 

vellum_ai-0.12.9/src/vellum/workflows/nodes/bases/__init__.py

@@ -0,0 +1,5 @@
+from .base import BaseNode
+
+__all__ = [
+    "BaseNode",
+]

{vellum_ai-0.12.8 → vellum_ai-0.12.9}/src/vellum/workflows/nodes/bases/base.py

@@ -344,8 +344,8 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
         all_inputs = {}
         for key, value in inputs.items():
             path_parts = key.split(".")
-            node_attribute_discriptor = getattr(self.__class__, path_parts[0])
-            inputs_key = reduce(lambda acc, part: acc[part], path_parts[1:], node_attribute_discriptor)
+            node_attribute_descriptor = getattr(self.__class__, path_parts[0])
+            inputs_key = reduce(lambda acc, part: acc[part], path_parts[1:], node_attribute_descriptor)
             all_inputs[inputs_key] = value
 
         self._inputs = MappingProxyType(all_inputs)
@@ -355,7 +355,3 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
 
     def __repr__(self) -> str:
         return str(self.__class__)
-
-
-class MyNode2(BaseNode):
-    pass

{vellum_ai-0.12.8 → vellum_ai-0.12.9}/src/vellum/workflows/nodes/core/inline_subworkflow_node/node.py

@@ -1,12 +1,14 @@
-from typing import TYPE_CHECKING, Generic, Iterator, Optional, Set, Type, TypeVar
+from typing import TYPE_CHECKING, ClassVar, Generic, Iterator, Optional, Set, Type, TypeVar, Union
 
 from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
-from vellum.workflows.nodes.bases.base_subworkflow_node import BaseSubworkflowNode
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.state.context import WorkflowContext
+from vellum.workflows.types.core import EntityInputsInterface
 from vellum.workflows.types.generics import StateType, WorkflowInputsType
 
 if TYPE_CHECKING:
@@ -15,7 +17,7 @@ if TYPE_CHECKING:
 InnerStateType = TypeVar("InnerStateType", bound=BaseState)
 
 
-class InlineSubworkflowNode(BaseSubworkflowNode[StateType], Generic[StateType, WorkflowInputsType, InnerStateType]):
+class InlineSubworkflowNode(BaseNode[StateType], Generic[StateType, WorkflowInputsType, InnerStateType]):
     """
     Used to execute a Subworkflow defined inline.
 
@@ -24,14 +26,13 @@ class InlineSubworkflowNode(BaseSubworkflowNode[StateType], Generic[StateType, W
     """
 
     subworkflow: Type["BaseWorkflow[WorkflowInputsType, InnerStateType]"]
+    subworkflow_inputs: ClassVar[Union[EntityInputsInterface, BaseInputs]] = {}
 
     def run(self) -> Iterator[BaseOutput]:
         with execution_context(parent_context=get_parent_context() or self._context.parent_context):
             subworkflow = self.subworkflow(
                 parent_state=self.state,
-                context=WorkflowContext(
-                    _vellum_client=self._context._vellum_client,
-                ),
+                context=WorkflowContext(vellum_client=self._context.vellum_client),
             )
             subworkflow_stream = subworkflow.stream(
                 inputs=self._compile_subworkflow_inputs(),
@@ -68,4 +69,9 @@ class InlineSubworkflowNode(BaseSubworkflowNode[StateType], Generic[StateType, W
 
     def _compile_subworkflow_inputs(self) -> WorkflowInputsType:
         inputs_class = self.subworkflow.get_inputs_class()
-        return inputs_class(**self.subworkflow_inputs)
+        if isinstance(self.subworkflow_inputs, dict):
+            return inputs_class(**self.subworkflow_inputs)
+        elif isinstance(self.subworkflow_inputs, inputs_class):
+            return self.subworkflow_inputs
+        else:
+            raise ValueError(f"Invalid subworkflow inputs type: {type(self.subworkflow_inputs)}")

vellum_ai-0.12.9/src/vellum/workflows/nodes/core/inline_subworkflow_node/tests/test_node.py

@@ -0,0 +1,41 @@
+import pytest
+
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.nodes.core.inline_subworkflow_node.node import InlineSubworkflowNode
+from vellum.workflows.outputs.base import BaseOutput
+from vellum.workflows.state.base import BaseState
+from vellum.workflows.workflows.base import BaseWorkflow
+
+
+class Inputs(BaseInputs):
+    foo: str
+
+
+class MyInnerNode(BaseNode):
+    class Outputs(BaseNode.Outputs):
+        out = Inputs.foo
+
+
+class MySubworkflow(BaseWorkflow[Inputs, BaseState]):
+    graph = MyInnerNode
+
+    class Outputs(BaseWorkflow.Outputs):
+        out = MyInnerNode.Outputs.out
+
+
+@pytest.mark.parametrize("inputs", [{"foo": "bar"}, Inputs(foo="bar")])
+def test_inline_subworkflow_node__inputs(inputs):
+    # GIVEN a node setup with subworkflow inputs
+    class MyNode(InlineSubworkflowNode):
+        subworkflow = MySubworkflow
+        subworkflow_inputs = inputs
+
+    # WHEN the node is run
+    node = MyNode()
+    events = list(node.run())
+
+    # THEN the output is as expected
+    assert events == [
+        BaseOutput(name="out", value="bar"),
+    ]

{vellum_ai-0.12.8 → vellum_ai-0.12.9}/src/vellum/workflows/nodes/core/map_node/node.py

@@ -108,7 +108,7 @@ class MapNode(BaseNode, Generic[StateType, MapNodeItemType]):
             self._run_subworkflow(item=item, index=index)
 
     def _run_subworkflow(self, *, item: MapNodeItemType, index: int) -> None:
-        context = WorkflowContext(_vellum_client=self._context._vellum_client)
+        context = WorkflowContext(vellum_client=self._context.vellum_client)
         subworkflow = self.subworkflow(parent_state=self.state, context=context)
         events = subworkflow.stream(
             inputs=self.SubworkflowInputs(index=index, item=item, all_items=self.items),

{vellum_ai-0.12.8 → vellum_ai-0.12.9}/src/vellum/workflows/nodes/core/templating_node/node.py

@@ -1,3 +1,4 @@
+import json
 from typing import Any, Callable, ClassVar, Dict, Generic, Mapping, Tuple, Type, TypeVar, Union, get_args
 
 from vellum.utils.templating.constants import DEFAULT_JINJA_CUSTOM_FILTERS, DEFAULT_JINJA_GLOBALS
@@ -7,7 +8,7 @@ from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.bases.base import BaseNodeMeta
-from vellum.workflows.types.core import EntityInputsInterface
+from vellum.workflows.types.core import EntityInputsInterface, Json
 from vellum.workflows.types.generics import StateType
 from vellum.workflows.types.utils import get_original_base
 
@@ -87,6 +88,12 @@ class TemplatingNode(BaseNode[StateType], Generic[StateType, _OutputType], metac
         if output_type is bool:
             return bool(rendered_template)
 
+        if output_type is Json:
+            try:
+                return json.loads(rendered_template)
+            except json.JSONDecodeError:
+                raise ValueError("Invalid JSON format for rendered_template")
+
         raise ValueError(f"Unsupported output type: {output_type}")
 
     def run(self) -> Outputs:

vellum_ai-0.12.9/src/vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py

@@ -0,0 +1,108 @@
+import json
+
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.nodes.core.templating_node.node import TemplatingNode
+from vellum.workflows.state import BaseState
+from vellum.workflows.types.core import Json
+
+
+def test_templating_node__dict_output():
+    # GIVEN a templating node with a dict input that just returns it
+    class TemplateNode(TemplatingNode):
+        template = "{{ data }}"
+        inputs = {
+            "data": {
+                "key": "value",
+            }
+        }
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN the output is json serializable
+    assert json.loads(outputs.result) == {"key": "value"}
+
+
+def test_templating_node__int_output():
+    # GIVEN a templating node that outputs an integer
+    class IntTemplateNode(TemplatingNode[BaseState, int]):
+        template = "{{ data }}"
+        inputs = {
+            "data": 42,
+        }
+
+    # WHEN the node is run
+    node = IntTemplateNode()
+    outputs = node.run()
+
+    # THEN the output is the expected integer
+    assert outputs.result == 42
+
+
+def test_templating_node__float_output():
+    # GIVEN a templating node that outputs a float
+    class FloatTemplateNode(TemplatingNode[BaseState, float]):
+        template = "{{ data }}"
+        inputs = {
+            "data": 42.5,
+        }
+
+    # WHEN the node is run
+    node = FloatTemplateNode()
+    outputs = node.run()
+
+    # THEN the output is the expected float
+    assert outputs.result == 42.5
+
+
+def test_templating_node__bool_output():
+    # GIVEN a templating node that outputs a bool
+    class BoolTemplateNode(TemplatingNode[BaseState, bool]):
+        template = "{{ data }}"
+        inputs = {
+            "data": True,
+        }
+
+    # WHEN the node is run
+    node = BoolTemplateNode()
+    outputs = node.run()
+
+    # THEN the output is the expected bool
+    assert outputs.result is True
+
+
+def test_templating_node__json_output():
+    # GIVEN a templating node that outputs JSON
+    class JSONTemplateNode(TemplatingNode[BaseState, Json]):
+        template = "{{ data }}"
+        inputs = {
+            "data": {"key": "value"},
+        }
+
+    # WHEN the node is run
+    node = JSONTemplateNode()
+    outputs = node.run()
+
+    # THEN the output is the expected JSON
+    assert outputs.result == {"key": "value"}
+
+
+def test_templating_node__execution_count_reference():
+    # GIVEN a random node
+    class OtherNode(BaseNode):
+        pass
+
+    # AND a templating node that references the execution count of the random node
+    class TemplateNode(TemplatingNode):
+        template = "{{ total }}"
+        inputs = {
+            "total": OtherNode.Execution.count,
+        }
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN the output is just the total
+    assert outputs.result == "0"

{vellum_ai-0.12.8 → vellum_ai-0.12.9}/src/vellum/workflows/nodes/core/try_node/node.py

@@ -73,9 +73,7 @@ class TryNode(BaseNode[StateType], Generic[StateType], metaclass=_TryNodeMeta):
     def run(self) -> Iterator[BaseOutput]:
         subworkflow = self.subworkflow(
             parent_state=self.state,
-            context=WorkflowContext(
-                _vellum_client=self._context._vellum_client,
-            ),
+            context=WorkflowContext(vellum_client=self._context.vellum_client),
         )
         subworkflow_stream = subworkflow.stream(
             event_filter=all_workflow_event_filter,

{vellum_ai-0.12.8 → vellum_ai-0.12.9}/src/vellum/workflows/nodes/core/try_node/tests/test_node.py

@@ -103,7 +103,7 @@ def test_try_node__use_parent_execution_context():
     # WHEN the node is run with a custom vellum client
     node = TestNode(
         context=WorkflowContext(
-            _vellum_client=Vellum(api_key="test-key"),
+            vellum_client=Vellum(api_key="test-key"),
         )
     )
     outputs = list(node.run())

{vellum_ai-0.12.8 → vellum_ai-0.12.9}/src/vellum/workflows/nodes/displayable/bases/api_node/node.py

@@ -26,11 +26,11 @@ class BaseAPINode(BaseNode, Generic[StateType]):
     url: str
     method: APIRequestMethod
     data: Optional[str] = None
-    json: Optional["Json"] = None
+    json: Optional[Json] = None
     headers: Optional[Dict[str, Union[str, VellumSecret]]] = None
 
     class Outputs(BaseOutputs):
-        json: Optional["Json"]
+        json: Optional[Json]
         headers: Dict[str, str]
         status_code: int
         text: str

{vellum_ai-0.12.8 → vellum_ai-0.12.9}/src/vellum/workflows/nodes/displayable/bases/search_node.py

@@ -12,6 +12,7 @@ from vellum import (
     SearchWeightsRequest,
 )
 from vellum.core import ApiError, RequestOptions
+from vellum.utils.uuid import is_valid_uuid
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
@@ -73,11 +74,13 @@ class BaseSearchNode(BaseNode[StateType], Generic[StateType]):
         results: List[SearchResult]
 
     def _perform_search(self) -> SearchResponse:
+        index_is_uuid = True if isinstance(self.document_index, UUID) else is_valid_uuid(self.document_index)
+
         try:
             return self._context.vellum_client.search(
                 query=self.query,
-                index_id=str(self.document_index) if isinstance(self.document_index, UUID) else None,
-                index_name=self.document_index if isinstance(self.document_index, str) else None,
+                index_id=str(self.document_index) if index_is_uuid else None,
+                index_name=str(self.document_index) if not index_is_uuid else None,
                 options=self.options,
             )
         except NotFoundError:

{vellum_ai-0.12.8 → vellum_ai-0.12.9}/src/vellum/workflows/nodes/displayable/subworkflow_deployment_node/node.py

@@ -17,12 +17,13 @@ from vellum.workflows.context import get_parent_context
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.errors.types import workflow_event_error_to_workflow_error
 from vellum.workflows.exceptions import NodeException
-from vellum.workflows.nodes.bases.base_subworkflow_node.node import BaseSubworkflowNode
+from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.outputs.base import BaseOutput
+from vellum.workflows.types.core import EntityInputsInterface
 from vellum.workflows.types.generics import StateType
 
 
-class SubworkflowDeploymentNode(BaseSubworkflowNode[StateType], Generic[StateType]):
+class SubworkflowDeploymentNode(BaseNode[StateType], Generic[StateType]):
     """
     Used to execute a Workflow Deployment.
 
@@ -38,6 +39,7 @@ class SubworkflowDeploymentNode(BaseSubworkflowNode[StateType], Generic[StateTyp
 
     # Either the Workflow Deployment's UUID or its name.
     deployment: ClassVar[Union[UUID, str]]
+    subworkflow_inputs: ClassVar[EntityInputsInterface] = {}
 
     release_tag: str = LATEST_RELEASE_TAG
     external_id: Optional[str] = OMIT