vellum-ai 0.14.53__py3-none-any.whl → 0.14.55__py3-none-any.whl

vellum/client/resources/release_reviews/client.py

@@ -3,12 +3,11 @@
 from ...core.client_wrapper import SyncClientWrapper
 import typing
 from ...core.request_options import RequestOptions
-from ...types.prompt_deployment_release import PromptDeploymentRelease
+from ...types.workflow_deployment_release import WorkflowDeploymentRelease
 from ...core.jsonable_encoder import jsonable_encoder
 from ...core.pydantic_utilities import parse_obj_as
 from json.decoder import JSONDecodeError
 from ...core.api_error import ApiError
-from ...types.workflow_deployment_release import WorkflowDeploymentRelease
 from ...core.client_wrapper import AsyncClientWrapper
 
 
@@ -16,60 +15,6 @@ class ReleaseReviewsClient:
     def __init__(self, *, client_wrapper: SyncClientWrapper):
         self._client_wrapper = client_wrapper
 
-    def retrieve_prompt_deployment_release(
-        self, id: str, release_id_or_release_tag: str, *, request_options: typing.Optional[RequestOptions] = None
-    ) -> PromptDeploymentRelease:
-        """
-        Retrieve a specific Prompt Deployment Release by either its UUID or the name of a Release Tag that points to it.
-
-        Parameters
-        ----------
-        id : str
-            A UUID string identifying this deployment.
-
-        release_id_or_release_tag : str
-            Either the UUID of Prompt Deployment Release you'd like to retrieve, or the name of a Release Tag that's pointing to the Prompt Deployment Release you'd like to retrieve.
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        PromptDeploymentRelease
-
-
-        Examples
-        --------
-        from vellum import Vellum
-
-        client = Vellum(
-            api_key="YOUR_API_KEY",
-        )
-        client.release_reviews.retrieve_prompt_deployment_release(
-            id="id",
-            release_id_or_release_tag="release_id_or_release_tag",
-        )
-        """
-        _response = self._client_wrapper.httpx_client.request(
-            f"v1/deployments/{jsonable_encoder(id)}/releases/{jsonable_encoder(release_id_or_release_tag)}",
-            base_url=self._client_wrapper.get_environment().default,
-            method="GET",
-            request_options=request_options,
-        )
-        try:
-            if 200 <= _response.status_code < 300:
-                return typing.cast(
-                    PromptDeploymentRelease,
-                    parse_obj_as(
-                        type_=PromptDeploymentRelease,  # type: ignore
-                        object_=_response.json(),
-                    ),
-                )
-            _response_json = _response.json()
-        except JSONDecodeError:
-            raise ApiError(status_code=_response.status_code, body=_response.text)
-        raise ApiError(status_code=_response.status_code, body=_response_json)
-
     def retrieve_workflow_deployment_release(
         self, id: str, release_id_or_release_tag: str, *, request_options: typing.Optional[RequestOptions] = None
     ) -> WorkflowDeploymentRelease:
@@ -129,68 +74,6 @@ class AsyncReleaseReviewsClient:
     def __init__(self, *, client_wrapper: AsyncClientWrapper):
         self._client_wrapper = client_wrapper
 
-    async def retrieve_prompt_deployment_release(
-        self, id: str, release_id_or_release_tag: str, *, request_options: typing.Optional[RequestOptions] = None
-    ) -> PromptDeploymentRelease:
-        """
-        Retrieve a specific Prompt Deployment Release by either its UUID or the name of a Release Tag that points to it.
-
-        Parameters
-        ----------
-        id : str
-            A UUID string identifying this deployment.
-
-        release_id_or_release_tag : str
-            Either the UUID of Prompt Deployment Release you'd like to retrieve, or the name of a Release Tag that's pointing to the Prompt Deployment Release you'd like to retrieve.
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        PromptDeploymentRelease
-
-
-        Examples
-        --------
-        import asyncio
-
-        from vellum import AsyncVellum
-
-        client = AsyncVellum(
-            api_key="YOUR_API_KEY",
-        )
-
-
-        async def main() -> None:
-            await client.release_reviews.retrieve_prompt_deployment_release(
-                id="id",
-                release_id_or_release_tag="release_id_or_release_tag",
-            )
-
-
-        asyncio.run(main())
-        """
-        _response = await self._client_wrapper.httpx_client.request(
-            f"v1/deployments/{jsonable_encoder(id)}/releases/{jsonable_encoder(release_id_or_release_tag)}",
-            base_url=self._client_wrapper.get_environment().default,
-            method="GET",
-            request_options=request_options,
-        )
-        try:
-            if 200 <= _response.status_code < 300:
-                return typing.cast(
-                    PromptDeploymentRelease,
-                    parse_obj_as(
-                        type_=PromptDeploymentRelease,  # type: ignore
-                        object_=_response.json(),
-                    ),
-                )
-            _response_json = _response.json()
-        except JSONDecodeError:
-            raise ApiError(status_code=_response.status_code, body=_response.text)
-        raise ApiError(status_code=_response.status_code, body=_response_json)
-
     async def retrieve_workflow_deployment_release(
         self, id: str, release_id_or_release_tag: str, *, request_options: typing.Optional[RequestOptions] = None
     ) -> WorkflowDeploymentRelease:

vellum/client/resources/workflow_deployments/client.py

@@ -263,7 +263,8 @@ class WorkflowDeploymentsClient:
         self, history_id_or_release_tag: str, id: str, *, request_options: typing.Optional[RequestOptions] = None
     ) -> WorkflowDeploymentHistoryItem:
         """
-        Retrieve a specific Workflow Deployment History Item by either its UUID or the name of a Release Tag that points to it.
+        DEPRECATED: This endpoint is deprecated and will be removed in a future release. Please use the
+        `retrieve_workflow_deployment_release` endpoint instead.
 
         Parameters
         ----------
@@ -786,7 +787,8 @@ class AsyncWorkflowDeploymentsClient:
         self, history_id_or_release_tag: str, id: str, *, request_options: typing.Optional[RequestOptions] = None
     ) -> WorkflowDeploymentHistoryItem:
         """
-        Retrieve a specific Workflow Deployment History Item by either its UUID or the name of a Release Tag that points to it.
+        DEPRECATED: This endpoint is deprecated and will be removed in a future release. Please use the
+        `retrieve_workflow_deployment_release` endpoint instead.
 
         Parameters
         ----------

vellum/client/types/__init__.py

@@ -69,6 +69,7 @@ from .compile_prompt_deployment_expand_meta_request import CompilePromptDeployme
 from .compile_prompt_meta import CompilePromptMeta
 from .components_schemas_pdf_search_result_meta_source import ComponentsSchemasPdfSearchResultMetaSource
 from .components_schemas_pdf_search_result_meta_source_request import ComponentsSchemasPdfSearchResultMetaSourceRequest
+from .components_schemas_prompt_version_build_config_sandbox import ComponentsSchemasPromptVersionBuildConfigSandbox
 from .condition_combinator import ConditionCombinator
 from .conditional_node_result import ConditionalNodeResult
 from .conditional_node_result_data import ConditionalNodeResultData
@@ -324,6 +325,7 @@ from .prompt_request_input import PromptRequestInput
 from .prompt_request_json_input import PromptRequestJsonInput
 from .prompt_request_string_input import PromptRequestStringInput
 from .prompt_settings import PromptSettings
+from .prompt_version_build_config_sandbox import PromptVersionBuildConfigSandbox
 from .raw_prompt_execution_overrides_request import RawPromptExecutionOverridesRequest
 from .reducto_chunker_config import ReductoChunkerConfig
 from .reducto_chunker_config_request import ReductoChunkerConfigRequest
@@ -677,6 +679,7 @@ __all__ = [
     "CompilePromptMeta",
     "ComponentsSchemasPdfSearchResultMetaSource",
     "ComponentsSchemasPdfSearchResultMetaSourceRequest",
+    "ComponentsSchemasPromptVersionBuildConfigSandbox",
     "ConditionCombinator",
     "ConditionalNodeResult",
     "ConditionalNodeResultData",
@@ -928,6 +931,7 @@ __all__ = [
     "PromptRequestJsonInput",
     "PromptRequestStringInput",
     "PromptSettings",
+    "PromptVersionBuildConfigSandbox",
     "RawPromptExecutionOverridesRequest",
     "ReductoChunkerConfig",
     "ReductoChunkerConfigRequest",

vellum/client/types/components_schemas_prompt_version_build_config_sandbox.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .prompt_version_build_config_sandbox import PromptVersionBuildConfigSandbox
+
+ComponentsSchemasPromptVersionBuildConfigSandbox = PromptVersionBuildConfigSandbox

vellum/client/types/execute_api_request_body.py

@@ -2,4 +2,6 @@
 
 import typing
 
-ExecuteApiRequestBody = typing.Union[str, typing.Dict[str, typing.Optional[typing.Any]]]
+ExecuteApiRequestBody = typing.Union[
+    str, typing.List[typing.Optional[typing.Any]], typing.Dict[str, typing.Optional[typing.Any]]
+]

vellum/client/types/prompt_deployment_release_prompt_version.py

@@ -1,13 +1,18 @@
 # This file was auto-generated by Fern from our API Definition.
 
 from ..core.pydantic_utilities import UniversalBaseModel
+from .components_schemas_prompt_version_build_config_sandbox import ComponentsSchemasPromptVersionBuildConfigSandbox
+import pydantic
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import typing
-import pydantic
 
 
 class PromptDeploymentReleasePromptVersion(UniversalBaseModel):
     id: str
+    build_config: ComponentsSchemasPromptVersionBuildConfigSandbox = pydantic.Field()
+    """
+    Configuration used to build this prompt version.
+    """
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

vellum/client/types/prompt_version_build_config_sandbox.py

@@ -0,0 +1,22 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
+
+
+class PromptVersionBuildConfigSandbox(UniversalBaseModel):
+    source: typing.Literal["SANDBOX"] = "SANDBOX"
+    sandbox_id: str
+    sandbox_snapshot_id: str
+    prompt_id: 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

vellum/types/components_schemas_prompt_version_build_config_sandbox.py

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

vellum/types/prompt_version_build_config_sandbox.py

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

vellum/workflows/nodes/bases/base.py

@@ -2,12 +2,13 @@ from dataclasses import field
 from functools import cached_property, reduce
 import inspect
 from types import MappingProxyType
-from uuid import UUID
+from uuid import UUID, uuid4
 from typing import Any, Dict, Generic, Iterator, Optional, Set, Tuple, Type, TypeVar, Union, cast, get_args
 
 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.edges.edge import Edge
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.graph import Graph
@@ -325,6 +326,36 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
                 code=WorkflowErrorCode.INVALID_INPUTS,
             )
 
+        @classmethod
+        def _queue_node_execution(
+            cls, state: StateType, dependencies: Set["Type[BaseNode]"], invoked_by: Optional[Edge] = None
+        ) -> UUID:
+            """
+            Queues a future execution of a node, returning the span id of the execution.
+
+            We may combine this into the should_initiate method, but we'll keep it separate for now to avoid
+            breaking changes until the 0.15.0 release.
+            """
+
+            execution_id = uuid4()
+            if not invoked_by:
+                return execution_id
+
+            if cls.merge_behavior not in {MergeBehavior.AWAIT_ANY, MergeBehavior.AWAIT_ALL}:
+                return execution_id
+
+            source_node = invoked_by.from_port.node_class
+            for queued_node_execution_id in state.meta.node_execution_cache._node_executions_queued[cls.node_class]:
+                if source_node not in state.meta.node_execution_cache._dependencies_invoked[queued_node_execution_id]:
+                    state.meta.node_execution_cache._invoke_dependency(
+                        queued_node_execution_id, cls.node_class, source_node, dependencies
+                    )
+                    return queued_node_execution_id
+
+            state.meta.node_execution_cache._node_executions_queued[cls.node_class].append(execution_id)
+            state.meta.node_execution_cache._invoke_dependency(execution_id, cls.node_class, source_node, dependencies)
+            return execution_id
+
     class Execution(metaclass=_BaseNodeExecutionMeta):
         node_class: Type["BaseNode"]
         count: int

vellum/workflows/nodes/displayable/code_execution_node/tests/{test_code_execution_node.py → test_node.py}

@@ -882,44 +882,68 @@ def main(arg1: list) -> str:
     assert outputs == {"result": "bar", "log": ""}
 
 
-def test_run_node__string_value_wrapper__get_attr():
-    # GIVEN a node that accesses the 'value' property of a string input
-    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, str]):
-        code = """\
+@pytest.mark.parametrize(
+    "code_snippet",
+    [
+        """
 def main(text: str) -> str:
     return text.value
-"""
+""",
+        """
+def main(text: str) -> str:
+    return text["value"]
+""",
+    ],
+)
+def test_run_node__string_value_wrapper_value(code_snippet):
+    """Test string value wrapper value access using different patterns"""
+
+    # GIVEN a node that accesses the 'value' property of a string input
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, str]):
+        code = code_snippet
+        runtime = "PYTHON_3_11_6"
         code_inputs = {
             "text": "hello",
         }
-        runtime = "PYTHON_3_11_6"
 
     # WHEN we run the node
     node = ExampleCodeExecutionNode()
     outputs = node.run()
 
-    # THEN the node should successfully access the string value through the .value property
+    # THEN the node should successfully access the string value
     assert outputs == {"result": "hello", "log": ""}
 
 
-def test_run_node__string_value_wrapper__get_item():
-    # GIVEN a node that accesses the 'value' property of a string input
-    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, str]):
-        code = """\
+@pytest.mark.parametrize(
+    "code_snippet",
+    [
+        """
 def main(text: str) -> str:
-    return text["value"]
-"""
+    return text.type
+""",
+        """
+def main(text: str) -> str:
+    return text["type"]
+""",
+    ],
+)
+def test_run_node__string_value_wrapper_type(code_snippet):
+    """Test string value wrapper type access using different patterns"""
+
+    # GIVEN a node that will return the string type
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, str]):
+        code = code_snippet
+        runtime = "PYTHON_3_11_6"
         code_inputs = {
             "text": "hello",
         }
-        runtime = "PYTHON_3_11_6"
 
     # WHEN we run the node
     node = ExampleCodeExecutionNode()
     outputs = node.run()
 
-    # THEN the node should successfully access the string value through the .value property
-    assert outputs == {"result": "hello", "log": ""}
+    # THEN the node should successfully return the string type
+    assert outputs == {"result": "STRING", "log": ""}
 
 
 def test_run_node__string_value_wrapper__list_of_dicts():
@@ -962,6 +986,87 @@ def main(input: str) -> str:
     assert outputs == {"result": "h", "log": ""}
 
 
+@pytest.mark.parametrize(
+    "code_snippet",
+    [
+        """
+from vellum.client.types.function_call import FunctionCall
+def main(input: FunctionCall) -> FunctionCall:
+    return input.value
+""",
+        """
+from vellum.client.types.function_call import FunctionCall
+def main(input: FunctionCall) -> FunctionCall:
+    return input["value"]
+""",
+    ],
+)
+def test_run_node__function_call_wrapper_value(code_snippet):
+    """Test function call wrapper value access using different patterns"""
+
+    # GIVEN a node that accesses the function call value
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, FunctionCall]):
+        code = code_snippet
+        code_inputs = {
+            "input": FunctionCall(
+                name="test-name",
+                arguments={
+                    "test-key": "test-value",
+                },
+            )
+        }
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+    outputs = node.run()
+
+    # THEN the node should successfully return the function call value
+    assert isinstance(outputs.result, FunctionCall)
+    assert outputs.result.name == "test-name"
+    assert outputs.result.arguments == {"test-key": "test-value"}
+    assert outputs.result.id is None
+    assert outputs.log == ""
+
+
+@pytest.mark.parametrize(
+    "code_snippet",
+    [
+        """
+from vellum.client.types.function_call import FunctionCall
+def main(input: FunctionCall) -> str:
+    return input.type
+""",
+        """
+from vellum.client.types.function_call import FunctionCall
+def main(input: FunctionCall) -> str:
+    return input["type"]
+""",
+    ],
+)
+def test_run_node__function_call_wrapper_type(code_snippet):
+    """Test function call wrapper type access using different patterns"""
+
+    # GIVEN a node that accesses the function call type
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, str]):
+        code = code_snippet
+        runtime = "PYTHON_3_11_6"
+        code_inputs = {
+            "input": FunctionCall(
+                name="test-name",
+                arguments={
+                    "test-key": "test-value",
+                },
+            )
+        }
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+    outputs = node.run()
+
+    # THEN the node should successfully return the function call type
+    assert outputs == {"result": "FUNCTION_CALL", "log": ""}
+
+
 def test_run_node__iter_list():
     # GIVEN a node that will return the first string in a list
     class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, str]):
@@ -1044,3 +1149,21 @@ Traceback (most recent call last):
 IndexError: list index out of range
 """
     )
+
+
+def test_run_node__default_function_call_type():
+    # GIVEN a node that will return a FunctionCall
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, FunctionCall]):
+        code = """\
+def main(input: str) -> str:
+    return None
+"""
+        runtime = "PYTHON_3_11_6"
+        code_inputs = {"input": "foo"}
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+    outputs = node.run()
+
+    # THEN the node should return default function call
+    assert outputs == {"result": FunctionCall(name="", arguments={}), "log": ""}

vellum/workflows/nodes/experimental/tool_calling_node/node.py

@@ -43,8 +43,8 @@ class ToolCallingNode(BaseNode):
         chat_history: The complete chat history including tool calls
         """
 
-        text: str = ""
-        chat_history: List[ChatMessage] = []
+        text: str
+        chat_history: List[ChatMessage]
 
     def run(self) -> Outputs:
         """
@@ -81,10 +81,10 @@ class ToolCallingNode(BaseNode):
                     message="Subworkflow unexpectedly paused",
                 )
             elif terminal_event.name == "workflow.execution.fulfilled":
-                node_outputs = self.Outputs()
-
-                for output_descriptor, output_value in terminal_event.outputs:
-                    setattr(node_outputs, output_descriptor.name, output_value)
+                node_outputs = self.Outputs(
+                    text=terminal_event.outputs.text,
+                    chat_history=terminal_event.outputs.chat_history,
+                )
 
                 return node_outputs
             elif terminal_event.name == "workflow.execution.rejected":

vellum/workflows/nodes/experimental/tool_calling_node/utils.py

@@ -11,7 +11,7 @@ from vellum.workflows.nodes.displayable.inline_prompt_node.node import InlinePro
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.ports.port import Port
 from vellum.workflows.references.lazy import LazyReference
-from vellum.workflows.types.core import EntityInputsInterface
+from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior
 
 
 class FunctionNode(BaseNode):
@@ -21,6 +21,9 @@ class FunctionNode(BaseNode):
 
 
 class ToolRouterNode(InlinePromptNode):
+    class Trigger(InlinePromptNode.Trigger):
+        merge_behavior = MergeBehavior.AWAIT_ATTRIBUTES
+
     def run(self) -> Iterator[BaseOutput]:
         self.prompt_inputs = {**self.prompt_inputs, "chat_history": self.state.chat_history}  # type: ignore
         generator = super().run()

vellum/workflows/nodes/tests/test_utils.py

@@ -4,7 +4,7 @@ from typing import Any, List, Union
 from pydantic import BaseModel
 
 from vellum.client.types.chat_message import ChatMessage
-from vellum.client.types.function_call import FunctionCall as FunctionCallType
+from vellum.client.types.function_call import FunctionCall
 from vellum.client.types.vellum_value import VellumValue
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
@@ -15,11 +15,7 @@ from vellum.workflows.types.core import Json
 class Person(BaseModel):
     name: str
     age: int
-
-
-class FunctionCall(BaseModel):
-    name: str
-    args: List[int]
+    colors: List[str]
 
 
 @pytest.mark.parametrize(
@@ -61,34 +57,25 @@ def test_parse_type_from_str_basic_cases(input_str, output_type, expected_result
 
 
 def test_parse_type_from_str_pydantic_models():
-    person_json = '{"name": "Alice", "age": 30}'
+    person_json = '{"name": "Alice", "age": 30, "colors": ["red", "blue"]}'
     person = parse_type_from_str(person_json, Person)
     assert isinstance(person, Person)
     assert person.name == "Alice"
     assert person.age == 30
-
-    function_json = '{"name": "test", "args": [1, 2]}'
-    function = parse_type_from_str(function_json, FunctionCall)
-    assert isinstance(function, FunctionCall)
-    assert function.name == "test"
-    assert function.args == [1, 2]
-
-    function_call_json = '{"value": {"name": "test", "args": [1, 2]}}'
-    function = parse_type_from_str(function_call_json, FunctionCall)
-    assert isinstance(function, FunctionCall)
-    assert function.name == "test"
-    assert function.args == [1, 2]
+    assert person.colors == ["red", "blue"]
 
 
 def test_parse_type_from_str_list_of_models():
-    person_list_json = '[{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]'
+    person_list_json = '[{"name": "Alice", "age": 30, "colors": ["red", "blue"]}, {"name": "Bob", "age": 25, "colors": ["green", "yellow"]}]'  # noqa: E501
     persons = parse_type_from_str(person_list_json, List[Person])
     assert len(persons) == 2
     assert all(isinstance(p, Person) for p in persons)
     assert persons[0].name == "Alice"
     assert persons[0].age == 30
+    assert persons[0].colors == ["red", "blue"]
     assert persons[1].name == "Bob"
     assert persons[1].age == 25
+    assert persons[1].colors == ["green", "yellow"]
 
 
 @pytest.mark.parametrize(
@@ -143,7 +130,7 @@ def test_parse_type_from_str_error_cases(input_str, output_type, expected_except
         (int, 0),  # Number
         (float, 0.0),  # Number
         (Any, None),  # Json
-        (FunctionCallType, {}),  # FunctionCall
+        (FunctionCall, FunctionCall(name="", arguments={})),  # FunctionCall
         (List[ChatMessage], []),  # Chat History
         (List[VellumValue], []),  # Array
         (Union[float, int], 0.0),  # Union

vellum/workflows/nodes/utils.py

@@ -230,7 +230,10 @@ def _get_default_value(output_type: Any) -> Any:
     elif origin is list:
         return []
     elif output_type is FunctionCall:
-        return {}
+        return FunctionCall(
+            name="",
+            arguments={},
+        )
     elif origin is Union:
         # Always use the first argument type's default value
         if args:

vellum/workflows/runner/runner.py

@@ -431,7 +431,7 @@ class WorkflowRunner(Generic[StateType]):
                     return
 
             all_deps = self._dependencies[node_class]
-            node_span_id = state.meta.node_execution_cache.queue_node_execution(node_class, all_deps, invoked_by)
+            node_span_id = node_class.Trigger._queue_node_execution(state, all_deps, invoked_by)
             if not node_class.Trigger.should_initiate(state, all_deps, node_span_id):
                 return