vellum-ai 0.14.65__py3-none-any.whl → 0.14.67__py3-none-any.whl

vellum/client/types/document_read.py

@@ -32,7 +32,6 @@ class DocumentRead(UniversalBaseModel):
     """
 
     original_file_url: typing.Optional[str] = None
-    processed_file_url: typing.Optional[str] = None
     document_to_document_indexes: typing.List[DocumentDocumentToDocumentIndex]
     metadata: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = pydantic.Field(default=None)
     """

vellum/client/types/folder_entity_prompt_sandbox_data.py

@@ -14,6 +14,7 @@ class FolderEntityPromptSandboxData(UniversalBaseModel):
     created: dt.datetime
     modified: dt.datetime
     status: EntityStatus
+    description: typing.Optional[str] = None
     last_deployed_on: typing.Optional[dt.datetime] = None
 
     if IS_PYDANTIC_V2:

vellum/client/types/folder_entity_workflow_sandbox_data.py

@@ -14,6 +14,7 @@ class FolderEntityWorkflowSandboxData(UniversalBaseModel):
     created: dt.datetime
     modified: dt.datetime
     status: EntityStatus
+    description: typing.Optional[str] = None
     last_deployed_on: typing.Optional[dt.datetime] = None
 
     if IS_PYDANTIC_V2:

vellum/workflows/expressions/accessor.py

@@ -35,20 +35,37 @@ class AccessorExpression(BaseDescriptor[Any]):
             if isinstance(self._field, int):
                 raise InvalidExpressionException("Cannot access field by index on a dataclass")
 
-            return getattr(base, self._field)
+            try:
+                return getattr(base, self._field)
+            except AttributeError:
+                raise InvalidExpressionException(f"Field '{self._field}' not found on dataclass {type(base).__name__}")
 
         if isinstance(base, BaseModel):
             if isinstance(self._field, int):
                 raise InvalidExpressionException("Cannot access field by index on a BaseModel")
 
-            return getattr(base, self._field)
+            try:
+                return getattr(base, self._field)
+            except AttributeError:
+                raise InvalidExpressionException(f"Field '{self._field}' not found on BaseModel {type(base).__name__}")
 
         if isinstance(base, Mapping):
-            return base[self._field]
+            try:
+                return base[self._field]
+            except KeyError:
+                raise InvalidExpressionException(f"Key '{self._field}' not found in mapping")
 
         if isinstance(base, Sequence):
-            index = int(self._field)
-            return base[index]
+            try:
+                index = int(self._field)
+                return base[index]
+            except (IndexError, ValueError):
+                if isinstance(self._field, int) or (isinstance(self._field, str) and self._field.lstrip("-").isdigit()):
+                    raise InvalidExpressionException(
+                        f"Index {self._field} is out of bounds for sequence of length {len(base)}"
+                    )
+                else:
+                    raise InvalidExpressionException(f"Invalid index '{self._field}' for sequence access")
 
         raise InvalidExpressionException(f"Cannot get field {self._field} from {base}")
 

vellum/workflows/expressions/tests/test_accessor.py

@@ -0,0 +1,189 @@
+import pytest
+from dataclasses import dataclass
+
+from pydantic import BaseModel
+
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
+from vellum.workflows.expressions.accessor import AccessorExpression
+from vellum.workflows.references.constant import ConstantValueReference
+from vellum.workflows.state.base import BaseState
+
+
+@dataclass
+class TestDataclass:
+    name: str
+    value: int
+
+
+class TestBaseModel(BaseModel):
+    name: str
+    value: int
+
+
+class TestState(BaseState):
+    pass
+
+
+def test_accessor_expression_dict_valid_key():
+    state = TestState()
+    base_ref = ConstantValueReference({"name": "test", "value": 42})
+    accessor = AccessorExpression(base=base_ref, field="name")
+
+    result = accessor.resolve(state)
+
+    assert result == "test"
+
+
+def test_accessor_expression_dict_invalid_key():
+    state = TestState()
+    base_ref = ConstantValueReference({"name": "test", "value": 42})
+    accessor = AccessorExpression(base=base_ref, field="missing_key")
+
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        accessor.resolve(state)
+
+    assert "Key 'missing_key' not found in mapping" in str(exc_info.value)
+
+
+def test_accessor_expression_list_valid_index():
+    state = TestState()
+    base_ref = ConstantValueReference(["first", "second", "third"])
+    accessor = AccessorExpression(base=base_ref, field=1)
+
+    result = accessor.resolve(state)
+
+    assert result == "second"
+
+
+def test_accessor_expression_list_invalid_index():
+    state = TestState()
+    base_ref = ConstantValueReference(["first", "second"])
+    accessor = AccessorExpression(base=base_ref, field=5)
+
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        accessor.resolve(state)
+
+    assert "Index 5 is out of bounds for sequence of length 2" in str(exc_info.value)
+
+
+def test_accessor_expression_list_negative_index():
+    state = TestState()
+    base_ref = ConstantValueReference(["first", "second", "third"])
+    accessor = AccessorExpression(base=base_ref, field=-1)
+
+    result = accessor.resolve(state)
+
+    assert result == "third"
+
+
+def test_accessor_expression_list_invalid_negative_index():
+    state = TestState()
+    base_ref = ConstantValueReference(["first", "second"])
+    accessor = AccessorExpression(base=base_ref, field=-5)
+
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        accessor.resolve(state)
+
+    assert "Index -5 is out of bounds for sequence of length 2" in str(exc_info.value)
+
+
+def test_accessor_expression_list_string_index():
+    state = TestState()
+    base_ref = ConstantValueReference(["first", "second", "third"])
+    accessor = AccessorExpression(base=base_ref, field="1")
+
+    result = accessor.resolve(state)
+
+    assert result == "second"
+
+
+def test_accessor_expression_list_invalid_string_index():
+    state = TestState()
+    base_ref = ConstantValueReference(["first", "second"])
+    accessor = AccessorExpression(base=base_ref, field="invalid")
+
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        accessor.resolve(state)
+
+    assert "Invalid index 'invalid' for sequence access" in str(exc_info.value)
+
+
+def test_accessor_expression_dataclass_valid_field():
+    state = TestState()
+    test_obj = TestDataclass(name="test", value=42)
+    base_ref = ConstantValueReference(test_obj)
+    accessor = AccessorExpression(base=base_ref, field="name")
+
+    result = accessor.resolve(state)
+
+    assert result == "test"
+
+
+def test_accessor_expression_dataclass_invalid_field():
+    state = TestState()
+    test_obj = TestDataclass(name="test", value=42)
+    base_ref = ConstantValueReference(test_obj)
+    accessor = AccessorExpression(base=base_ref, field="missing_field")
+
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        accessor.resolve(state)
+
+    assert "Field 'missing_field' not found on dataclass TestDataclass" in str(exc_info.value)
+
+
+def test_accessor_expression_basemodel_valid_field():
+    state = TestState()
+    test_obj = TestBaseModel(name="test", value=42)
+    base_ref = ConstantValueReference(test_obj)
+    accessor = AccessorExpression(base=base_ref, field="name")
+
+    result = accessor.resolve(state)
+
+    assert result == "test"
+
+
+def test_accessor_expression_basemodel_invalid_field():
+    state = TestState()
+    test_obj = TestBaseModel(name="test", value=42)
+    base_ref = ConstantValueReference(test_obj)
+    accessor = AccessorExpression(base=base_ref, field="missing_field")
+
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        accessor.resolve(state)
+
+    assert "Field 'missing_field' not found on BaseModel TestBaseModel" in str(exc_info.value)
+
+
+def test_accessor_expression_dataclass_index_access():
+    state = TestState()
+    test_obj = TestDataclass(name="test", value=42)
+    base_ref = ConstantValueReference(test_obj)
+    accessor = AccessorExpression(base=base_ref, field=0)
+
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        accessor.resolve(state)
+
+    assert "Cannot access field by index on a dataclass" in str(exc_info.value)
+
+
+def test_accessor_expression_basemodel_index_access():
+    state = TestState()
+    test_obj = TestBaseModel(name="test", value=42)
+    base_ref = ConstantValueReference(test_obj)
+    accessor = AccessorExpression(base=base_ref, field=0)
+
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        accessor.resolve(state)
+
+    assert "Cannot access field by index on a BaseModel" in str(exc_info.value)
+
+
+def test_accessor_expression_unsupported_type():
+    state = TestState()
+    base_ref = ConstantValueReference(42)
+    accessor = AccessorExpression(base=base_ref, field="field")
+
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        accessor.resolve(state)
+
+    assert "Cannot get field field from 42" in str(exc_info.value)

vellum/workflows/nodes/bases/base.py

@@ -10,6 +10,7 @@ from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.utils import is_unresolved, resolve_value
 from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.events.node import NodeExecutionStreamingEvent
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.graph import Graph
 from vellum.workflows.graph.graph import GraphTarget
@@ -92,7 +93,7 @@ class BaseNodeMeta(ABCMeta):
                 if issubclass(base, BaseNode):
                     ports_dct = {p.name: Port(default=p.default) for p in base.Ports}
                     ports_dct["__module__"] = dct["__module__"]
-                    dct["Ports"] = type(f"{name}.Ports", (NodePorts,), ports_dct)
+                    dct["Ports"] = type(f"{name}.Ports", (base.Ports,), ports_dct)
                     break
 
         if "Execution" not in dct:
@@ -357,41 +358,15 @@ class BaseNode(Generic[StateType], ABC, metaclass=BaseNodeMeta):
                 state.meta.node_execution_cache._dependencies_invoked[execution_id].add(invoked_by)
                 return execution_id
 
-            # For AWAIT_ANY in workflows, we have two cases:
-            # 1. The node is being re-executed because of a fork
-            # 2. The node is being re-executed because of a loop
-            # For case 1, we need to remove the fork id from the node_to_fork_id mapping
-            # For case 2, we need to check if the node is in a loop
+            # For AWAIT_ANY in workflows, we need to detect if the node is in a loop
+            # If the node is in a loop, we can trigger the node again
             in_loop = False
-            # Default to true, will be set to false if the merged node has already been triggered
-            should_retrigger = True
             if cls.merge_behavior == MergeBehavior.AWAIT_ANY:
-                # Get the node that triggered the current execution
-                invoked_by_node = state.meta.node_execution_cache.__node_execution_lookup__.get(invoked_by)
-
-                # Check if invoked by node is a forked node
-                if invoked_by_node is not None:
-                    fork_id = state.meta.node_execution_cache.__node_to_fork_id__.get(invoked_by_node, None)
-                    if fork_id:
-                        # If the invoked by node has a fork id and that fork id is in __all_fork_ids__
-                        #   We will
-                        #   1. remove the fork id from __all_fork_ids__
-                        #   2. remove the fork id from the __node_to_fork_id__ mapping
-                        # else (this mean the fork has already been triggered)
-                        #   remove the id from the node_to_fork_id mapping and not retrigger again
-                        all_fork_ids = state.meta.node_execution_cache.__all_fork_ids__
-                        if fork_id in all_fork_ids:
-                            # When the next forked node merge, it will not trigger the node again
-                            # We should consider adding a lock here to prevent race condition
-                            all_fork_ids.remove(fork_id)
-                            state.meta.node_execution_cache.__node_to_fork_id__.pop(invoked_by_node, None)
-                        else:
-                            should_retrigger = False
-                            state.meta.node_execution_cache.__node_to_fork_id__.pop(invoked_by_node, None)
-
-                # If should_retrigger is false, then we will not trigger the node already
-                # So we don't need to check loop behavior
-                if should_retrigger:
+                # Get the latest fulfilled execution ID of current node
+                fulfilled_stack = state.meta.node_execution_cache._node_executions_fulfilled[cls.node_class]
+                current_latest_fulfilled_id = fulfilled_stack.peek() if not fulfilled_stack.is_empty() else None
+                # If the current node has not been fulfilled yet, we don't need to check for loop
+                if current_latest_fulfilled_id is not None:
                     # Trace back through the dependency chain to detect if this node triggers itself
                     visited = set()
                     current_execution_id = invoked_by
@@ -417,15 +392,18 @@ class BaseNode(Generic[StateType], ABC, metaclass=BaseNodeMeta):
                             current_execution_id
                         )
 
-                        # If we've found our target node class in the chain, we're in a loop
+                        # If we've found our target node class in the chain
                         if current_node_class == cls.node_class:
-                            in_loop = True
+                            # Check if the execution id is the same as the latest fulfilled execution id
+                            # If yes, we're in a loop
+                            if current_execution_id == current_latest_fulfilled_id:
+                                in_loop = True
+                            # If not, current node has been triggered by other node,
+                            # we can break out of the loop
                             break
 
             for queued_node_execution_id in state.meta.node_execution_cache._node_executions_queued[cls.node_class]:
-                # When should_retrigger is false, it means the merged node has already been triggered
-                # So we don't need to trigger the node again
-                if not should_retrigger or (
+                if (
                     invoked_by not in state.meta.node_execution_cache._dependencies_invoked[queued_node_execution_id]
                     and not in_loop
                 ):
@@ -509,3 +487,16 @@ class BaseNode(Generic[StateType], ABC, metaclass=BaseNodeMeta):
 
     def __repr__(self) -> str:
         return str(self.__class__)
+
+    __simulates_workflow_output__ = False
+
+    def __directly_emit_workflow_output__(
+        self, event: NodeExecutionStreamingEvent, workflow_output_descriptor: OutputReference
+    ) -> bool:
+        """
+        In the legacy workflow runner, there was support for emitting streaming workflow outputs for prompt nodes
+        connected to terminal nodes. These two private methods provides a hacky, intentionally short-lived workaround
+        for us to enable this until we can directly reference prompt outputs from the UI.
+        """
+
+        return False

vellum/workflows/nodes/bases/tests/test_base_node.py

@@ -1,6 +1,6 @@
 import pytest
 from uuid import UUID
-from typing import Optional
+from typing import Optional, Set
 
 from vellum.client.types.string_vellum_value_request import StringVellumValueRequest
 from vellum.core.pydantic_utilities import UniversalBaseModel
@@ -9,7 +9,9 @@ from vellum.workflows.descriptors.tests.test_utils import FixtureState
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes import FinalOutputNode
 from vellum.workflows.nodes.bases.base import BaseNode
-from vellum.workflows.outputs.base import BaseOutputs
+from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
+from vellum.workflows.ports.port import Port
+from vellum.workflows.references.constant import ConstantValueReference
 from vellum.workflows.references.node import NodeReference
 from vellum.workflows.references.output import OutputReference
 from vellum.workflows.state.base import BaseState, StateMeta
@@ -333,3 +335,47 @@ def test_base_node__node_reference_of_inherited_annotation():
     # THEN the node reference is of the correct type
     assert isinstance(node_reference, NodeReference)
     assert node_reference.name == "foo"
+
+
+def test_base_node__ports_inheritance():
+    # GIVEN a node with one port
+    class MyNode(BaseNode):
+        class Ports(BaseNode.Ports):
+            foo = Port.on_if(ConstantValueReference(True))
+
+            def __lt__(self, output: BaseOutput) -> Set[Port]:
+                return {self.foo}
+
+    # AND a node that inherits from MyNode
+    class InheritedNode(MyNode):
+        pass
+
+    # WHEN we collect the ports
+    ports = [port.name for port in InheritedNode.Ports]
+
+    # THEN the inheritance is correct
+    inherited_ports = InheritedNode.Ports()
+    assert inherited_ports.__lt__(BaseOutput(name="foo")) == {InheritedNode.Ports.foo}
+
+    # AND the ports are correct
+    assert ports == ["foo"]
+
+
+def test_base_node__ports_inheritance__cumulative_ports():
+    # GIVEN a node with one port
+    class MyNode(BaseNode):
+        class Ports(BaseNode.Ports):
+            foo = Port.on_if(ConstantValueReference(True))
+
+    # AND a node that inherits from MyNode with another port
+    class InheritedNode(MyNode):
+        class Ports(MyNode.Ports):
+            bar = Port.on_if(ConstantValueReference(True))
+
+    # WHEN we collect the ports
+    ports = [port.name for port in InheritedNode.Ports]
+
+    # THEN the ports are correct
+    # Potentially in the future, we support inheriting ports from multiple parents.
+    # For now, we take only the declared ports, so that not all nodes have the default port.
+    assert ports == ["bar"]

vellum/workflows/nodes/displayable/api_node/node.py

@@ -51,7 +51,9 @@ class APINode(BaseAPINode):
         final_headers = {**headers, **header_overrides}
 
         vellum_client_wrapper = self._context.vellum_client._client_wrapper
-        if self.url.startswith(vellum_client_wrapper._environment.default) and "X-API-Key" not in final_headers:
+        if self.url.startswith(vellum_client_wrapper._environment.default) and (
+            "X-API-Key" not in final_headers and "X_API_KEY" not in final_headers
+        ):
             final_headers["X-API-Key"] = vellum_client_wrapper.api_key
 
         return self._run(

vellum/workflows/nodes/displayable/api_node/tests/test_api_node.py

@@ -158,3 +158,35 @@ def test_api_node__detects_client_environment_urls__does_not_override_headers(
     # AND the vellum API should have been called with the correct headers
     assert mock_response.last_request
     assert mock_response.last_request.headers["X-API-Key"] == "vellum-api-key-5678"
+
+
+def test_api_node__detects_client_environment_urls__legacy_does_not_override_headers(
+    mock_httpx_transport, mock_requests, monkeypatch
+):
+    # GIVEN an API node with a URL pointing back to Vellum
+    class SimpleAPINodeToVellum(APINode):
+        url = "https://api.vellum.ai"
+        headers = {
+            "X_API_KEY": "vellum-api-key-5678",
+        }
+
+    # AND a mock request sent to the Vellum API would return a 200
+    mock_response = mock_requests.get(
+        "https://api.vellum.ai",
+        status_code=200,
+        json={"data": [1, 2, 3]},
+    )
+
+    # AND an api key is set
+    monkeypatch.setenv("VELLUM_API_KEY", "vellum-api-key-1234")
+
+    # WHEN we run the node
+    node = SimpleAPINodeToVellum()
+    node.run()
+
+    # THEN the execute_api method should not have been called
+    mock_httpx_transport.handle_request.assert_not_called()
+
+    # AND the vellum API should have been called with the correct headers
+    assert mock_response.last_request
+    assert mock_response.last_request.headers["X_API_KEY"] == "vellum-api-key-5678"

vellum/workflows/nodes/displayable/bases/base_prompt_node/node.py

@@ -5,9 +5,11 @@ from vellum import AdHocExecutePromptEvent, ExecutePromptEvent, PromptOutput
 from vellum.client.core.api_error import ApiError
 from vellum.core import RequestOptions
 from vellum.workflows.errors.types import WorkflowErrorCode, vellum_error_to_workflow_error
+from vellum.workflows.events.node import NodeExecutionStreamingEvent
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
+from vellum.workflows.references.output import OutputReference
 from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior
 from vellum.workflows.types.generics import StateType
 
@@ -85,3 +87,29 @@ class BasePromptNode(BaseNode, Generic[StateType]):
             message="Failed to execute Prompt",
             code=WorkflowErrorCode.INTERNAL_ERROR,
         ) from e
+
+    def __directly_emit_workflow_output__(
+        self,
+        event: NodeExecutionStreamingEvent,
+        workflow_output_descriptor: OutputReference,
+    ) -> bool:
+        if event.output.name != "results":
+            return False
+
+        if not isinstance(event.output.delta, str) and not event.output.is_initiated:
+            return False
+
+        target_nodes = [e.to_node for e in self.Ports.default.edges if e.to_node.__simulates_workflow_output__]
+        target_node_output = next(
+            (
+                o
+                for target_node in target_nodes
+                for o in target_node.Outputs
+                if o == workflow_output_descriptor.instance
+            ),
+            None,
+        )
+        if not target_node_output:
+            return False
+
+        return True

vellum/workflows/nodes/displayable/bases/inline_prompt_node/tests/test_inline_prompt_node.py

@@ -192,7 +192,30 @@ def test_validation_with_extra_variables(vellum_adhoc_prompt_client):
     ]
 
 
-def test_inline_prompt_node__json_output(vellum_adhoc_prompt_client):
+@pytest.mark.parametrize(
+    "custom_parameters,test_description",
+    [
+        (
+            {
+                "json_mode": False,
+                "json_schema": {
+                    "name": "get_result",
+                    "schema": {
+                        "type": "object",
+                        "required": ["result"],
+                        "properties": {"result": {"type": "string", "description": ""}},
+                    },
+                },
+            },
+            "with json_schema configured",
+        ),
+        (
+            {},
+            "without json_mode or json_schema configured",
+        ),
+    ],
+)
+def test_inline_prompt_node__json_output(vellum_adhoc_prompt_client, custom_parameters, test_description):
     """Confirm that InlinePromptNodes output the expected JSON when run."""
 
     # GIVEN a node that subclasses InlinePromptNode
@@ -214,17 +237,7 @@ def test_inline_prompt_node__json_output(vellum_adhoc_prompt_client):
             frequency_penalty=0.0,
             presence_penalty=0.0,
             logit_bias=None,
-            custom_parameters={
-                "json_mode": False,
-                "json_schema": {
-                    "name": "get_result",
-                    "schema": {
-                        "type": "object",
-                        "required": ["result"],
-                        "properties": {"result": {"type": "string", "description": ""}},
-                    },
-                },
-            },
+            custom_parameters=custom_parameters,
         )
 
     # AND a known JSON response from invoking an inline prompt
@@ -284,17 +297,7 @@ def test_inline_prompt_node__json_output(vellum_adhoc_prompt_client):
             frequency_penalty=0.0,
             presence_penalty=0.0,
             logit_bias=None,
-            custom_parameters={
-                "json_mode": False,
-                "json_schema": {
-                    "name": "get_result",
-                    "schema": {
-                        "type": "object",
-                        "required": ["result"],
-                        "properties": {"result": {"type": "string", "description": ""}},
-                    },
-                },
-            },
+            custom_parameters=custom_parameters,
         ),
         request_options=mock.ANY,
         settings=None,

vellum/workflows/nodes/displayable/conditional_node/node.py

@@ -2,7 +2,6 @@ from typing import Set
 
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.outputs.base import BaseOutputs
-from vellum.workflows.ports.node_ports import NodePorts
 from vellum.workflows.ports.port import Port
 from vellum.workflows.ports.utils import validate_ports
 from vellum.workflows.state.base import BaseState
@@ -18,7 +17,7 @@ class ConditionalNode(BaseNode):
     class Trigger(BaseNode.Trigger):
         merge_behavior = MergeBehavior.AWAIT_ANY
 
-    class Ports(NodePorts):
+    class Ports(BaseNode.Ports):
         def __call__(self, outputs: BaseOutputs, state: BaseState) -> Set[Port]:
             all_ports = [port for port in self.__class__]
             enforce_single_invoked_port = validate_ports(all_ports)

vellum/workflows/nodes/displayable/final_output_node/node.py

@@ -61,3 +61,5 @@ class FinalOutputNode(BaseNode[StateType], Generic[StateType, _OutputType], meta
                 self.__class__.get_output_type(),
             )
         )
+
+    __simulates_workflow_output__ = True

vellum/workflows/nodes/displayable/inline_prompt_node/node.py

@@ -48,26 +48,16 @@ class InlinePromptNode(BaseInlinePromptNode[StateType]):
         string_outputs = []
         json_output = None
 
-        should_parse_json = False
-        if hasattr(self, "parameters"):
-            custom_params = self.parameters.custom_parameters
-            if custom_params and isinstance(custom_params, dict):
-                json_schema = custom_params.get("json_schema", {})
-                if (isinstance(json_schema, dict) and "schema" in json_schema) or custom_params.get("json_mode", {}):
-                    should_parse_json = True
-
         for output in outputs:
             if output.value is None:
                 continue
 
             if output.type == "STRING":
                 string_outputs.append(output.value)
-                if should_parse_json:
-                    try:
-                        parsed_json = json.loads(output.value)
-                        json_output = parsed_json
-                    except (json.JSONDecodeError, TypeError):
-                        pass
+                try:
+                    json_output = json.loads(output.value)
+                except (json.JSONDecodeError, TypeError):
+                    pass
             elif output.type == "JSON":
                 string_outputs.append(json.dumps(output.value, indent=4))
                 json_output = output.value

vellum/workflows/nodes/displayable/search_node/node.py

@@ -1,6 +1,8 @@
 import json
 from typing import ClassVar
 
+from vellum.workflows.errors import WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.bases import BaseSearchNode as BaseSearchNode
 from vellum.workflows.state.encoder import DefaultStateEncoder
 from vellum.workflows.types import MergeBehavior
@@ -35,6 +37,12 @@ class SearchNode(BaseSearchNode[StateType]):
         text: str
 
     def run(self) -> Outputs:
+        if self.query is None or self.query == "":
+            raise NodeException(
+                message="Search query is required but was not provided",
+                code=WorkflowErrorCode.INVALID_INPUTS,
+            )
+
         if not isinstance(self.query, str):
             self.query = json.dumps(self.query, cls=DefaultStateEncoder)