vellum-ai 1.0.10__py3-none-any.whl → 1.0.11__py3-none-any.whl

vellum/client/core/client_wrapper.py

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

vellum/workflows/descriptors/base.py

@@ -2,6 +2,7 @@ from typing import TYPE_CHECKING, Any, Generic, Optional, Tuple, Type, TypeVar,
 
 if TYPE_CHECKING:
     from vellum.workflows.expressions.accessor import AccessorExpression
+    from vellum.workflows.expressions.add import AddExpression
     from vellum.workflows.expressions.and_ import AndExpression
     from vellum.workflows.expressions.begins_with import BeginsWithExpression
     from vellum.workflows.expressions.between import BetweenExpression
@@ -26,8 +27,10 @@ if TYPE_CHECKING:
     from vellum.workflows.expressions.is_not_undefined import IsNotUndefinedExpression
     from vellum.workflows.expressions.is_null import IsNullExpression
     from vellum.workflows.expressions.is_undefined import IsUndefinedExpression
+    from vellum.workflows.expressions.length import LengthExpression
     from vellum.workflows.expressions.less_than import LessThanExpression
     from vellum.workflows.expressions.less_than_or_equal_to import LessThanOrEqualToExpression
+    from vellum.workflows.expressions.minus import MinusExpression
     from vellum.workflows.expressions.not_between import NotBetweenExpression
     from vellum.workflows.expressions.not_in import NotInExpression
     from vellum.workflows.expressions.or_ import OrExpression
@@ -127,7 +130,7 @@ class BaseDescriptor(Generic[_T]):
 
         return CoalesceExpression(lhs=self, rhs=other)
 
-    def __getitem__(self, field: Union[str, int]) -> "AccessorExpression":
+    def __getitem__(self, field: Union[str, int, "BaseDescriptor[str]", "BaseDescriptor[int]"]) -> "AccessorExpression":
         from vellum.workflows.expressions.accessor import AccessorExpression
 
         return AccessorExpression(base=self, field=field)
@@ -376,3 +379,30 @@ class BaseDescriptor(Generic[_T]):
         from vellum.workflows.expressions.concat import ConcatExpression
 
         return ConcatExpression(lhs=self, rhs=other)
+
+    def length(self) -> "LengthExpression[_T]":
+        from vellum.workflows.expressions.length import LengthExpression
+
+        return LengthExpression(expression=self)
+
+    @overload
+    def add(self, other: "BaseDescriptor[_O]") -> "AddExpression[_T, _O]": ...
+
+    @overload
+    def add(self, other: _O) -> "AddExpression[_T, _O]": ...
+
+    def add(self, other: "Union[BaseDescriptor[_O], _O]") -> "AddExpression[_T, _O]":
+        from vellum.workflows.expressions.add import AddExpression
+
+        return AddExpression(lhs=self, rhs=other)
+
+    @overload
+    def minus(self, other: "BaseDescriptor[_O]") -> "MinusExpression[_T, _O]": ...
+
+    @overload
+    def minus(self, other: _O) -> "MinusExpression[_T, _O]": ...
+
+    def minus(self, other: "Union[BaseDescriptor[_O], _O]") -> "MinusExpression[_T, _O]":
+        from vellum.workflows.expressions.minus import MinusExpression
+
+        return MinusExpression(lhs=self, rhs=other)

vellum/workflows/descriptors/utils.py

@@ -1,7 +1,8 @@
 from collections.abc import Mapping
 import dataclasses
 import inspect
-from typing import Any, Dict, Optional, Sequence, Set, TypeVar, Union, cast, overload
+from typing import Any, Dict, Optional, Sequence, Set, Type, TypeVar, Union, cast, overload
+from typing_extensions import TypeGuard
 
 from pydantic import BaseModel
 
@@ -115,3 +116,20 @@ def is_unresolved(value: Any) -> bool:
         return any(is_unresolved(item) for item in value)
 
     return False
+
+
+_ResolvedType = TypeVar("_ResolvedType")
+
+
+def is_resolved_instance(value: Any, type_: Type[_ResolvedType]) -> TypeGuard[_ResolvedType]:
+    """
+    Checks if a value is an instance of a type or a descriptor that resolves to that type.
+    """
+
+    if isinstance(value, type_):
+        return True
+
+    if isinstance(value, BaseDescriptor) and value.types:
+        return issubclass(value.types[0], type_)
+
+    return False

vellum/workflows/expressions/accessor.py

@@ -7,10 +7,11 @@ from pydantic_core import core_schema
 
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.exceptions import InvalidExpressionException
-from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.descriptors.utils import is_resolved_instance, resolve_value
 from vellum.workflows.state.base import BaseState
 
 LHS = TypeVar("LHS")
+AccessorField = Union[str, int, BaseDescriptor[str], BaseDescriptor[int]]
 
 
 class AccessorExpression(BaseDescriptor[Any]):
@@ -18,7 +19,7 @@ class AccessorExpression(BaseDescriptor[Any]):
         self,
         *,
         base: BaseDescriptor[LHS],
-        field: Union[str, int],
+        field: AccessorField,
     ) -> None:
         super().__init__(
             name=f"{base.name}.{field}",
@@ -28,7 +29,7 @@ class AccessorExpression(BaseDescriptor[Any]):
         self._base = base
         self._field = field
 
-    def _infer_accessor_types(self, base: BaseDescriptor[LHS], field: Union[str, int]) -> tuple[Type, ...]:
+    def _infer_accessor_types(self, base: BaseDescriptor[LHS], field: AccessorField) -> tuple[Type, ...]:
         """
         Infer the types for this accessor expression based on the base descriptor's types
         and the field being accessed.
@@ -42,7 +43,7 @@ class AccessorExpression(BaseDescriptor[Any]):
             origin = get_origin(base_type)
             args = get_args(base_type)
 
-            if isinstance(field, int) and origin in (list, tuple) and args:
+            if is_resolved_instance(field, int) and origin in (list, tuple) and args:
                 if origin is list:
                     inferred_types.append(args[0])
                 elif origin is tuple and len(args) == 2 and args[1] is ...:
@@ -52,44 +53,51 @@ class AccessorExpression(BaseDescriptor[Any]):
                         inferred_types.append(args[field])
                     else:
                         inferred_types.append(args[field])
-            elif isinstance(field, str) and origin in (dict,) and len(args) >= 2:
+            elif is_resolved_instance(field, str) and origin in (dict,) and len(args) >= 2:
                 inferred_types.append(args[1])  # Value type from Dict[K, V]
 
         return tuple(set(inferred_types)) if inferred_types else ()
 
     def resolve(self, state: "BaseState") -> Any:
         base = resolve_value(self._base, state)
+        accessor_field = resolve_value(self._field, state)
 
         if dataclasses.is_dataclass(base):
-            if isinstance(self._field, int):
+            if isinstance(accessor_field, int):
                 raise InvalidExpressionException("Cannot access field by index on a dataclass")
 
             try:
-                return getattr(base, self._field)
+                return getattr(base, accessor_field)
             except AttributeError:
-                raise InvalidExpressionException(f"Field '{self._field}' not found on dataclass {type(base).__name__}")
+                raise InvalidExpressionException(
+                    f"Field '{accessor_field}' not found on dataclass {type(base).__name__}"
+                )
 
         if isinstance(base, BaseModel):
-            if isinstance(self._field, int):
+            if isinstance(accessor_field, int):
                 raise InvalidExpressionException("Cannot access field by index on a BaseModel")
 
             try:
-                return getattr(base, self._field)
+                return getattr(base, accessor_field)
             except AttributeError:
-                raise InvalidExpressionException(f"Field '{self._field}' not found on BaseModel {type(base).__name__}")
+                raise InvalidExpressionException(
+                    f"Field '{accessor_field}' not found on BaseModel {type(base).__name__}"
+                )
 
         if isinstance(base, Mapping):
             try:
-                return base[self._field]
+                return base[accessor_field]
             except KeyError:
-                raise InvalidExpressionException(f"Key '{self._field}' not found in mapping")
+                raise InvalidExpressionException(f"Key '{accessor_field}' not found in mapping")
 
         if isinstance(base, Sequence):
             try:
-                index = int(self._field)
+                index = int(accessor_field)
                 return base[index]
             except (IndexError, ValueError):
-                if isinstance(self._field, int) or (isinstance(self._field, str) and self._field.lstrip("-").isdigit()):
+                if isinstance(accessor_field, int) or (
+                    isinstance(accessor_field, str) and accessor_field.lstrip("-").isdigit()
+                ):
                     raise InvalidExpressionException(
                         f"Index {self._field} is out of bounds for sequence of length {len(base)}"
                     )

vellum/workflows/expressions/add.py

@@ -0,0 +1,41 @@
+from typing import Any, Generic, Protocol, TypeVar, Union, runtime_checkable
+from typing_extensions import TypeGuard
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+
+@runtime_checkable
+class SupportsAdd(Protocol):
+    def __add__(self, other: Any) -> Any: ...
+
+
+def has_add(obj: Any) -> TypeGuard[SupportsAdd]:
+    return hasattr(obj, "__add__")
+
+
+LHS = TypeVar("LHS")
+RHS = TypeVar("RHS")
+
+
+class AddExpression(BaseDescriptor[Any], Generic[LHS, RHS]):
+    def __init__(
+        self,
+        *,
+        lhs: Union[BaseDescriptor[LHS], LHS],
+        rhs: Union[BaseDescriptor[RHS], RHS],
+    ) -> None:
+        super().__init__(name=f"{lhs} + {rhs}", types=(object,))
+        self._lhs = lhs
+        self._rhs = rhs
+
+    def resolve(self, state: "BaseState") -> Any:
+        lhs = resolve_value(self._lhs, state)
+        rhs = resolve_value(self._rhs, state)
+
+        if not has_add(lhs):
+            raise InvalidExpressionException(f"'{lhs.__class__.__name__}' must support the '+' operator")
+
+        return lhs + rhs

vellum/workflows/expressions/length.py

@@ -0,0 +1,35 @@
+from typing import Generic, TypeVar, Union
+
+from vellum.workflows.constants import undefined
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+_T = TypeVar("_T")
+
+
+class LengthExpression(BaseDescriptor[int], Generic[_T]):
+    def __init__(
+        self,
+        *,
+        expression: Union[BaseDescriptor[_T], _T],
+    ) -> None:
+        super().__init__(name=f"length({expression})", types=(int,))
+        self._expression = expression
+
+    def resolve(self, state: "BaseState") -> int:
+        expression = resolve_value(self._expression, state)
+
+        if expression is undefined:
+            raise InvalidExpressionException("Cannot get length of undefined value")
+
+        if not hasattr(expression, "__len__"):
+            raise InvalidExpressionException(
+                f"Expected an object that supports `len()`, got `{expression.__class__.__name__}`"
+            )
+
+        try:
+            return len(expression)
+        except TypeError as e:
+            raise InvalidExpressionException(f"Cannot get length of `{expression.__class__.__name__}`: {str(e)}")

vellum/workflows/expressions/minus.py

@@ -0,0 +1,41 @@
+from typing import Any, Generic, Protocol, TypeVar, Union, runtime_checkable
+from typing_extensions import TypeGuard
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+
+@runtime_checkable
+class SupportsMinus(Protocol):
+    def __sub__(self, other: Any) -> Any: ...
+
+
+def has_sub(obj: Any) -> TypeGuard[SupportsMinus]:
+    return hasattr(obj, "__sub__")
+
+
+LHS = TypeVar("LHS")
+RHS = TypeVar("RHS")
+
+
+class MinusExpression(BaseDescriptor[Any], Generic[LHS, RHS]):
+    def __init__(
+        self,
+        *,
+        lhs: Union[BaseDescriptor[LHS], LHS],
+        rhs: Union[BaseDescriptor[RHS], RHS],
+    ) -> None:
+        super().__init__(name=f"{lhs} - {rhs}", types=(object,))
+        self._lhs = lhs
+        self._rhs = rhs
+
+    def resolve(self, state: "BaseState") -> Any:
+        lhs = resolve_value(self._lhs, state)
+        rhs = resolve_value(self._rhs, state)
+
+        if not has_sub(lhs):
+            raise InvalidExpressionException(f"'{lhs.__class__.__name__}' must support the '-' operator")
+
+        return lhs - rhs

vellum/workflows/expressions/tests/test_add.py

@@ -0,0 +1,72 @@
+import pytest
+
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
+from vellum.workflows.expressions.add import AddExpression
+from vellum.workflows.state.base import BaseState
+
+
+class TestState(BaseState):
+    number_value: int = 5
+    string_value: str = "hello"
+
+
+def test_add_expression_numbers():
+    """
+    Tests that AddExpression correctly adds two numbers.
+    """
+
+    state = TestState()
+
+    expression = TestState.number_value.add(10)
+
+    result = expression.resolve(state)
+    assert result == 15
+
+
+def test_add_expression_strings():
+    """
+    Tests that AddExpression correctly concatenates two strings.
+    """
+
+    state = TestState()
+
+    expression = TestState.string_value.add(" world")
+
+    result = expression.resolve(state)
+    assert result == "hello world"
+
+
+def test_add_expression_unsupported_type():
+    """
+    Tests that AddExpression raises an exception for unsupported types.
+    """
+
+    class NoAddSupport:
+        pass
+
+    no_add_obj = NoAddSupport()
+    expression = AddExpression(lhs=no_add_obj, rhs=5)
+    state = TestState()
+
+    with pytest.raises(InvalidExpressionException, match="'NoAddSupport' must support the '\\+' operator"):
+        expression.resolve(state)
+
+
+def test_add_expression_name():
+    """
+    Tests that AddExpression has the correct name.
+    """
+
+    expression = AddExpression(lhs=5, rhs=3)
+
+    assert expression.name == "5 + 3"
+
+
+def test_add_expression_types():
+    """
+    Tests that AddExpression has the correct types.
+    """
+
+    expression = AddExpression(lhs=5, rhs=3)
+
+    assert expression.types == (object,)

vellum/workflows/expressions/tests/test_length.py

@@ -0,0 +1,38 @@
+import pytest
+
+from vellum.workflows.constants import undefined
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
+from vellum.workflows.expressions.length import LengthExpression
+from vellum.workflows.state.base import BaseState
+
+
+class TestState(BaseState):
+    string_value: str = "hello world"
+
+
+def test_length_expression_string():
+    """
+    Tests that LengthExpression correctly returns the length of a string.
+    """
+
+    state = TestState()
+
+    expression = TestState.string_value.length()
+    result = expression.resolve(state)
+
+    assert result == 11
+
+
+def test_length_expression_undefined():
+    """
+    Tests that LengthExpression raises an exception for undefined values.
+    """
+
+    expression = LengthExpression(expression=undefined)
+    state = TestState()
+
+    # THEN we should get an InvalidExpressionException
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        expression.resolve(state)
+
+    assert "Cannot get length of undefined value" in str(exc_info.value)

vellum/workflows/expressions/tests/test_minus.py

@@ -0,0 +1,72 @@
+import pytest
+
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
+from vellum.workflows.expressions.minus import MinusExpression
+from vellum.workflows.state.base import BaseState
+
+
+class TestState(BaseState):
+    number_value: int = 10
+    float_value: float = 15.5
+
+
+def test_minus_expression_numbers():
+    """
+    Tests that MinusExpression correctly subtracts two numbers.
+    """
+
+    state = TestState()
+
+    expression = TestState.number_value.minus(3)
+
+    result = expression.resolve(state)
+    assert result == 7
+
+
+def test_minus_expression_floats():
+    """
+    Tests that MinusExpression correctly subtracts two floats.
+    """
+
+    state = TestState()
+
+    expression = TestState.float_value.minus(5.5)
+
+    result = expression.resolve(state)
+    assert result == 10.0
+
+
+def test_minus_expression_unsupported_type():
+    """
+    Tests that MinusExpression raises an exception for unsupported types.
+    """
+
+    class NoSubSupport:
+        pass
+
+    no_sub_obj = NoSubSupport()
+    expression = MinusExpression(lhs=no_sub_obj, rhs=5)
+    state = TestState()
+
+    with pytest.raises(InvalidExpressionException, match="'NoSubSupport' must support the '-' operator"):
+        expression.resolve(state)
+
+
+def test_minus_expression_name():
+    """
+    Tests that MinusExpression has the correct name.
+    """
+
+    expression = MinusExpression(lhs=10, rhs=3)
+
+    assert expression.name == "10 - 3"
+
+
+def test_minus_expression_types():
+    """
+    Tests that MinusExpression has the correct types.
+    """
+
+    expression = MinusExpression(lhs=10, rhs=3)
+
+    assert expression.types == (object,)

vellum/workflows/integrations/composio_service.py

@@ -151,4 +151,8 @@ class ComposioService:
         if user_id is not None:
             json_data["user_id"] = user_id
         response = self._make_request(endpoint, method="POST", json_data=json_data)
+
+        if not response.get("successful", True):
+            return response.get("error", "Tool execution failed")
+
         return response.get("data", response)

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

@@ -14,7 +14,7 @@ from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior
 from vellum.workflows.types.generics import StateType
 
 
-class BasePromptNode(BaseNode, Generic[StateType]):
+class BasePromptNode(BaseNode[StateType], Generic[StateType]):
     # Inputs that are passed to the Prompt
     prompt_inputs: ClassVar[Optional[EntityInputsInterface]] = None
 

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

@@ -1,5 +1,5 @@
 import json
-from typing import Any, Dict, Iterator, Type, Union
+from typing import Any, Dict, Generic, Iterator, Type, Union
 
 from vellum.workflows.constants import undefined
 from vellum.workflows.errors import WorkflowErrorCode
@@ -10,7 +10,7 @@ from vellum.workflows.types import MergeBehavior
 from vellum.workflows.types.generics import StateType
 
 
-class InlinePromptNode(BaseInlinePromptNode[StateType]):
+class InlinePromptNode(BaseInlinePromptNode[StateType], Generic[StateType]):
     """
     Used to execute a Prompt defined inline.
 

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

@@ -12,6 +12,7 @@ from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.displayable.tool_calling_node.state import ToolCallingState
 from vellum.workflows.nodes.displayable.tool_calling_node.utils import (
+    create_else_node,
     create_function_node,
     create_mcp_tool_node,
     create_tool_router_node,
@@ -171,7 +172,11 @@ class ToolCallingNode(BaseNode[StateType], Generic[StateType]):
             edge_graph = router_port >> FunctionNodeClass >> self.tool_router_node
             graph_set.add(edge_graph)
 
-        default_port = getattr(self.tool_router_node.Ports, "default")
+        else_node = create_else_node(self.tool_router_node)
+        default_port = self.tool_router_node.Ports.default >> {
+            else_node.Ports.loop >> self.tool_router_node,
+            else_node.Ports.end,
+        }
         graph_set.add(default_port)
 
         self._graph = Graph.from_set(graph_set)

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

@@ -7,3 +7,5 @@ from vellum.workflows.state.base import BaseState
 class ToolCallingState(BaseState):
     chat_history: List[ChatMessage] = []
     prompt_iterations: int = 0
+    current_prompt_output_index: int = 0
+    current_function_calls_processed: int = 0

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

@@ -44,6 +44,21 @@ def mock_tool_execution_response():
     }
 
 
+@pytest.fixture
+def mock_tool_execution_error_response():
+    """Mock response for failed tool execution API"""
+    return {
+        "data": {},
+        "successful": False,
+        "error": (
+            'Request failed error: `{"message":"Not Found",'
+            '"documentation_url":"https://docs.github.com/rest/pulls/pulls#get-a-pull-request",'
+            '"status":"404"}`'
+        ),
+        "log_id": "log_raE_fIWNcDPo",
+    }
+
+
 @pytest.fixture
 def composio_service():
     """Create ComposioService with test API key"""
@@ -168,3 +183,37 @@ class TestComposioCoreService:
             timeout=30,
         )
         assert result == {"items": [], "total": 0}
+
+    def test_execute_tool_failure_surfaces_error(
+        self, composio_service, mock_requests, mock_tool_execution_error_response
+    ):
+        """Test that tool execution failures surface detailed error information"""
+        # GIVEN a mock response indicating tool execution failure
+        mock_response = Mock()
+        mock_response.json.return_value = mock_tool_execution_error_response
+        mock_response.raise_for_status.return_value = None
+        mock_requests.post.return_value = mock_response
+
+        # WHEN we execute a tool that fails
+        result = composio_service.execute_tool("GITHUB_GET_PR", {"repo": "test", "pr_number": 999})
+
+        # THEN the result should contain the detailed error message from the API
+        assert "Request failed error" in result
+        assert "Not Found" in result
+
+    def test_execute_tool_failure_with_generic_error_message(self, composio_service, mock_requests):
+        """Test that tool execution failures with missing error field use generic message"""
+        # GIVEN a mock response indicating tool execution failure without error field
+        mock_response = Mock()
+        mock_response.json.return_value = {
+            "data": {},
+            "successful": False,
+        }
+        mock_response.raise_for_status.return_value = None
+        mock_requests.post.return_value = mock_response
+
+        # WHEN we execute a tool that fails
+        result = composio_service.execute_tool("TEST_TOOL", {"param": "value"})
+
+        # THEN the result should contain the generic error message
+        assert result == "Tool execution failed"

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

@@ -1,6 +1,6 @@
 import json
 from uuid import uuid4
-from typing import Any, Iterator, List
+from typing import Any, Iterator
 
 from vellum import ChatMessage
 from vellum.client.types.fulfilled_execute_prompt_event import FulfilledExecutePromptEvent
@@ -15,6 +15,7 @@ from vellum.workflows import BaseWorkflow
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.displayable.tool_calling_node.node import ToolCallingNode
+from vellum.workflows.nodes.displayable.tool_calling_node.state import ToolCallingState
 from vellum.workflows.nodes.displayable.tool_calling_node.utils import create_function_node, create_tool_router_node
 from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.state.base import BaseState, StateMeta
@@ -44,7 +45,7 @@ def test_port_condition_match_function_name():
     )
 
     # AND a state with a function call to the first function
-    state = BaseState(
+    state = ToolCallingState(
         meta=StateMeta(
             node_outputs={
                 router_node.Outputs.results: [
@@ -116,12 +117,6 @@ def test_tool_calling_node_inline_workflow_context():
     )
     function_node._context = parent_context
 
-    # Create a state with chat_history for the function node
-    class TestState(BaseState):
-        chat_history: List[ChatMessage] = []
-
-    function_node.state = TestState(meta=StateMeta(node_outputs={tool_router_node.Outputs.text: '{"arguments": {}}'}))
-
     # WHEN the function node runs
     outputs = list(function_node.run())
 

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

@@ -5,6 +5,8 @@ from typing import Any, Callable, Dict, Iterator, List, Optional, Type, Union, c
 from pydash import snake_case
 
 from vellum import ChatMessage, PromptBlock
+from vellum.client.types.array_chat_message_content import ArrayChatMessageContent
+from vellum.client.types.array_chat_message_content_item import ArrayChatMessageContentItem
 from vellum.client.types.function_call_chat_message_content import FunctionCallChatMessageContent
 from vellum.client.types.function_call_chat_message_content_value import FunctionCallChatMessageContentValue
 from vellum.client.types.function_definition import FunctionDefinition
@@ -59,6 +61,9 @@ class FunctionCallNodeMixin:
                 content=StringChatMessageContent(value=json.dumps(result, cls=DefaultStateEncoder)),
             )
         )
+        with state.__quiet__():
+            state.current_function_calls_processed += 1
+            state.current_prompt_output_index += 1
 
 
 class ToolRouterNode(InlinePromptNode[ToolCallingState]):
@@ -73,29 +78,37 @@ class ToolRouterNode(InlinePromptNode[ToolCallingState]):
             raise NodeException(message=max_iterations_message, code=WorkflowErrorCode.NODE_EXECUTION)
 
         generator = super().run()
+        with self.state.__quiet__():
+            self.state.current_prompt_output_index = 0
+            self.state.current_function_calls_processed = 0
+            self.state.prompt_iterations += 1
         for output in generator:
-            if output.name == "results" and output.value:
-                values = cast(List[Any], output.value)
-                if values and len(values) > 0:
-                    if values[0].type == "STRING":
-                        self.state.chat_history.append(ChatMessage(role="ASSISTANT", text=values[0].value))
-                    elif values[0].type == "FUNCTION_CALL":
-                        self.state.prompt_iterations += 1
-
-                        function_call = values[0].value
-                        if function_call is not None:
-                            self.state.chat_history.append(
-                                ChatMessage(
-                                    role="ASSISTANT",
-                                    content=FunctionCallChatMessageContent(
-                                        value=FunctionCallChatMessageContentValue(
-                                            name=function_call.name,
-                                            arguments=function_call.arguments,
-                                            id=function_call.id,
-                                        ),
-                                    ),
-                                )
+            if output.name == InlinePromptNode.Outputs.results.name and output.value:
+                prompt_outputs = cast(List[PromptOutput], output.value)
+                chat_contents: List[ArrayChatMessageContentItem] = []
+                for prompt_output in prompt_outputs:
+                    if prompt_output.type == "STRING":
+                        chat_contents.append(StringChatMessageContent(value=prompt_output.value))
+                    elif prompt_output.type == "FUNCTION_CALL" and prompt_output.value:
+                        raw_function_call = prompt_output.value.model_dump()
+                        if "state" in raw_function_call:
+                            del raw_function_call["state"]
+                        chat_contents.append(
+                            FunctionCallChatMessageContent(
+                                value=FunctionCallChatMessageContentValue.model_validate(raw_function_call)
                             )
+                        )
+
+                if len(chat_contents) == 1:
+                    if chat_contents[0].type == "STRING":
+                        self.state.chat_history.append(ChatMessage(role="ASSISTANT", text=chat_contents[0].value))
+                    else:
+                        self.state.chat_history.append(ChatMessage(role="ASSISTANT", content=chat_contents[0]))
+                else:
+                    self.state.chat_history.append(
+                        ChatMessage(role="ASSISTANT", content=ArrayChatMessageContent(value=chat_contents))
+                    )
+
             yield output
 
 
@@ -225,42 +238,51 @@ class MCPNode(BaseNode[ToolCallingState], FunctionCallNodeMixin):
         yield from []
 
 
-def _hydrate_composio_tool_definition(tool_def: ComposioToolDefinition) -> ComposioToolDefinition:
+class ElseNode(BaseNode[ToolCallingState]):
+    """Node that executes when no function conditions match."""
+
+    class Ports(BaseNode.Ports):
+        # Redefined in the create_else_node function, but defined here to resolve mypy errors
+        loop = Port.on_if(
+            ToolCallingState.current_prompt_output_index.less_than(1)
+            | ToolCallingState.current_function_calls_processed.greater_than(0)
+        )
+        end = Port.on_else()
+
+    def run(self) -> BaseNode.Outputs:
+        with self.state.__quiet__():
+            self.state.current_prompt_output_index += 1
+        return self.Outputs()
+
+
+def _hydrate_composio_tool_definition(tool_def: ComposioToolDefinition) -> FunctionDefinition:
     """Hydrate a ComposioToolDefinition with detailed information from the Composio API.
 
     Args:
         tool_def: The basic ComposioToolDefinition to enhance
 
     Returns:
-        ComposioToolDefinition with detailed parameters and description
+        FunctionDefinition with detailed parameters and description
     """
     try:
         composio_service = ComposioService()
         tool_details = composio_service.get_tool_by_slug(tool_def.action)
 
-        # Extract toolkit information from API response
-        toolkit_info = tool_details.get("toolkit", {})
-        toolkit_slug = (
-            toolkit_info.get("slug", tool_def.toolkit) if isinstance(toolkit_info, dict) else tool_def.toolkit
-        )
-
-        # Create a version of the tool definition with proper field extraction
-        return ComposioToolDefinition(
-            type=tool_def.type,
-            toolkit=toolkit_slug.upper() if toolkit_slug else tool_def.toolkit,
-            action=tool_details.get("slug", tool_def.action),
+        # Create a FunctionDefinition directly with proper field extraction
+        return FunctionDefinition(
+            name=tool_def.name,
             description=tool_details.get("description", tool_def.description),
-            display_name=tool_details.get("name", tool_def.display_name),
-            parameters=tool_details.get("input_parameters", tool_def.parameters),
-            version=tool_details.get("version", tool_def.version),
-            tags=tool_details.get("tags", tool_def.tags),
-            user_id=tool_def.user_id,
+            parameters=tool_details.get("input_parameters", {}),
         )
 
     except Exception as e:
-        # If hydration fails (including no API key), log and return original
+        # If hydration fails (including no API key), log and return basic function definition
         logger.warning(f"Failed to enhance Composio tool '{tool_def.action}': {e}")
-        return tool_def
+        return FunctionDefinition(
+            name=tool_def.name,
+            description=tool_def.description,
+            parameters={},
+        )
 
 
 def hydrate_mcp_tool_definitions(server_def: MCPServer) -> List[MCPToolDefinition]:
@@ -303,8 +325,13 @@ def create_tool_router_node(
             return Port.on_if(
                 LazyReference(
                     lambda: (
-                        node.Outputs.results[0]["type"].equals("FUNCTION_CALL")
-                        & node.Outputs.results[0]["value"]["name"].equals(fn_name)
+                        ToolCallingState.current_prompt_output_index.less_than(node.Outputs.results.length())
+                        & node.Outputs.results[ToolCallingState.current_prompt_output_index]["type"].equals(
+                            "FUNCTION_CALL"
+                        )
+                        & node.Outputs.results[ToolCallingState.current_prompt_output_index]["value"]["name"].equals(
+                            fn_name
+                        )
                     )
                 )
             )
@@ -313,13 +340,7 @@ def create_tool_router_node(
             if isinstance(function, ComposioToolDefinition):
                 # Get Composio tool details and hydrate the function definition
                 enhanced_function = _hydrate_composio_tool_definition(function)
-                prompt_functions.append(
-                    FunctionDefinition(
-                        name=enhanced_function.name,
-                        description=enhanced_function.description,
-                        parameters=enhanced_function.parameters,
-                    )
-                )
+                prompt_functions.append(enhanced_function)
                 # Create port for this function (using original function for get_function_name)
                 function_name = get_function_name(function)
                 port = create_port_condition(function_name)
@@ -485,6 +506,27 @@ def create_mcp_tool_node(
     return node
 
 
+def create_else_node(
+    tool_router_node: Type[ToolRouterNode],
+) -> Type[ElseNode]:
+    class Ports(ElseNode.Ports):
+        loop = Port.on_if(
+            ToolCallingState.current_prompt_output_index.less_than(tool_router_node.Outputs.results.length())
+            | ToolCallingState.current_function_calls_processed.greater_than(0)
+        )
+        end = Port.on_else()
+
+    node = type(
+        f"{tool_router_node.__name__}_ElseNode",
+        (ElseNode,),
+        {
+            "Ports": Ports,
+            "__module__": __name__,
+        },
+    )
+    return node
+
+
 def get_function_name(function: ToolBase) -> str:
     if isinstance(function, DeploymentDefinition):
         name = str(function.deployment_id or function.deployment_name)

vellum/workflows/types/definition.py

@@ -2,7 +2,7 @@ import importlib
 import inspect
 from types import FrameType
 from uuid import UUID
-from typing import Annotated, Any, Dict, List, Literal, Optional, Union
+from typing import Annotated, Any, Dict, Literal, Optional, Union
 
 from pydantic import BeforeValidator
 
@@ -111,11 +111,6 @@ class ComposioToolDefinition(UniversalBaseModel):
     toolkit: str  # "GITHUB", "SLACK", etc.
     action: str  # Specific action like "GITHUB_CREATE_AN_ISSUE"
     description: str
-
-    display_name: Optional[str] = None
-    parameters: Optional[Dict[str, Any]] = None
-    version: Optional[str] = None
-    tags: Optional[List[str]] = None
     user_id: Optional[str] = None
 
     @property

vellum/workflows/types/tests/test_definition.py

@@ -48,7 +48,7 @@ def test_composio_tool_definition_creation():
     assert composio_tool.toolkit == "GITHUB"
     assert composio_tool.action == "GITHUB_CREATE_AN_ISSUE"
     assert composio_tool.description == "Create a new issue in a GitHub repository"
-    assert composio_tool.display_name is None
+    assert composio_tool.user_id is None
     assert composio_tool.name == "github_create_an_issue"
 
 

{vellum_ai-1.0.10.dist-info → vellum_ai-1.0.11.dist-info}/METADATA

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

{vellum_ai-1.0.10.dist-info → vellum_ai-1.0.11.dist-info}/RECORD

@@ -94,7 +94,7 @@ vellum_ee/workflows/display/tests/workflow_serialization/test_basic_search_node_
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_subworkflow_deployment_serialization.py,sha256=XWrhHg_acLsRHwjstBAii9Pmes9oXFtAUWSAVF1oSBc,11225
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_templating_node_serialization.py,sha256=V8b6gKghLlO7PJI8xeNdnfn8aII0W_IFQvSQBQM62UQ,7721
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_terminal_node_serialization.py,sha256=hDWtKXmGI1CKhTwTNqpu_d5RkE5n7SolMLtgd87KqTI,3856
-vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_composio_serialization.py,sha256=sWKSqw1B4iAEamIzbRJBfjtMCy_D54gxEu3aPSDrS_o,3819
+vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_composio_serialization.py,sha256=AUfULtIangNYkvLH3jd2Ar8X5ulW4tGmezeCfMmXFUU,3697
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_inline_workflow_serialization.py,sha256=4t1lkN2nsZF6lFqP6QnskUQWJlhasF8C2_f6atzk8ZY,26298
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_serialization.py,sha256=B0rDsCvO24qPp0gkmj8SdTDY5CxZYkvKwknsKBuAPyA,10017
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_workflow_deployment_serialization.py,sha256=mova0sPD3evHiHIN1O0VynxlCp-uOcEIKve5Pd_oCDg,4069
@@ -105,7 +105,7 @@ vellum_ee/workflows/display/types.py,sha256=i4T7ElU5b5h-nA1i3scmEhO1BqmNDc4eJDHa
 vellum_ee/workflows/display/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/utils/auto_layout.py,sha256=f4GiLn_LazweupfqTpubcdtdfE_vrOcmZudSsnYIY9E,3906
 vellum_ee/workflows/display/utils/exceptions.py,sha256=LSwwxCYNxFkf5XMUcFkaZKpQ13OSrI7y_bpEUwbKVk0,169
-vellum_ee/workflows/display/utils/expressions.py,sha256=H5_yWpX4QQNr83iIIocOHddTpktsHbVDp1ylayvjjTE,15840
+vellum_ee/workflows/display/utils/expressions.py,sha256=YZjd6wrOkmmnTe5LstKaVaBqmR8Q8XS81QzSFwkLtN0,16324
 vellum_ee/workflows/display/utils/registry.py,sha256=fWIm5Jj-10gNFjgn34iBu4RWv3Vd15ijtSN0V97bpW8,1513
 vellum_ee/workflows/display/utils/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/utils/tests/test_auto_layout.py,sha256=vfXI769418s9vda5Gb5NFBH747WMOwSgHRXeLCTLVm8,2356
@@ -145,7 +145,7 @@ vellum/client/README.md,sha256=Dle5iytCXxP1pNeNd7uZyhFo0rl7tp7vU7s8gmi10OQ,4863
 vellum/client/__init__.py,sha256=KmkyOgReuTsjmXF3WC_dPQ9QqJgYrB3Sr8_LcSUIQyI,125258
 vellum/client/core/__init__.py,sha256=SQ85PF84B9MuKnBwHNHWemSGuy-g_515gFYNFhvEE0I,1438
 vellum/client/core/api_error.py,sha256=RE8LELok2QCjABadECTvtDp7qejA1VmINCh6TbqPwSE,426
-vellum/client/core/client_wrapper.py,sha256=PYKT4GSWVfnUCdamESx8hYo2KF9SVuaYQAHwwHxyYSI,2385
+vellum/client/core/client_wrapper.py,sha256=GLUu-tM9O4VyvaRt1Uz-BgKMqUFNR3H4hdD14V7NGqM,2385
 vellum/client/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 vellum/client/core/file.py,sha256=d4NNbX8XvXP32z8KpK2Xovv33nFfruIrpz0QWxlgpZk,2663
 vellum/client/core/http_client.py,sha256=cKs2w0ybDBk1wHQf-fTALm_MmvaMe3cZKcYJxqmCxkE,19539
@@ -1530,10 +1530,10 @@ vellum/workflows/__init__.py,sha256=CssPsbNvN6rDhoLuqpEv7MMKGa51vE6dvAh6U31Pcio,
 vellum/workflows/constants.py,sha256=2yg4_uo5gpqViy3ZLSwfC8qTybleYCtOnhA4Rj6bacM,1310
 vellum/workflows/context.py,sha256=jvMuyeRluay8BQa7GX1TqUlmoHLCycAVYKkp87sfXSo,1644
 vellum/workflows/descriptors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/descriptors/base.py,sha256=nZeCuuoJj3eJJjhrqOyfBB4FLUkN6fuO8PDdx6YDkzc,15373
+vellum/workflows/descriptors/base.py,sha256=fRnRkECyDjfz2QEDCY9Q5mAerlJ6jR0R4nE-MP2VP_k,16558
 vellum/workflows/descriptors/exceptions.py,sha256=gUy4UD9JFUKSeQnQpeuDSLiRqWjWiIsxLahB7p_q3JY,54
 vellum/workflows/descriptors/tests/test_utils.py,sha256=HJ5DoRz0sJvViGxyZ_FtytZjxN2J8xTkGtaVwCy6Q90,6928
-vellum/workflows/descriptors/utils.py,sha256=1siECBf6AI54gwwUwkF6mP9rYsRryUGaOYBbMpQaceM,3848
+vellum/workflows/descriptors/utils.py,sha256=7QvS_IOZWIoKvhNwpYBOTP3NasLSIBKTnhyASry2HCM,4320
 vellum/workflows/edges/__init__.py,sha256=wSkmAnz9xyi4vZwtDbKxwlplt2skD7n3NsxkvR_pUus,50
 vellum/workflows/edges/edge.py,sha256=N0SnY3gKVuxImPAdCbPMPlHJIXbkQ3fwq_LbJRvVMFc,677
 vellum/workflows/emitters/__init__.py,sha256=d9QFOI3eVg6rzpSFLvrjkDYXWikf1tcp3ruTRa2Boyc,143
@@ -1553,7 +1553,8 @@ vellum/workflows/events/types.py,sha256=jc6vEcydzYETfK3u2Cx1BfUDmYh3Jxa86sdsrrQ5
 vellum/workflows/events/workflow.py,sha256=cR2aG6A-JqvLMKFqonDhKjSg496qldEtuks4BXXMTrY,7768
 vellum/workflows/exceptions.py,sha256=NiBiR3ggfmPxBVqD-H1SqmjI-7mIn0EStSN1BqApvCM,1213
 vellum/workflows/expressions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/expressions/accessor.py,sha256=4OvF9JQKHSyYLTz7gGprcw3Da5-zA8D0Co0j1eIeer0,4141
+vellum/workflows/expressions/accessor.py,sha256=3lu1-_-dBfZdJvtX-q66jbmRAZtqIfdsh_3_JNuzg1E,4462
+vellum/workflows/expressions/add.py,sha256=Rr1O83nksL5Z0kam4eaQOokvDrEwlUg7LqWnXzGUW40,1226
 vellum/workflows/expressions/and_.py,sha256=I7lNqrUM3-m_5hmjjiMhaHhJtKcLj39kEFVWPDOqwfo,916
 vellum/workflows/expressions/begins_with.py,sha256=FnWsQXbENm0ZwkfEP7dR8Qx4_MMrzj6C1yqAV2KaNHw,1123
 vellum/workflows/expressions/between.py,sha256=dVeddT6YA91eOAlE1Utg7C7gnCiYE7WP-dg17yXUeAY,1492
@@ -1578,16 +1579,21 @@ vellum/workflows/expressions/is_not_null.py,sha256=EoHXFgZScKP_BM2a5Z7YFQN6l7RME
 vellum/workflows/expressions/is_not_undefined.py,sha256=9s-RUQBqM17-_nIRvwsHuarLdHVtrxVuwnqBNJEtmh0,735
 vellum/workflows/expressions/is_null.py,sha256=C75ALGlG_sTGcxI46tm9HtgPVfJ7DwTIyKzX8qtEiDU,660
 vellum/workflows/expressions/is_undefined.py,sha256=uUBK3rxYbwoeRq36AGFc7d61hXzTp8UacQAi-1JbaW0,724
+vellum/workflows/expressions/length.py,sha256=Gq4eBXnLLmuyhKHwERcvBd4qLHLkw_JebpZ778gw08M,1274
 vellum/workflows/expressions/less_than.py,sha256=chY9puJ6jDB2EinjfyGNrSplJ1NJC-BB-GGSSB33bqI,1237
 vellum/workflows/expressions/less_than_or_equal_to.py,sha256=JtTDBa8yFKy3fGaCOA1tb_5s1JkY8FFnH6kpoeXGnT4,1267
+vellum/workflows/expressions/minus.py,sha256=qTIuOF3knMwwGiA9BNGvMP6vVw3z0g5wr4LziaYMRIE,1232
 vellum/workflows/expressions/not_between.py,sha256=ZtRJeJDSSlOvajL8YoBoh5o_khjIn9xSSeQCnXYbHFE,1506
 vellum/workflows/expressions/not_in.py,sha256=pFvwkFPsn3WJw61ssFgM2U1dqWEeglfz4FVT4xwm5Mc,1144
 vellum/workflows/expressions/or_.py,sha256=s-8YdMSSCDS2yijR38kguwok3iqmDMMgDYKV93b4O4s,914
 vellum/workflows/expressions/parse_json.py,sha256=xsk6j3HF7bU1yF6fwt5P9Ugcyd5D9ZXrdng11FRilUI,1088
 vellum/workflows/expressions/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/expressions/tests/test_accessor.py,sha256=g2z0mJjuWwVKeXS0yGoFW-aRmT5n_LrhfuBorSmj9kI,7585
+vellum/workflows/expressions/tests/test_add.py,sha256=_MjlRvIGAVM5wve2ru5jc_5Ae4x_ywvh4vN0S2yQ-8M,1615
 vellum/workflows/expressions/tests/test_concat.py,sha256=fDHXlmFvCtqPkdZQD9Qs22i6sJq_MJjbUXCnTlSMvA0,1666
 vellum/workflows/expressions/tests/test_expressions.py,sha256=3b6k8xs-CItBBw95NygFLUNoNPKxI4VA1GyWbkMtqyI,11623
+vellum/workflows/expressions/tests/test_length.py,sha256=pQA1tYSwqxE6euclboY024NXEOs7yaVgwTKkMPYUT08,1035
+vellum/workflows/expressions/tests/test_minus.py,sha256=pq7dvdRGNhSSn95LGNzRErsYUsFk5SpOKHDcSR5QToc,1632
 vellum/workflows/expressions/tests/test_parse_json.py,sha256=zpB_qE5_EwWQL7ULQUJm0o1PRSfWZdAqZNW6Ah13oJE,1059
 vellum/workflows/graph/__init__.py,sha256=3sHlay5d_-uD7j3QJXiGl0WHFZZ_QScRvgyDhN2GhHY,74
 vellum/workflows/graph/graph.py,sha256=GGR8cGpSuNWPIiTWNWsj6l70upb5nIxAyFcn7VdaJIs,5506
@@ -1598,7 +1604,7 @@ vellum/workflows/inputs/base.py,sha256=w3owT5B3rLBmIj-v-jL2l-HD4yd3hXK9RmHVd557B
 vellum/workflows/inputs/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/inputs/tests/test_inputs.py,sha256=lioA8917mFLYq7Ml69UNkqUjcWbbxkxnpIEJ4FBaYBk,2206
 vellum/workflows/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/integrations/composio_service.py,sha256=v1rVQXTh1rnupguj8oIM20V7bSKaJiAoJ5yjz2NeKA8,5906
+vellum/workflows/integrations/composio_service.py,sha256=rSliaZtNiBcDSvDxz9k5i1KkyUIrbxyegu0yU9cDByU,6023
 vellum/workflows/integrations/mcp_service.py,sha256=SaOLg76JBAiBDAMUn04mxVWmf2Btobd1kDjc8B1atng,8712
 vellum/workflows/logging.py,sha256=_a217XogktV4Ncz6xKFz7WfYmZAzkfVRVuC0rWob8ls,437
 vellum/workflows/nodes/__init__.py,sha256=aVdQVv7Y3Ro3JlqXGpxwaU2zrI06plDHD2aumH5WUIs,1157
@@ -1641,7 +1647,7 @@ vellum/workflows/nodes/displayable/bases/api_node/node.py,sha256=iUtdPsbJs1jwo3V
 vellum/workflows/nodes/displayable/bases/api_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/bases/api_node/tests/test_node.py,sha256=Pf51DIyhtUxx-pCu0zJYDB4Z5_IW5mRwkJIoPT53_9I,3894
 vellum/workflows/nodes/displayable/bases/base_prompt_node/__init__.py,sha256=Org3xTvgp1pA0uUXFfnJr29D3HzCey2lEdYF4zbIUgo,70
-vellum/workflows/nodes/displayable/bases/base_prompt_node/node.py,sha256=EJsGaz8Umss6-JWGGYbJp93ZHx3IlZQWAySlHAdNYtY,4466
+vellum/workflows/nodes/displayable/bases/base_prompt_node/node.py,sha256=ea20icDM1HB942wkH-XtXNSNCBDcjeOiN3vowkHL4fs,4477
 vellum/workflows/nodes/displayable/bases/inline_prompt_node/__init__.py,sha256=Hl35IAoepRpE-j4cALaXVJIYTYOF3qszyVbxTj4kS1s,82
 vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py,sha256=hy_fy4zImhpnHuPczKtOLhv_uOmvxvJsQA9Zl9DTmSw,12851
 vellum/workflows/nodes/displayable/bases/inline_prompt_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1672,7 +1678,7 @@ vellum/workflows/nodes/displayable/guardrail_node/test_node.py,sha256=SAGv6hSFcB
 vellum/workflows/nodes/displayable/guardrail_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/guardrail_node/tests/test_node.py,sha256=X2pd6TI8miYxIa7rgvs1pHTEreyWcf77EyR0_Jsa700,2055
 vellum/workflows/nodes/displayable/inline_prompt_node/__init__.py,sha256=gSUOoEZLlrx35-tQhSAd3An8WDwBqyiQh-sIebLU9wU,74
-vellum/workflows/nodes/displayable/inline_prompt_node/node.py,sha256=wgZ9bt9IFe5cqWSghfMlD1NgmFhRnuDLRzXzMhJomV0,2912
+vellum/workflows/nodes/displayable/inline_prompt_node/node.py,sha256=3jY-2UJarVJSz2eupt7c9Mp-Mk56U2meXU0d7c0KVNk,2941
 vellum/workflows/nodes/displayable/inline_prompt_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/inline_prompt_node/tests/test_node.py,sha256=bBHs90mV5SZ3rJPAL0wx4WWyawUA406LgMPOdvpZC_A,10923
 vellum/workflows/nodes/displayable/merge_node/__init__.py,sha256=J8IC08dSH7P76wKlNuxe1sn7toNGtSQdFirUbtPDEs0,60
@@ -1697,13 +1703,13 @@ vellum/workflows/nodes/displayable/tests/test_search_node_error_handling.py,sha2
 vellum/workflows/nodes/displayable/tests/test_search_node_wth_text_output.py,sha256=VepO5z1277c1y5N6LLIC31nnWD1aak2m5oPFplfJHHs,6935
 vellum/workflows/nodes/displayable/tests/test_text_prompt_deployment_node.py,sha256=dc3EEn1sOICpr3GdS8eyeFtExaGwWWcw9eHSdkRhQJU,2584
 vellum/workflows/nodes/displayable/tool_calling_node/__init__.py,sha256=3n0-ysmFKsr40CVxPthc0rfJgqVJeZuUEsCmYudLVRg,117
-vellum/workflows/nodes/displayable/tool_calling_node/node.py,sha256=ftPf7hmPvk_rJeIoxnJGkTLex-kDW1CRuvVDUwUdMxg,7283
-vellum/workflows/nodes/displayable/tool_calling_node/state.py,sha256=oQg_GAtc349nPB5BL_oeDYYD7q1qSDPAqjj8iA8OoAw,215
+vellum/workflows/nodes/displayable/tool_calling_node/node.py,sha256=RFoMIr4CVy50fjuXAFphwfW1oXeZo7s-JY4Bqvlphn0,7460
+vellum/workflows/nodes/displayable/tool_calling_node/state.py,sha256=CcBVb_YtwfSSka4ze678k6-qwmzMSfjfVP8_Y95feSo,302
 vellum/workflows/nodes/displayable/tool_calling_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/nodes/displayable/tool_calling_node/tests/test_composio_service.py,sha256=y7KAqbiJHoya6N5EWv1qgz0htM_Yzz7zjAHVp78IMFo,6919
-vellum/workflows/nodes/displayable/tool_calling_node/tests/test_node.py,sha256=TPafJhCAV6oLg5kTttQw0hL56ct3a2Xatvnld6dK8CY,8628
+vellum/workflows/nodes/displayable/tool_calling_node/tests/test_composio_service.py,sha256=in1fbEz5x1tx3uKv9YXdvOncsHucNL8Ro6Go7lBuuOQ,8962
+vellum/workflows/nodes/displayable/tool_calling_node/tests/test_node.py,sha256=1QwfUOS26pesN6Ckqfm-RVlOSyjuF945vKC20AXedKw,8458
 vellum/workflows/nodes/displayable/tool_calling_node/tests/test_utils.py,sha256=om4FztVQ33jFZK_lbusi6khOM7zgzNCHlUcEb5-r6pU,8361
-vellum/workflows/nodes/displayable/tool_calling_node/utils.py,sha256=fvy0O3YpibWUpw4aLKnk8PdwlRCJC7Z2acjryOTiuxY,19728
+vellum/workflows/nodes/displayable/tool_calling_node/utils.py,sha256=7B_8FY5xEjra3A3k6kcABnrgobqieCKNCEA6ijKKaW8,21284
 vellum/workflows/nodes/experimental/README.md,sha256=eF6DfIL8t-HbF9-mcofOMymKrraiBHDLKTlnBa51ZiE,284
 vellum/workflows/nodes/experimental/__init__.py,sha256=jCQgvZEknXKfuNhGSOou4XPfrPqZ1_XBj5F0n0fgiWM,106
 vellum/workflows/nodes/experimental/openai_chat_completion_node/__init__.py,sha256=lsyD9laR9p7kx5-BXGH2gUTM242UhKy8SMV0SR6S2iE,90
@@ -1751,11 +1757,11 @@ vellum/workflows/tests/test_undefined.py,sha256=zMCVliCXVNLrlC6hEGyOWDnQADJ2g83y
 vellum/workflows/types/__init__.py,sha256=KxUTMBGzuRCfiMqzzsykOeVvrrkaZmTTo1a7SLu8gRM,68
 vellum/workflows/types/code_execution_node_wrappers.py,sha256=3MNIoFZKzVzNS5qFLVuDwMV17QJw72zo7NRf52yMq5A,3074
 vellum/workflows/types/core.py,sha256=TggDVs2lVya33xvu374EDhMC1b7RRlAAs0zWLaF46BA,1385
-vellum/workflows/types/definition.py,sha256=fzWfsfbXLS4sZvjOQMSDoiuSaFo4Ii2kC8AOiPade9o,4602
+vellum/workflows/types/definition.py,sha256=ee55MvZs4scFgI7y3ykIcP_5kSTqb4ojNrtGmnvISTw,4437
 vellum/workflows/types/generics.py,sha256=8jptbEx1fnJV0Lhj0MpCJOT6yNiEWeTOYOwrEAb5CRU,1576
 vellum/workflows/types/stack.py,sha256=h7NE0vXR7l9DevFBIzIAk1Zh59K-kECQtDTKOUunwMY,1314
 vellum/workflows/types/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/types/tests/test_definition.py,sha256=4Qqlf7GpoG9MrLuMCkcRzEZMgwrr7du4DROcB1xfv0E,5050
+vellum/workflows/types/tests/test_definition.py,sha256=AM2uaADSWb6QUAP_CwjeSuNayBjoZ_yQWjYefw0mbGI,5045
 vellum/workflows/types/tests/test_utils.py,sha256=UnZog59tR577mVwqZRqqWn2fScoOU1H6up0EzS8zYhw,2536
 vellum/workflows/types/utils.py,sha256=mTctHITBybpt4855x32oCKALBEcMNLn-9cCmfEKgJHQ,6498
 vellum/workflows/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1776,8 +1782,8 @@ vellum/workflows/workflows/event_filters.py,sha256=GSxIgwrX26a1Smfd-6yss2abGCnad
 vellum/workflows/workflows/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/workflows/tests/test_base_workflow.py,sha256=ptMntHzVyy8ZuzNgeTuk7hREgKQ5UBdgq8VJFSGaW4Y,20832
 vellum/workflows/workflows/tests/test_context.py,sha256=VJBUcyWVtMa_lE5KxdhgMu0WYNYnUQUDvTF7qm89hJ0,2333
-vellum_ai-1.0.10.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-1.0.10.dist-info/METADATA,sha256=j-b34bQSbPMhl5YG7dLuwC4_EZYCtRrdhoTxjXYJ3-U,5555
-vellum_ai-1.0.10.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-1.0.10.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-1.0.10.dist-info/RECORD,,
+vellum_ai-1.0.11.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-1.0.11.dist-info/METADATA,sha256=8M0wZ1WdaD1OxRcbUt8a0g6566qeU-QnXRHQ6heBKiU,5555
+vellum_ai-1.0.11.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-1.0.11.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-1.0.11.dist-info/RECORD,,

vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_composio_serialization.py

@@ -53,10 +53,6 @@ def test_serialize_workflow():
         "toolkit": "GITHUB",
         "action": "GITHUB_CREATE_AN_ISSUE",
         "description": "Create a new issue in a GitHub repository",
-        "display_name": "Create GitHub Issue",
-        "parameters": None,
-        "version": None,
-        "tags": None,
         "user_id": None,
     }
 

vellum_ee/workflows/display/utils/expressions.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel
 from vellum.client.types.logical_operator import LogicalOperator
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.expressions.accessor import AccessorExpression
+from vellum.workflows.expressions.add import AddExpression
 from vellum.workflows.expressions.and_ import AndExpression
 from vellum.workflows.expressions.begins_with import BeginsWithExpression
 from vellum.workflows.expressions.between import BetweenExpression
@@ -26,8 +27,10 @@ from vellum.workflows.expressions.is_not_null import IsNotNullExpression
 from vellum.workflows.expressions.is_not_undefined import IsNotUndefinedExpression
 from vellum.workflows.expressions.is_null import IsNullExpression
 from vellum.workflows.expressions.is_undefined import IsUndefinedExpression
+from vellum.workflows.expressions.length import LengthExpression
 from vellum.workflows.expressions.less_than import LessThanExpression
 from vellum.workflows.expressions.less_than_or_equal_to import LessThanOrEqualToExpression
+from vellum.workflows.expressions.minus import MinusExpression
 from vellum.workflows.expressions.not_between import NotBetweenExpression
 from vellum.workflows.expressions.not_in import NotInExpression
 from vellum.workflows.expressions.or_ import OrExpression
@@ -96,6 +99,12 @@ def convert_descriptor_to_operator(descriptor: BaseDescriptor) -> LogicalOperato
         return "coalesce"
     elif isinstance(descriptor, ParseJsonExpression):
         return "parseJson"
+    elif isinstance(descriptor, LengthExpression):
+        return "length"
+    elif isinstance(descriptor, AddExpression):
+        return "+"
+    elif isinstance(descriptor, MinusExpression):
+        return "-"
     else:
         raise ValueError(f"Unsupported descriptor type: {descriptor}")
 
@@ -133,6 +142,7 @@ def _serialize_condition(display_context: "WorkflowDisplayContext", condition: B
             IsNotNilExpression,
             IsUndefinedExpression,
             IsNotUndefinedExpression,
+            LengthExpression,
             ParseJsonExpression,
         ),
     ):
@@ -157,6 +167,7 @@ def _serialize_condition(display_context: "WorkflowDisplayContext", condition: B
     elif isinstance(
         condition,
         (
+            AddExpression,
             AndExpression,
             BeginsWithExpression,
             CoalesceExpression,
@@ -172,6 +183,7 @@ def _serialize_condition(display_context: "WorkflowDisplayContext", condition: B
             InExpression,
             LessThanExpression,
             LessThanOrEqualToExpression,
+            MinusExpression,
             NotInExpression,
             OrExpression,
         ),