vellum-ai 1.2.0__py3-none-any.whl → 1.2.2__py3-none-any.whl

vellum/client/types/error_detail_response.py

@@ -0,0 +1,22 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+
+
+class ErrorDetailResponse(UniversalBaseModel):
+    detail: str = pydantic.Field()
+    """
+    Message informing the user of the error.
+    """
+
+    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/client/types/event_create_response.py

@@ -0,0 +1,26 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+
+
+class EventCreateResponse(UniversalBaseModel):
+    """
+    Response serializer for successful event creation.
+    """
+
+    success: typing.Optional[bool] = pydantic.Field(default=None)
+    """
+    Indicates whether the event was published successfully.
+    """
+
+    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/client/types/execution_thinking_vellum_value.py

@@ -19,7 +19,7 @@ class ExecutionThinkingVellumValue(UniversalBaseModel):
 
     name: str
     type: typing.Literal["THINKING"] = "THINKING"
-    value: StringVellumValue
+    value: typing.Optional[StringVellumValue] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

vellum/client/types/thinking_vellum_value.py

@@ -13,7 +13,7 @@ class ThinkingVellumValue(UniversalBaseModel):
     """
 
     type: typing.Literal["THINKING"] = "THINKING"
-    value: StringVellumValue
+    value: typing.Optional[StringVellumValue] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

vellum/client/types/thinking_vellum_value_request.py

@@ -13,7 +13,7 @@ class ThinkingVellumValueRequest(UniversalBaseModel):
     """
 
     type: typing.Literal["THINKING"] = "THINKING"
-    value: StringVellumValueRequest
+    value: typing.Optional[StringVellumValueRequest] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

vellum/client/types/workflow_event.py

@@ -0,0 +1,33 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+from .node_execution_fulfilled_event import NodeExecutionFulfilledEvent
+from .node_execution_initiated_event import NodeExecutionInitiatedEvent
+from .node_execution_paused_event import NodeExecutionPausedEvent
+from .node_execution_rejected_event import NodeExecutionRejectedEvent
+from .node_execution_resumed_event import NodeExecutionResumedEvent
+from .node_execution_streaming_event import NodeExecutionStreamingEvent
+from .workflow_execution_fulfilled_event import WorkflowExecutionFulfilledEvent
+from .workflow_execution_initiated_event import WorkflowExecutionInitiatedEvent
+from .workflow_execution_paused_event import WorkflowExecutionPausedEvent
+from .workflow_execution_rejected_event import WorkflowExecutionRejectedEvent
+from .workflow_execution_resumed_event import WorkflowExecutionResumedEvent
+from .workflow_execution_snapshotted_event import WorkflowExecutionSnapshottedEvent
+from .workflow_execution_streaming_event import WorkflowExecutionStreamingEvent
+
+WorkflowEvent = typing.Union[
+    NodeExecutionInitiatedEvent,
+    NodeExecutionStreamingEvent,
+    NodeExecutionFulfilledEvent,
+    NodeExecutionRejectedEvent,
+    NodeExecutionPausedEvent,
+    NodeExecutionResumedEvent,
+    WorkflowExecutionInitiatedEvent,
+    WorkflowExecutionStreamingEvent,
+    WorkflowExecutionRejectedEvent,
+    WorkflowExecutionFulfilledEvent,
+    WorkflowExecutionPausedEvent,
+    WorkflowExecutionResumedEvent,
+    WorkflowExecutionSnapshottedEvent,
+]

vellum/errors/too_many_requests_error.py

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

vellum/errors/unauthorized_error.py

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

vellum/prompts/blocks/compilation.py

@@ -19,6 +19,8 @@ from vellum.client.types.image_vellum_value import ImageVellumValue
 from vellum.client.types.number_input import NumberInput
 from vellum.client.types.vellum_audio import VellumAudio
 from vellum.client.types.vellum_image import VellumImage
+from vellum.client.types.vellum_video import VellumVideo
+from vellum.client.types.video_vellum_value import VideoVellumValue
 from vellum.prompts.blocks.exceptions import PromptCompilationError
 from vellum.prompts.blocks.types import CompiledChatMessagePromptBlock, CompiledPromptBlock, CompiledValuePromptBlock
 from vellum.utils.templating.constants import DEFAULT_JINJA_CUSTOM_FILTERS, DEFAULT_JINJA_GLOBALS
@@ -154,17 +156,17 @@ def compile_prompt_blocks(
             )
             compiled_blocks.append(audio_block)
 
-        # elif block.block_type == "VIDEO":
-        #     video_block = CompiledValuePromptBlock(
-        #         content=VideoVellumValue(
-        #             value=VellumVideo(
-        #                 src=block.src,
-        #                 metadata=block.metadata,
-        #             ),
-        #         ),
-        #         cache_config=block.cache_config,
-        #     )
-        #     compiled_blocks.append(video_block)
+        elif block.block_type == "VIDEO":
+            video_block = CompiledValuePromptBlock(
+                content=VideoVellumValue(
+                    value=VellumVideo(
+                        src=block.src,
+                        metadata=block.metadata,
+                    ),
+                ),
+                cache_config=block.cache_config,
+            )
+            compiled_blocks.append(video_block)
 
         elif block.block_type == "IMAGE":
             image_block = CompiledValuePromptBlock(

vellum/resources/events/__init__.py

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

vellum/resources/events/client.py

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

vellum/resources/events/raw_client.py

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

vellum/types/error_detail_response.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.error_detail_response import *

vellum/types/event_create_response.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.event_create_response import *

vellum/types/workflow_event.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.workflow_event import *

vellum/workflows/emitters/vellum_emitter.py

@@ -1,12 +1,9 @@
 import logging
-import time
-from typing import Any, Dict, Optional
-
-import httpx
+from typing import Optional
 
+from vellum.core.request_options import RequestOptions
 from vellum.workflows.emitters.base import BaseWorkflowEmitter
-from vellum.workflows.events.types import default_serializer
-from vellum.workflows.events.workflow import WorkflowEvent
+from vellum.workflows.events.workflow import WorkflowEvent as SDKWorkflowEvent
 from vellum.workflows.state.base import BaseState
 
 logger = logging.getLogger(__name__)
@@ -43,9 +40,8 @@ class VellumEmitter(BaseWorkflowEmitter):
         super().__init__()
         self._timeout = timeout
         self._max_retries = max_retries
-        self._events_endpoint = "v1/events"  # TODO: make this configurable with the correct url
 
-    def emit_event(self, event: WorkflowEvent) -> None:
+    def emit_event(self, event: SDKWorkflowEvent) -> None:
         """
         Emit a workflow event to Vellum's infrastructure.
 
@@ -59,9 +55,7 @@ class VellumEmitter(BaseWorkflowEmitter):
             return
 
         try:
-            event_data = default_serializer(event)
-
-            self._send_event(event_data)
+            self._send_event(event)
 
         except Exception as e:
             logger.exception(f"Failed to emit event {event.name}: {e}")
@@ -75,70 +69,23 @@ class VellumEmitter(BaseWorkflowEmitter):
         """
         pass
 
-    def _send_event(self, event_data: Dict[str, Any]) -> None:
+    def _send_event(self, event: SDKWorkflowEvent) -> None:
         """
-        Send event data to Vellum's events endpoint with retry logic.
+        Send event to Vellum's events endpoint using client.events.create.
 
         Args:
-            event_data: The serialized event data to send.
+            event: The WorkflowEvent object to send.
         """
         if not self._context:
             logger.warning("Cannot send event: No workflow context registered")
             return
 
         client = self._context.vellum_client
-
-        for attempt in range(self._max_retries + 1):
-            try:
-                # Use the Vellum client's underlying HTTP client to make the request
-                # For proper authentication headers and configuration
-                base_url = client._client_wrapper.get_environment().default
-                response = client._client_wrapper.httpx_client.request(
-                    method="POST",
-                    base_url=base_url,
-                    path=self._events_endpoint,  # TODO: will be replaced with the correct url
-                    json=event_data,
-                    headers=client._client_wrapper.get_headers(),
-                    request_options={"timeout_in_seconds": self._timeout},
-                )
-
-                response.raise_for_status()
-
-                if attempt > 0:
-                    logger.info(f"Event sent successfully after {attempt + 1} attempts")
-                return
-
-            except httpx.HTTPStatusError as e:
-                if e.response.status_code >= 500:
-                    # Server errors might be transient, retry
-                    if attempt < self._max_retries:
-                        wait_time = min(2**attempt, 60)  # Exponential backoff, max 60s
-                        logger.warning(
-                            f"Server error emitting event (attempt {attempt + 1}/{self._max_retries + 1}): "
-                            f"{e.response.status_code}. Retrying in {wait_time}s..."
-                        )
-                        time.sleep(wait_time)
-                        continue
-                    else:
-                        logger.exception(
-                            f"Server error emitting event after {self._max_retries + 1} attempts: "
-                            f"{e.response.status_code} {e.response.text}"
-                        )
-                        return
-                else:
-                    # Client errors (4xx) are not retriable
-                    logger.exception(f"Client error emitting event: {e.response.status_code} {e.response.text}")
-                    return
-
-            except httpx.RequestError as e:
-                if attempt < self._max_retries:
-                    wait_time = min(2**attempt, 60)  # Exponential backoff, max 60s
-                    logger.warning(
-                        f"Network error emitting event (attempt {attempt + 1}/{self._max_retries + 1}): "
-                        f"{e}. Retrying in {wait_time}s..."
-                    )
-                    time.sleep(wait_time)
-                    continue
-                else:
-                    logger.exception(f"Network error emitting event after {self._max_retries + 1} attempts: {e}")
-                    return
+        request_options = RequestOptions(timeout_in_seconds=self._timeout, max_retries=self._max_retries)
+        client.events.create(
+            # The API accepts a ClientWorkflowEvent but our SDK emits an SDKWorkflowEvent. These shapes are
+            # meant to be identical, just with different helper methods. We may consolidate the two in the future.
+            # But for now, the type ignore allows us to avoid an additional Model -> json -> Model conversion.
+            request=event,  # type: ignore[arg-type]
+            request_options=request_options,
+        )

vellum/workflows/events/tests/test_event.py

@@ -90,6 +90,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                     },
                     "display_context": None,
                     "initial_state": None,
+                    "workflow_version_exec_config": None,
                 },
                 "parent": None,
             },

vellum/workflows/events/workflow.py

@@ -77,6 +77,9 @@ class WorkflowExecutionInitiatedBody(_BaseWorkflowExecutionBody, Generic[InputsT
     # that the Workflow Runner can begin populating this field then.
     display_context: Optional[WorkflowEventDisplayContext] = None
 
+    # This field will be populated during serialization by the serialize_body method
+    workflow_version_exec_config: Optional[Any] = None
+
     @field_serializer("inputs")
     def serialize_inputs(self, inputs: InputsType, _info: Any) -> Dict[str, Any]:
         return default_serializer(inputs)

vellum/workflows/nodes/bases/base.py

@@ -125,7 +125,6 @@ class BaseNodeMeta(ABCMeta):
         # Add cls to relevant nested classes, since python should've been doing this by default
         for port in node_class.Ports:
             port.node_class = node_class
-            port.validate()
 
         node_class.Execution.node_class = node_class
         node_class.Trigger.node_class = node_class

vellum/workflows/nodes/core/inline_subworkflow_node/tests/test_node.py

@@ -9,6 +9,7 @@ from vellum.workflows.nodes.core.try_node.node import TryNode
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.workflows.base import BaseWorkflow
+from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
 
 class Inputs(BaseInputs):
@@ -143,3 +144,37 @@ def test_inline_subworkflow_node__with_adornment():
     outputs = list(node.run())
 
     assert outputs[-1].name == "final_output" and outputs[-1].value == "hello"
+
+
+@pytest.mark.skip(reason="Enable after we set is_dynamic on the subworkflow class")
+def test_inline_subworkflow_node__is_dynamic_subworkflow():
+    """Test that InlineSubworkflowNode sets is_dynamic=True on the subworkflow class"""
+
+    # GIVEN a subworkflow class
+    class TestSubworkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = MyInnerNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            out = MyInnerNode.Outputs.out
+
+    # AND a node that uses this subworkflow
+    class TestNode(InlineSubworkflowNode):
+        subworkflow = TestSubworkflow
+
+    # AND a workflow that uses this node
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = TestNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            out = TestNode.Outputs.out
+
+    # WHEN the workflow is executed
+    workflow = TestWorkflow()
+    events = list(workflow.stream(event_filter=all_workflow_event_filter))
+
+    # AND we should find workflow execution initiated events
+    initiated_events = [event for event in events if event.name == "workflow.execution.initiated"]
+    assert len(initiated_events) == 2  # Main workflow + inline workflow
+
+    assert initiated_events[0].body.workflow_definition.is_dynamic is False  # Main workflow
+    assert initiated_events[1].body.workflow_definition.is_dynamic is True  # Inline workflow

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

@@ -14,6 +14,7 @@ from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.outputs import BaseOutputs
 from vellum.workflows.types.core import Json, MergeBehavior, VellumSecret
 from vellum.workflows.types.generics import StateType
+from vellum.workflows.utils.hmac import sign_request_with_env_secret
 
 
 class BaseAPINode(BaseNode, Generic[StateType]):
@@ -105,6 +106,9 @@ class BaseAPINode(BaseNode, Generic[StateType]):
                 prepped = Request(method=method, url=url, headers=headers).prepare()
         except Exception as e:
             raise NodeException(f"Failed to prepare HTTP request: {e}", code=WorkflowErrorCode.PROVIDER_ERROR)
+
+        sign_request_with_env_secret(prepped)
+
         try:
             with Session() as session:
                 response = session.send(prepped, timeout=timeout)

vellum/workflows/nodes/displayable/bases/api_node/tests/test_node.py

@@ -1,4 +1,6 @@
 import pytest
+import os
+from unittest.mock import patch
 
 from vellum.client.types.execute_api_response import ExecuteApiResponse
 from vellum.workflows.constants import APIRequestMethod
@@ -122,3 +124,27 @@ def test_api_node_preserves_custom_user_agent_header(requests_mock):
     assert response_mock.last_request.headers.get("User-Agent") == "Custom-Agent/1.0"
 
     assert result.status_code == 200
+
+
+def test_local_execute_api_with_hmac_secret(requests_mock):
+    """Test that _local_execute_api adds HMAC headers when VELLUM_HMAC_SECRET is set."""
+
+    class TestAPINode(BaseAPINode):
+        method = APIRequestMethod.POST
+        url = "https://example.com/test"
+        json = {"test": "data"}
+
+    response_mock = requests_mock.post(
+        "https://example.com/test",
+        json={"result": "success"},
+        status_code=200,
+    )
+
+    with patch.dict(os.environ, {"VELLUM_HMAC_SECRET": "test-secret"}):
+        node = TestAPINode()
+        result = node.run()
+
+    assert response_mock.last_request
+    assert "X-Vellum-Timestamp" in response_mock.last_request.headers
+    assert "X-Vellum-Signature" in response_mock.last_request.headers
+    assert result.status_code == 200

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

@@ -122,8 +122,13 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
                     )
                 elif is_workflow_class(function):
                     normalized_functions.append(compile_inline_workflow_function_definition(function))
-                else:
+                elif callable(function):
                     normalized_functions.append(compile_function_definition(function))
+                else:
+                    raise NodeException(
+                        message=f"`{function}` is not a valid function definition",
+                        code=WorkflowErrorCode.INVALID_INPUTS,
+                    )
 
         if self.settings and not self.settings.stream_enabled:
             # This endpoint is returning a single event, so we need to wrap it in a generator

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

@@ -662,3 +662,25 @@ def test_inline_prompt_node__dict_blocks_error(vellum_adhoc_prompt_client):
     # THEN the node should raise the correct NodeException
     assert excinfo.value.code == WorkflowErrorCode.INVALID_INPUTS
     assert "Failed to compile blocks" == str(excinfo.value)
+
+
+def test_inline_prompt_node__invalid_function_type():
+    """Test that the node raises an error when an invalid function type is passed."""
+
+    # GIVEN a node that has an invalid function type (not dict or callable)
+    class MyInlinePromptNode(InlinePromptNode):
+        ml_model = "gpt-4o"
+        blocks = []
+        prompt_inputs = {}
+        functions = ["not_a_function"]  # type: ignore
+
+    # WHEN the node is created
+    node = MyInlinePromptNode()
+
+    # THEN the node should raise a NodeException with the correct error code
+    with pytest.raises(NodeException) as excinfo:
+        list(node.run())
+
+    # AND the error should have the correct code and message
+    assert excinfo.value.code == WorkflowErrorCode.INVALID_INPUTS
+    assert "`not_a_function` is not a valid function definition" == str(excinfo.value)

vellum/workflows/nodes/displayable/bases/utils.py

@@ -28,6 +28,8 @@ from vellum.client.types.string_vellum_value_request import StringVellumValueReq
 from vellum.client.types.vellum_error import VellumError
 from vellum.client.types.vellum_value import VellumValue
 from vellum.client.types.vellum_value_request import VellumValueRequest
+from vellum.client.types.video_vellum_value import VideoVellumValue
+from vellum.client.types.video_vellum_value_request import VideoVellumValueRequest
 from vellum.workflows.errors.types import WorkflowError, workflow_error_to_vellum_error
 from vellum.workflows.state.encoder import DefaultStateEncoder
 
@@ -36,7 +38,7 @@ VELLUM_VALUE_REQUEST_TUPLE = (
     NumberVellumValueRequest,
     JsonVellumValueRequest,
     AudioVellumValueRequest,
-    # VideoVellumValueRequest,
+    VideoVellumValueRequest,
     ImageVellumValueRequest,
     FunctionCallVellumValueRequest,
     ErrorVellumValueRequest,
@@ -80,7 +82,7 @@ def primitive_to_vellum_value(value: Any) -> VellumValue:
             NumberVellumValue,
             JsonVellumValue,
             AudioVellumValue,
-            # VideoVellumValue,
+            VideoVellumValue,
             ImageVellumValue,
             FunctionCallVellumValue,
             ErrorVellumValue,

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

@@ -1,6 +1,6 @@
 import json
 from uuid import UUID
-from typing import Any, ClassVar, Dict, Generic, Iterator, List, Optional, Set, Union, cast
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, Generic, Iterator, List, Optional, Set, Union, cast
 
 from vellum import (
     ChatMessage,
@@ -16,16 +16,21 @@ from vellum.client.core import RequestOptions
 from vellum.client.core.api_error import ApiError
 from vellum.client.types.chat_message_request import ChatMessageRequest
 from vellum.workflows.constants import LATEST_RELEASE_TAG, OMIT
-from vellum.workflows.context import get_execution_context
+from vellum.workflows.context import execution_context, get_execution_context, get_parent_context
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.errors.types import workflow_event_error_to_workflow_error
 from vellum.workflows.events.types import default_serializer
+from vellum.workflows.events.workflow import is_workflow_event
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior
 from vellum.workflows.types.generics import StateType
+from vellum.workflows.workflows.event_filters import all_workflow_event_filter
+
+if TYPE_CHECKING:
+    from vellum.workflows.workflows.base import BaseWorkflow
 
 
 class SubworkflowDeploymentNode(BaseNode[StateType], Generic[StateType]):
@@ -135,6 +140,74 @@ class SubworkflowDeploymentNode(BaseNode[StateType], Generic[StateType]):
                 )
             )
 
+    def _compile_subworkflow_inputs_for_direct_invocation(self, workflow: "BaseWorkflow") -> Any:
+        """Compile inputs for direct workflow invocation (similar to InlineSubworkflowNode)."""
+        inputs_class = workflow.get_inputs_class()
+
+        if isinstance(self.subworkflow_inputs, BaseInputs):
+            inputs_dict = {}
+            for input_descriptor, input_value in self.subworkflow_inputs:
+                if input_value is not None:
+                    inputs_dict[input_descriptor.name] = input_value
+            return inputs_class(**inputs_dict)
+        else:
+            # Filter out None values for direct invocation
+            filtered_inputs = {k: v for k, v in self.subworkflow_inputs.items() if v is not None}
+            return inputs_class(**filtered_inputs)
+
+    def _run_resolved_workflow(self, resolved_workflow: "BaseWorkflow") -> Iterator[BaseOutput]:
+        """Execute resolved workflow directly (similar to InlineSubworkflowNode)."""
+        with execution_context(parent_context=get_parent_context()):
+            subworkflow_stream = resolved_workflow.stream(
+                inputs=self._compile_subworkflow_inputs_for_direct_invocation(resolved_workflow),
+                event_filter=all_workflow_event_filter,
+                node_output_mocks=self._context._get_all_node_output_mocks(),
+            )
+
+        outputs = None
+        exception = None
+        fulfilled_output_names: Set[str] = set()
+
+        for event in subworkflow_stream:
+            self._context._emit_subworkflow_event(event)
+            if exception:
+                continue
+
+            if not is_workflow_event(event):
+                continue
+            if event.workflow_definition != resolved_workflow.__class__:
+                continue
+
+            if event.name == "workflow.execution.streaming":
+                if event.output.is_fulfilled:
+                    fulfilled_output_names.add(event.output.name)
+                yield event.output
+            elif event.name == "workflow.execution.fulfilled":
+                outputs = event.outputs
+            elif event.name == "workflow.execution.rejected":
+                exception = NodeException.of(event.error)
+            elif event.name == "workflow.execution.paused":
+                exception = NodeException(
+                    code=WorkflowErrorCode.INVALID_OUTPUTS,
+                    message="Subworkflow unexpectedly paused",
+                )
+
+        if exception:
+            raise exception
+
+        if outputs is None:
+            raise NodeException(
+                message="Expected to receive outputs from Workflow Deployment",
+                code=WorkflowErrorCode.INVALID_OUTPUTS,
+            )
+
+        for output_descriptor, output_value in outputs:
+            if output_descriptor.name not in fulfilled_output_names:
+                yield BaseOutput(
+                    name=output_descriptor.name,
+                    value=output_value,
+                )
+
     def run(self) -> Iterator[BaseOutput]:
         execution_context = get_execution_context()
         request_options = self.request_options or RequestOptions()
@@ -152,6 +225,19 @@ class SubworkflowDeploymentNode(BaseNode[StateType], Generic[StateType]):
                 message="Expected subworkflow deployment attribute to be either a UUID or STR, got None instead",
             )
 
+        if not deployment_name:
+            raise NodeException(
+                code=WorkflowErrorCode.INVALID_INPUTS,
+                message="Expected deployment name to be provided for subworkflow execution.",
+            )
+
+        resolved_workflow = self._context.resolve_workflow_deployment(
+            deployment_name=deployment_name, release_tag=self.release_tag
+        )
+        if resolved_workflow:
+            yield from self._run_resolved_workflow(resolved_workflow)
+            return
+
         try:
             subworkflow_stream = self._context.vellum_client.execute_workflow_stream(
                 inputs=self._compile_subworkflow_inputs(),

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

@@ -76,6 +76,7 @@ class ToolCallingNode(BaseNode[StateType], Generic[StateType]):
 
             class ToolCallingWorkflow(BaseWorkflow[BaseInputs, ToolCallingState]):
                 graph = self._graph
+                is_dynamic = True
 
                 class Outputs(BaseWorkflow.Outputs):
                     text: str = self.tool_prompt_node.Outputs.text