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

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/emitters/vellum_emitter.py

@@ -41,7 +41,7 @@ class VellumEmitter(BaseWorkflowEmitter):
         super().__init__()
         self._timeout = timeout
         self._max_retries = max_retries
-        self._events_endpoint = "events"  # TODO: make this configurable with the correct url
+        self._events_endpoint = "v1/events"  # TODO: make this configurable with the correct url
 
     def emit_event(self, event: WorkflowEvent) -> None:
         """
@@ -90,7 +90,8 @@ class VellumEmitter(BaseWorkflowEmitter):
                 base_url = client._client_wrapper.get_environment().default
                 response = client._client_wrapper.httpx_client.request(
                     method="POST",
-                    path=f"{base_url}/{self._events_endpoint}",  # TODO: will be replaced with the correct url
+                    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},

vellum/workflows/events/types.py

@@ -80,6 +80,11 @@ class UnknownParentContext(BaseParentContext):
     type: Literal["UNKNOWN"] = "UNKNOWN"
 
 
+# Setting external parent context for external workflows
+class ExternalParentContext(BaseParentContext):
+    type: Literal["EXTERNAL"] = "EXTERNAL"
+
+
 def _cast_parent_context_discriminator(v: Any) -> Any:
     if v in PARENT_CONTEXT_TYPES:
         return v
@@ -138,6 +143,7 @@ ParentContext = Annotated[
         PromptDeploymentParentContext,
         WorkflowSandboxParentContext,
         APIRequestParentContext,
+        ExternalParentContext,
         UnknownParentContext,
     ],
     ParentContextDiscriminator(),

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/tests/test_text_prompt_deployment_node.py

@@ -1,4 +1,3 @@
-from unittest import mock
 from uuid import uuid4
 from typing import Any, Iterator, List
 
@@ -64,17 +63,8 @@ def test_text_prompt_deployment_node__basic(vellum_client):
     assert text_output.value == "Hello, world!"
 
     # AND we should have made the expected call to stream the prompt execution
-    vellum_client.execute_prompt_stream.assert_called_once_with(
-        expand_meta=None,
-        expand_raw=None,
-        external_id=None,
-        inputs=[],
-        metadata=None,
-        prompt_deployment_id=None,
-        prompt_deployment_name="my-deployment",
-        raw_overrides=None,
-        release_tag="LATEST",
-        request_options={
-            "additional_body_parameters": {"execution_context": {"parent_context": None, "trace_id": mock.ANY}}
-        },
-    )
+    vellum_client.execute_prompt_stream.assert_called_once()
+    _, call_kwargs = vellum_client.execute_prompt_stream.call_args
+    exec_ctx = call_kwargs["request_options"]["additional_body_parameters"]["execution_context"]
+    assert exec_ctx["parent_context"] is not None
+    assert exec_ctx["parent_context"]["type"] == "EXTERNAL"

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

@@ -12,8 +12,10 @@ 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_router_node,
     create_tool_router_node,
     get_function_name,
     get_mcp_tool_name,
@@ -144,6 +146,11 @@ class ToolCallingNode(BaseNode[StateType], Generic[StateType]):
             max_prompt_iterations=self.max_prompt_iterations,
         )
 
+        self.router_node = create_router_node(
+            functions=self.functions,
+            tool_router_node=self.tool_router_node,
+        )
+
         self._function_nodes = {}
         for function in self.functions:
             if isinstance(function, MCPServer):
@@ -171,7 +178,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"