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

vellum/client/core/client_wrapper.py

@@ -27,10 +27,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "vellum-ai/1.2.1",
+            "User-Agent": "vellum-ai/1.2.2",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.2.1",
+            "X-Fern-SDK-Version": "1.2.2",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

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/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/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

vellum/workflows/nodes/displayable/tool_calling_node/tests/test_node.py

@@ -1,12 +1,14 @@
 import json
 from uuid import uuid4
-from typing import Any, Iterator
+from typing import Any, Iterator, List
 
 from vellum import ChatMessage
+from vellum.client.types.execute_prompt_event import ExecutePromptEvent
 from vellum.client.types.fulfilled_execute_prompt_event import FulfilledExecutePromptEvent
 from vellum.client.types.function_call import FunctionCall
 from vellum.client.types.function_call_vellum_value import FunctionCallVellumValue
 from vellum.client.types.initiated_execute_prompt_event import InitiatedExecutePromptEvent
+from vellum.client.types.prompt_output import PromptOutput
 from vellum.client.types.string_chat_message_content import StringChatMessageContent
 from vellum.client.types.string_vellum_value import StringVellumValue
 from vellum.client.types.variable_prompt_block import VariablePromptBlock
@@ -25,6 +27,7 @@ from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.state.base import BaseState, StateMeta
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.types.definition import DeploymentDefinition
+from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
 
 def first_function() -> str:
@@ -238,3 +241,84 @@ def test_tool_calling_node_with_generic_type_parameter():
     assert node is not None
     assert isinstance(node, TestToolCallingNode)
     assert node.state == state
+
+
+def test_tool_calling_node_workflow_is_dynamic(vellum_adhoc_prompt_client):
+    """
+    Test workflow_version_exec_config without any mocks to see if that's the issue.
+    """
+
+    def generate_prompt_events(*args, **kwargs) -> Iterator[ExecutePromptEvent]:
+        execution_id = str(uuid4())
+
+        call_count = vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.call_count
+        expected_outputs: List[PromptOutput]
+        if call_count == 1:
+            expected_outputs = [
+                FunctionCallVellumValue(
+                    value=FunctionCall(
+                        arguments={"var_1": 1, "var_2": 2},
+                        id="call_123",
+                        name="add_numbers_workflow",
+                        state="FULFILLED",
+                    ),
+                ),
+            ]
+        else:
+            expected_outputs = [StringVellumValue(value="The result is 3")]
+
+        events: List[ExecutePromptEvent] = [
+            InitiatedExecutePromptEvent(execution_id=execution_id),
+            FulfilledExecutePromptEvent(
+                execution_id=execution_id,
+                outputs=expected_outputs,
+            ),
+        ]
+        yield from events
+
+    vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.side_effect = generate_prompt_events
+
+    class AddNode(BaseNode):
+
+        class Outputs(BaseNode.Outputs):
+            result: int
+
+        def run(self) -> Outputs:
+            return self.Outputs(result=1)
+
+    class AddNumbersWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        """
+        A simple workflow that adds two numbers.
+        """
+
+        graph = AddNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            result = AddNode.Outputs.result
+
+    class TestToolCallingNode(ToolCallingNode):
+        ml_model = "gpt-4o-mini"
+        blocks = []
+        functions = [AddNumbersWorkflow]
+        prompt_inputs = {}
+
+    # GIVEN a workflow with just a tool calling node
+    class ToolCallingWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = TestToolCallingNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            text: str = TestToolCallingNode.Outputs.text
+            chat_history: List[ChatMessage] = TestToolCallingNode.Outputs.chat_history
+
+    workflow = ToolCallingWorkflow()
+
+    # WHEN the workflow is executed and we capture all events
+    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) == 3  # Main workflow + tool calling internal + 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  # Tool calling internal
+    assert initiated_events[2].body.workflow_definition.is_dynamic is True  # Inline workflow

vellum/workflows/nodes/displayable/tool_calling_node/tests/test_utils.py

@@ -238,3 +238,15 @@ def test_create_tool_prompt_node_chat_history_block_dict(vellum_adhoc_prompt_cli
         ),
         VariablePromptBlock(block_type="VARIABLE", state=None, cache_config=None, input_variable="chat_history"),
     ]
+
+
+def test_get_mcp_tool_name_snake_case():
+    """Test MCPToolDefinition function name generation with snake case."""
+    mcp_tool = MCPToolDefinition(
+        name="create_repository",
+        server=MCPServer(name="Github Server", url="https://api.github.com"),
+        parameters={"repository_name": "string", "description": "string"},
+    )
+
+    result = get_mcp_tool_name(mcp_tool)
+    assert result == "github_server__create_repository"

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

@@ -505,6 +505,7 @@ def create_function_node(
         )
         return node
     elif is_workflow_class(function):
+        function.is_dynamic = True
         node = type(
             f"DynamicInlineSubworkflowNode_{function.__name__}",
             (DynamicInlineSubworkflowNode,),
@@ -574,10 +575,12 @@ def get_function_name(function: ToolBase) -> str:
         name = str(function.deployment_id or function.deployment_name)
         return name.replace("-", "")
     elif isinstance(function, ComposioToolDefinition):
-        return function.name
+        # model post init sets the name to the action if it's not set
+        return function.name  # type: ignore[return-value]
     else:
         return snake_case(function.__name__)
 
 
 def get_mcp_tool_name(tool_def: MCPToolDefinition) -> str:
-    return f"{tool_def.server.name}__{tool_def.name}"
+    server_name = snake_case(tool_def.server.name)
+    return f"{server_name}__{tool_def.name}"

vellum/workflows/ports/port.py

@@ -7,7 +7,7 @@ from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.edges.edge import Edge
 from vellum.workflows.errors.types import WorkflowErrorCode
-from vellum.workflows.exceptions import NodeException, WorkflowInitializationException
+from vellum.workflows.exceptions import NodeException
 from vellum.workflows.graph import Graph, GraphTarget
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.types.core import ConditionType
@@ -107,13 +107,3 @@ class Port:
         cls, source_type: Type[Any], handler: GetCoreSchemaHandler
     ) -> core_schema.CoreSchema:
         return core_schema.is_instance_schema(cls)
-
-    def validate(self):
-        if (
-            not self.default
-            and self._condition_type in (ConditionType.IF, ConditionType.ELIF)
-            and self._condition is None
-        ):
-            raise WorkflowInitializationException(
-                f"Class {self.node_class.__name__}'s {self.name} should have a defined condition and cannot be empty."
-            )

vellum/workflows/state/context.py

@@ -13,6 +13,7 @@ from vellum.workflows.vellum_client import create_vellum_client
 
 if TYPE_CHECKING:
     from vellum.workflows.events.workflow import WorkflowEvent
+    from vellum.workflows.workflows.base import BaseWorkflow
 
 
 class WorkflowContext:
@@ -131,6 +132,19 @@ class WorkflowContext:
     def _get_all_node_output_mocks(self) -> List[MockNodeExecution]:
         return [mock for mocks in self._node_output_mocks_map.values() for mock in mocks]
 
+    def resolve_workflow_deployment(self, deployment_name: str, release_tag: str) -> Optional["BaseWorkflow"]:
+        """
+        Resolve a workflow deployment by name and release tag.
+
+        Args:
+            deployment_name: The name of the workflow deployment
+            release_tag: The release tag to resolve
+
+        Returns:
+            BaseWorkflow instance if found, None otherwise
+        """
+        return None
+
     @classmethod
     def create_from(cls, context):
         return cls(vellum_client=context.vellum_client, generated_files=context.generated_files)

vellum/workflows/types/definition.py

@@ -111,11 +111,11 @@ class ComposioToolDefinition(UniversalBaseModel):
     action: str  # Specific action like "GITHUB_CREATE_AN_ISSUE"
     description: str
     user_id: Optional[str] = None
+    name: str = ""
 
-    @property
-    def name(self) -> str:
-        """Generate a function name for this tool"""
-        return self.action.lower()
+    def model_post_init(self, __context: Any):
+        if self.name == "":
+            self.name = self.action.lower()
 
 
 class MCPServer(UniversalBaseModel):

vellum/workflows/utils/vellum_variables.py

@@ -1,7 +1,7 @@
 import typing
 from typing import List, Tuple, Type, Union, get_args, get_origin
 
-from vellum import (  # VellumVideo,; VellumVideoRequest,
+from vellum import (
     ChatMessage,
     ChatMessageRequest,
     FunctionCall,
@@ -19,6 +19,8 @@ from vellum import (  # VellumVideo,; VellumVideoRequest,
     VellumValue,
     VellumValueRequest,
     VellumVariableType,
+    VellumVideo,
+    VellumVideoRequest,
 )
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.types.core import Json
@@ -67,8 +69,8 @@ def primitive_type_to_vellum_variable_type(type_: Union[Type, BaseDescriptor]) -
         return "FUNCTION_CALL"
     elif _is_type_optionally_in(type_, (VellumAudio, VellumAudioRequest)):
         return "AUDIO"
-    # elif _is_type_optionally_in(type_, (VellumVideo, VellumVideoRequest)):
-    #     return "VIDEO"
+    elif _is_type_optionally_in(type_, (VellumVideo, VellumVideoRequest)):
+        return "VIDEO"
     elif _is_type_optionally_in(type_, (VellumImage, VellumImageRequest)):
         return "IMAGE"
     elif _is_type_optionally_in(type_, (VellumDocument, VellumDocumentRequest)):

vellum/workflows/workflows/base.py

@@ -211,6 +211,7 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
     unused_graphs: ClassVar[Set[GraphAttribute]]  # nodes or graphs that are defined but not used in the graph
     emitters: List[BaseWorkflowEmitter]
     resolvers: List[BaseWorkflowResolver]
+    is_dynamic: ClassVar[bool] = False
 
     class Outputs(BaseOutputs):
         pass