vellum-ai 0.12.8__py3-none-any.whl → 0.12.11__py3-none-any.whl

vellum/__init__.py

@@ -120,7 +120,6 @@ from .types import (
     FolderEntityWorkflowSandbox,
     FolderEntityWorkflowSandboxData,
     FulfilledAdHocExecutePromptEvent,
-    FulfilledEnum,
     FulfilledExecutePromptEvent,
     FulfilledExecutePromptResponse,
     FulfilledExecuteWorkflowWorkflowResultEvent,
@@ -389,6 +388,7 @@ from .types import (
     TestSuiteRunExternalExecConfigData,
     TestSuiteRunExternalExecConfigDataRequest,
     TestSuiteRunExternalExecConfigRequest,
+    TestSuiteRunMetricArrayOutput,
     TestSuiteRunMetricErrorOutput,
     TestSuiteRunMetricJsonOutput,
     TestSuiteRunMetricNumberOutput,
@@ -649,7 +649,6 @@ __all__ = [
     "FolderEntityWorkflowSandboxData",
     "ForbiddenError",
     "FulfilledAdHocExecutePromptEvent",
-    "FulfilledEnum",
     "FulfilledExecutePromptEvent",
     "FulfilledExecutePromptResponse",
     "FulfilledExecuteWorkflowWorkflowResultEvent",
@@ -922,6 +921,7 @@ __all__ = [
     "TestSuiteRunExternalExecConfigData",
     "TestSuiteRunExternalExecConfigDataRequest",
     "TestSuiteRunExternalExecConfigRequest",
+    "TestSuiteRunMetricArrayOutput",
     "TestSuiteRunMetricErrorOutput",
     "TestSuiteRunMetricJsonOutput",
     "TestSuiteRunMetricNumberOutput",

vellum/client/__init__.py

@@ -1079,6 +1079,7 @@ class Vellum:
         index_id: typing.Optional[str] = OMIT,
         index_name: typing.Optional[str] = OMIT,
         options: typing.Optional[SearchRequestOptionsRequest] = OMIT,
+        document_index: typing.Optional[str] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
     ) -> SearchResponse:
         """
@@ -1090,14 +1091,17 @@ class Vellum:
             The query to search for.
 
         index_id : typing.Optional[str]
-            The ID of the index to search against. Must provide either this or index_name.
+            The ID of the index to search against. Must provide either this, index_name or document_index.
 
         index_name : typing.Optional[str]
-            The name of the index to search against. Must provide either this or index_id.
+            The name of the index to search against. Must provide either this, index_id or document_index.
 
         options : typing.Optional[SearchRequestOptionsRequest]
             Configuration options for the search.
 
+        document_index : typing.Optional[str]
+            Either the index name or index ID to search against. Must provide either this, index_id or index_name.
+
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
@@ -1128,6 +1132,7 @@ class Vellum:
                 "options": convert_and_respect_annotation_metadata(
                     object_=options, annotation=SearchRequestOptionsRequest, direction="write"
                 ),
+                "document_index": document_index,
             },
             request_options=request_options,
             omit=OMIT,
@@ -2395,6 +2400,7 @@ class AsyncVellum:
         index_id: typing.Optional[str] = OMIT,
         index_name: typing.Optional[str] = OMIT,
         options: typing.Optional[SearchRequestOptionsRequest] = OMIT,
+        document_index: typing.Optional[str] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
     ) -> SearchResponse:
         """
@@ -2406,14 +2412,17 @@ class AsyncVellum:
             The query to search for.
 
         index_id : typing.Optional[str]
-            The ID of the index to search against. Must provide either this or index_name.
+            The ID of the index to search against. Must provide either this, index_name or document_index.
 
         index_name : typing.Optional[str]
-            The name of the index to search against. Must provide either this or index_id.
+            The name of the index to search against. Must provide either this, index_id or document_index.
 
         options : typing.Optional[SearchRequestOptionsRequest]
             Configuration options for the search.
 
+        document_index : typing.Optional[str]
+            Either the index name or index ID to search against. Must provide either this, index_id or index_name.
+
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
@@ -2452,6 +2461,7 @@ class AsyncVellum:
                 "options": convert_and_respect_annotation_metadata(
                     object_=options, annotation=SearchRequestOptionsRequest, direction="write"
                 ),
+                "document_index": document_index,
             },
             request_options=request_options,
             omit=OMIT,

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.11",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

vellum/client/types/__init__.py

@@ -127,7 +127,6 @@ from .folder_entity_test_suite_data import FolderEntityTestSuiteData
 from .folder_entity_workflow_sandbox import FolderEntityWorkflowSandbox
 from .folder_entity_workflow_sandbox_data import FolderEntityWorkflowSandboxData
 from .fulfilled_ad_hoc_execute_prompt_event import FulfilledAdHocExecutePromptEvent
-from .fulfilled_enum import FulfilledEnum
 from .fulfilled_execute_prompt_event import FulfilledExecutePromptEvent
 from .fulfilled_execute_prompt_response import FulfilledExecutePromptResponse
 from .fulfilled_execute_workflow_workflow_result_event import FulfilledExecuteWorkflowWorkflowResultEvent
@@ -402,6 +401,7 @@ from .test_suite_run_external_exec_config import TestSuiteRunExternalExecConfig
 from .test_suite_run_external_exec_config_data import TestSuiteRunExternalExecConfigData
 from .test_suite_run_external_exec_config_data_request import TestSuiteRunExternalExecConfigDataRequest
 from .test_suite_run_external_exec_config_request import TestSuiteRunExternalExecConfigRequest
+from .test_suite_run_metric_array_output import TestSuiteRunMetricArrayOutput
 from .test_suite_run_metric_error_output import TestSuiteRunMetricErrorOutput
 from .test_suite_run_metric_json_output import TestSuiteRunMetricJsonOutput
 from .test_suite_run_metric_number_output import TestSuiteRunMetricNumberOutput
@@ -641,7 +641,6 @@ __all__ = [
     "FolderEntityWorkflowSandbox",
     "FolderEntityWorkflowSandboxData",
     "FulfilledAdHocExecutePromptEvent",
-    "FulfilledEnum",
     "FulfilledExecutePromptEvent",
     "FulfilledExecutePromptResponse",
     "FulfilledExecuteWorkflowWorkflowResultEvent",
@@ -910,6 +909,7 @@ __all__ = [
     "TestSuiteRunExternalExecConfigData",
     "TestSuiteRunExternalExecConfigDataRequest",
     "TestSuiteRunExternalExecConfigRequest",
+    "TestSuiteRunMetricArrayOutput",
     "TestSuiteRunMetricErrorOutput",
     "TestSuiteRunMetricJsonOutput",
     "TestSuiteRunMetricNumberOutput",

vellum/client/types/function_call.py

@@ -2,7 +2,6 @@
 
 from ..core.pydantic_utilities import UniversalBaseModel
 import typing
-from .fulfilled_enum import FulfilledEnum
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import pydantic
 
@@ -15,7 +14,6 @@ class FunctionCall(UniversalBaseModel):
     arguments: typing.Dict[str, typing.Optional[typing.Any]]
     id: typing.Optional[str] = None
     name: str
-    state: typing.Optional[FulfilledEnum] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

vellum/client/types/function_call_request.py

@@ -2,7 +2,6 @@
 
 from ..core.pydantic_utilities import UniversalBaseModel
 import typing
-from .fulfilled_enum import FulfilledEnum
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import pydantic
 
@@ -15,7 +14,6 @@ class FunctionCallRequest(UniversalBaseModel):
     arguments: typing.Dict[str, typing.Optional[typing.Any]]
     id: typing.Optional[str] = None
     name: str
-    state: typing.Optional[FulfilledEnum] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

vellum/client/types/metric_definition_execution.py

@@ -1,10 +1,13 @@
 # This file was auto-generated by Fern from our API Definition.
 
+from __future__ import annotations
 from ..core.pydantic_utilities import UniversalBaseModel
+from .array_vellum_value import ArrayVellumValue
 import typing
 from .test_suite_run_metric_output import TestSuiteRunMetricOutput
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import pydantic
+from ..core.pydantic_utilities import update_forward_refs
 
 
 class MetricDefinitionExecution(UniversalBaseModel):
@@ -18,3 +21,6 @@ class MetricDefinitionExecution(UniversalBaseModel):
             frozen = True
             smart_union = True
             extra = pydantic.Extra.allow
+
+
+update_forward_refs(ArrayVellumValue, MetricDefinitionExecution=MetricDefinitionExecution)

vellum/client/types/test_suite_run_execution_metric_result.py

@@ -1,11 +1,14 @@
 # This file was auto-generated by Fern from our API Definition.
 
+from __future__ import annotations
 from ..core.pydantic_utilities import UniversalBaseModel
+from .array_vellum_value import ArrayVellumValue
 import typing
 from .test_suite_run_metric_output import TestSuiteRunMetricOutput
 from .test_suite_run_execution_metric_definition import TestSuiteRunExecutionMetricDefinition
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import pydantic
+from ..core.pydantic_utilities import update_forward_refs
 
 
 class TestSuiteRunExecutionMetricResult(UniversalBaseModel):
@@ -22,3 +25,6 @@ class TestSuiteRunExecutionMetricResult(UniversalBaseModel):
             frozen = True
             smart_union = True
             extra = pydantic.Extra.allow
+
+
+update_forward_refs(ArrayVellumValue, TestSuiteRunExecutionMetricResult=TestSuiteRunExecutionMetricResult)

vellum/client/types/test_suite_run_metric_array_output.py

@@ -0,0 +1,32 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from __future__ import annotations
+from ..core.pydantic_utilities import UniversalBaseModel
+from .array_vellum_value import ArrayVellumValue
+import typing
+from .vellum_value import VellumValue
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
+from ..core.pydantic_utilities import update_forward_refs
+
+
+class TestSuiteRunMetricArrayOutput(UniversalBaseModel):
+    """
+    Output for a test suite run metric that is of type ARRAY
+    """
+
+    value: typing.Optional[typing.List[VellumValue]] = None
+    type: typing.Literal["ARRAY"] = "ARRAY"
+    name: str
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow
+
+
+update_forward_refs(ArrayVellumValue, TestSuiteRunMetricArrayOutput=TestSuiteRunMetricArrayOutput)

vellum/client/types/test_suite_run_metric_output.py

@@ -5,10 +5,12 @@ from .test_suite_run_metric_string_output import TestSuiteRunMetricStringOutput
 from .test_suite_run_metric_number_output import TestSuiteRunMetricNumberOutput
 from .test_suite_run_metric_json_output import TestSuiteRunMetricJsonOutput
 from .test_suite_run_metric_error_output import TestSuiteRunMetricErrorOutput
+from .test_suite_run_metric_array_output import TestSuiteRunMetricArrayOutput
 
 TestSuiteRunMetricOutput = typing.Union[
     TestSuiteRunMetricStringOutput,
     TestSuiteRunMetricNumberOutput,
     TestSuiteRunMetricJsonOutput,
     TestSuiteRunMetricErrorOutput,
+    TestSuiteRunMetricArrayOutput,
 ]

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/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/types/{fulfilled_enum.py → test_suite_run_metric_array_output.py}

@@ -1,3 +1,3 @@
 # WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
 
-from vellum.client.types.fulfilled_enum import *
+from vellum.client.types.test_suite_run_metric_array_output import *

vellum/workflows/nodes/bases/__init__.py

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

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/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/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/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/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/workflows/nodes/core/templating_node/tests/test_templating_node.py

@@ -2,6 +2,8 @@ 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():
@@ -22,6 +24,70 @@ def test_templating_node__dict_output():
     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):

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/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/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/workflows/nodes/displayable/bases/search_node.py

@@ -76,8 +76,7 @@ class BaseSearchNode(BaseNode[StateType], Generic[StateType]):
         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,
+                document_index=str(self.document_index),
                 options=self.options,
             )
         except NotFoundError:

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

@@ -1,3 +1,4 @@
+import json
 from typing import Iterator
 
 from vellum.workflows.errors import WorkflowErrorCode
@@ -37,13 +38,19 @@ class InlinePromptNode(BaseInlinePromptNode[StateType]):
                 code=WorkflowErrorCode.INTERNAL_ERROR,
             )
 
-        string_output = next((output for output in outputs if output.type == "STRING"), None)
-        if not string_output or string_output.value is None:
-            output_types = {output.type for output in outputs}
-            is_plural = len(output_types) > 1
-            raise NodeException(
-                message=f"Expected to receive a non-null string output from Prompt. Only found outputs of type{'s' if is_plural else ''}: {', '.join(output_types)}",  # noqa: E501
-                code=WorkflowErrorCode.INTERNAL_ERROR,
-            )
-
-        yield BaseOutput(name="text", value=string_output.value)
+        string_outputs = []
+        for output in outputs:
+            if output.value is None:
+                continue
+
+            if output.type == "STRING":
+                string_outputs.append(output.value)
+            elif output.type == "JSON":
+                string_outputs.append(json.dumps(output.value, indent=4))
+            elif output.type == "FUNCTION_CALL":
+                string_outputs.append(output.value.model_dump_json(indent=4))
+            else:
+                string_outputs.append(output.value.message)
+
+        value = "\n".join(string_outputs)
+        yield BaseOutput(name="text", value=value)