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

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/sandbox.py

@@ -16,6 +16,9 @@ class WorkflowSandboxRunner(Generic[WorkflowType]):
         inputs: Optional[Sequence[BaseInputs]] = None,  # DEPRECATED - remove in v2.0.0
         dataset: Optional[Sequence[BaseInputs]] = None,
     ):
+        dotenv.load_dotenv()
+        self._logger = load_logger()
+
         if dataset is not None and inputs is not None:
             raise ValueError(
                 "Cannot specify both 'dataset' and 'inputs' parameters. " "Use 'dataset' as 'inputs' is deprecated."
@@ -24,6 +27,9 @@ class WorkflowSandboxRunner(Generic[WorkflowType]):
         if dataset is not None:
             actual_inputs = dataset
         elif inputs is not None:
+            self._logger.warning(
+                "The 'inputs' parameter is deprecated and will be removed in v2.0.0. " "Please use 'dataset' instead."
+            )
             actual_inputs = inputs
         else:
             raise ValueError("Either 'dataset' or 'inputs' parameter is required")
@@ -34,9 +40,6 @@ class WorkflowSandboxRunner(Generic[WorkflowType]):
         self._workflow = workflow
         self._inputs = actual_inputs
 
-        dotenv.load_dotenv()
-        self._logger = load_logger()
-
     def run(self, index: int = 0):
         if index < 0:
             self._logger.warning("Index is less than 0, running first input")

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/state/encoder.py

@@ -2,8 +2,10 @@ from dataclasses import asdict, is_dataclass
 from datetime import datetime
 import enum
 import inspect
+from io import StringIO
 from json import JSONEncoder
 from queue import Queue
+import sys
 from uuid import UUID
 from typing import Any, Callable, Dict, Type
 
@@ -18,6 +20,22 @@ from vellum.workflows.state.base import BaseState, NodeExecutionCache
 from vellum.workflows.utils.functions import compile_function_definition
 
 
+def virtual_open(file_path: str, mode: str = "r"):
+    """
+    Open a file, checking VirtualFileFinder instances first before falling back to regular open().
+    """
+    for finder in sys.meta_path:
+        if hasattr(finder, "loader") and hasattr(finder.loader, "_get_code"):
+            namespace = finder.loader.namespace
+            if file_path.startswith(namespace + "/"):
+                relative_path = file_path[len(namespace) + 1 :]
+                content = finder.loader._get_code(relative_path)
+                if content is not None:
+                    return StringIO(content)
+
+    return open(file_path, mode)
+
+
 class DefaultStateEncoder(JSONEncoder):
     encoders: Dict[Type, Callable] = {}
 
@@ -66,7 +84,7 @@ class DefaultStateEncoder(JSONEncoder):
             function_definition = compile_function_definition(obj)
             source_path = inspect.getsourcefile(obj)
             if source_path is not None:
-                with open(source_path) as f:
+                with virtual_open(source_path) as f:
                     source_code = f.read()
             else:
                 source_code = f"# Error: Source code not available for {obj.__name__}"

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/hmac.py

@@ -0,0 +1,44 @@
+import hashlib
+import hmac
+import os
+import time
+
+from requests import PreparedRequest
+
+
+def _sign_request(request: PreparedRequest, secret: str) -> None:
+    """
+    Sign a request with HMAC using the same pattern as Django implementation.
+
+    Args:
+        request: The prepared request to sign
+        secret: The HMAC secret string
+    """
+    timestamp = str(int(time.time()))
+
+    body = request.body or b""
+    if isinstance(body, str):
+        body = body.encode()
+
+    message = f"{timestamp}\n{request.method}\n{request.url}\n".encode() + body
+
+    signature = hmac.new(secret.encode("utf-8"), message, hashlib.sha256).hexdigest()
+
+    hmac_headers = {
+        "X-Vellum-Timestamp": timestamp,
+        "X-Vellum-Signature": signature,
+    }
+
+    request.headers.update(hmac_headers)
+
+
+def sign_request_with_env_secret(request: PreparedRequest) -> None:
+    """
+    Sign a request using VELLUM_HMAC_SECRET environment variable if available.
+
+    Args:
+        request: The prepared request to sign
+    """
+    hmac_secret = os.environ.get("VELLUM_HMAC_SECRET")
+    if hmac_secret:
+        _sign_request(request, hmac_secret)

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

{vellum_ai-1.2.0.dist-info → vellum_ai-1.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 1.2.0
+Version: 1.2.2
 Summary: 
 License: MIT
 Requires-Python: >=3.9,<4.0