vellum-ai 1.0.3__py3-none-any.whl → 1.0.5__py3-none-any.whl

vellum/__init__.py

@@ -217,6 +217,7 @@ from .client.types import (
     MlModelRead,
     MlModelUsage,
     MlModelUsageWrapper,
+    NameEnum,
     NamedScenarioInputChatHistoryVariableValueRequest,
     NamedScenarioInputJsonVariableValueRequest,
     NamedScenarioInputRequest,
@@ -867,6 +868,7 @@ __all__ = [
     "MlModelRead",
     "MlModelUsage",
     "MlModelUsageWrapper",
+    "NameEnum",
     "NamedScenarioInputChatHistoryVariableValueRequest",
     "NamedScenarioInputJsonVariableValueRequest",
     "NamedScenarioInputRequest",

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.3",
+            "User-Agent": "vellum-ai/1.0.5",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.0.3",
+            "X-Fern-SDK-Version": "1.0.5",
         }
         if self._api_version is not None:
             headers["X-API-Version"] = self._api_version

vellum/client/types/__init__.py

@@ -225,6 +225,7 @@ from .metric_node_result import MetricNodeResult
 from .ml_model_read import MlModelRead
 from .ml_model_usage import MlModelUsage
 from .ml_model_usage_wrapper import MlModelUsageWrapper
+from .name_enum import NameEnum
 from .named_scenario_input_chat_history_variable_value_request import NamedScenarioInputChatHistoryVariableValueRequest
 from .named_scenario_input_json_variable_value_request import NamedScenarioInputJsonVariableValueRequest
 from .named_scenario_input_request import NamedScenarioInputRequest
@@ -847,6 +848,7 @@ __all__ = [
     "MlModelRead",
     "MlModelUsage",
     "MlModelUsageWrapper",
+    "NameEnum",
     "NamedScenarioInputChatHistoryVariableValueRequest",
     "NamedScenarioInputJsonVariableValueRequest",
     "NamedScenarioInputRequest",

vellum/client/types/name_enum.py

@@ -0,0 +1,7 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+NameEnum = typing.Union[
+    typing.Literal["workflow_executions", "prompt_executions", "workflow_runtime_seconds"], typing.Any
+]

vellum/client/types/organization_limit_config.py

@@ -13,6 +13,7 @@ class OrganizationLimitConfig(UniversalBaseModel):
     prompt_executions_quota: typing.Optional[Quota] = None
     workflow_executions_quota: typing.Optional[Quota] = None
     workflow_runtime_seconds_quota: typing.Optional[Quota] = None
+    max_workflow_runtime_seconds: typing.Optional[int] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

vellum/client/types/quota.py

@@ -1,13 +1,14 @@
 # This file was auto-generated by Fern from our API Definition.
 
 from ..core.pydantic_utilities import UniversalBaseModel
+from .name_enum import NameEnum
 import typing
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import pydantic
 
 
 class Quota(UniversalBaseModel):
-    name: str
+    name: NameEnum
     value: typing.Optional[int] = None
     period_seconds: typing.Optional[int] = None
 

vellum/prompts/blocks/compilation.py

@@ -105,7 +105,11 @@ def compile_prompt_blocks(
                         cache_config=block.cache_config,
                     )
                 )
-            elif compiled_input == "JSON":
+            elif compiled_input.type == "JSON":
+                # Skip empty JSON arrays when there are chat message blocks present
+                if compiled_input.value == [] and any(block.block_type == "CHAT_MESSAGE" for block in compiled_blocks):
+                    continue
+
                 compiled_blocks.append(
                     CompiledValuePromptBlock(
                         content=JsonVellumValue(value=compiled_input.value),

vellum/prompts/blocks/tests/test_compilation.py

@@ -10,7 +10,10 @@ from vellum import (
     VariablePromptBlock,
     VellumVariable,
 )
+from vellum.client.types.json_vellum_value import JsonVellumValue
 from vellum.client.types.number_input import NumberInput
+from vellum.client.types.prompt_block import PromptBlock
+from vellum.client.types.prompt_request_json_input import PromptRequestJsonInput
 from vellum.prompts.blocks.compilation import compile_prompt_blocks
 from vellum.prompts.blocks.types import CompiledChatMessagePromptBlock, CompiledValuePromptBlock
 
@@ -146,3 +149,64 @@ def test_compile_prompt_blocks__happy(blocks, inputs, input_variables, expected)
     actual = compile_prompt_blocks(blocks=blocks, inputs=inputs, input_variables=input_variables)
 
     assert actual == expected
+
+
+def test_compile_prompt_blocks__empty_json_variable_with_chat_message_blocks():
+    """Test JSON variable handling logic, specifically the empty array skipping behavior."""
+
+    # GIVEN empty array with chat message blocks
+    blocks_with_chat: list[PromptBlock] = [
+        ChatMessagePromptBlock(
+            chat_role="USER",
+            blocks=[RichTextPromptBlock(blocks=[PlainTextPromptBlock(text="User message")])],
+        ),
+        VariablePromptBlock(input_variable="json_data"),
+    ]
+
+    inputs_with_empty_json = [PromptRequestJsonInput(key="json_data", value=[], type="JSON")]
+
+    input_variables = [VellumVariable(id="901ec2d6-430c-4341-b963-ca689006f5cc", type="JSON", key="json_data")]
+
+    # THEN the empty JSON array should be skipped when there are chat message blocks
+    expected_with_chat = [
+        CompiledChatMessagePromptBlock(
+            role="USER",
+            blocks=[CompiledValuePromptBlock(content=StringVellumValue(value="User message"))],
+        ),
+    ]
+
+    actual = compile_prompt_blocks(
+        blocks=blocks_with_chat, inputs=inputs_with_empty_json, input_variables=input_variables
+    )
+    assert actual == expected_with_chat
+
+
+def test_compile_prompt_blocks__non_empty_json_variable_with_chat_message_blocks():
+    """Test that non-empty JSON variables are included even when there are chat message blocks."""
+
+    # GIVEN non-empty JSON with chat message blocks
+    blocks_with_chat: list[PromptBlock] = [
+        ChatMessagePromptBlock(
+            chat_role="USER",
+            blocks=[RichTextPromptBlock(blocks=[PlainTextPromptBlock(text="User message")])],
+        ),
+        VariablePromptBlock(input_variable="json_data"),
+    ]
+
+    inputs_with_non_empty_json = [PromptRequestJsonInput(key="json_data", value={"key": "value"}, type="JSON")]
+
+    input_variables = [VellumVariable(id="901ec2d6-430c-4341-b963-ca689006f5cc", type="JSON", key="json_data")]
+
+    # THEN the non-empty JSON should be included
+    expected_with_non_empty = [
+        CompiledChatMessagePromptBlock(
+            role="USER",
+            blocks=[CompiledValuePromptBlock(content=StringVellumValue(value="User message"))],
+        ),
+        CompiledValuePromptBlock(content=JsonVellumValue(value={"key": "value"})),
+    ]
+
+    actual = compile_prompt_blocks(
+        blocks=blocks_with_chat, inputs=inputs_with_non_empty_json, input_variables=input_variables
+    )
+    assert actual == expected_with_non_empty

vellum/types/name_enum.py

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

vellum/workflows/descriptors/base.py

@@ -6,6 +6,7 @@ if TYPE_CHECKING:
     from vellum.workflows.expressions.begins_with import BeginsWithExpression
     from vellum.workflows.expressions.between import BetweenExpression
     from vellum.workflows.expressions.coalesce_expression import CoalesceExpression
+    from vellum.workflows.expressions.concat import ConcatExpression
     from vellum.workflows.expressions.contains import ContainsExpression
     from vellum.workflows.expressions.does_not_begin_with import DoesNotBeginWithExpression
     from vellum.workflows.expressions.does_not_contain import DoesNotContainExpression
@@ -364,3 +365,14 @@ class BaseDescriptor(Generic[_T]):
         from vellum.workflows.expressions.is_error import IsErrorExpression
 
         return IsErrorExpression(expression=self)
+
+    @overload
+    def concat(self, other: "BaseDescriptor[_O]") -> "ConcatExpression[_T, _O]": ...
+
+    @overload
+    def concat(self, other: _O) -> "ConcatExpression[_T, _O]": ...
+
+    def concat(self, other: "Union[BaseDescriptor[_O], _O]") -> "ConcatExpression[_T, _O]":
+        from vellum.workflows.expressions.concat import ConcatExpression
+
+        return ConcatExpression(lhs=self, rhs=other)

vellum/workflows/expressions/concat.py

@@ -0,0 +1,32 @@
+from typing import Generic, TypeVar, Union
+
+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
+
+LHS = TypeVar("LHS")
+RHS = TypeVar("RHS")
+
+
+class ConcatExpression(BaseDescriptor[list], Generic[LHS, RHS]):
+    def __init__(
+        self,
+        *,
+        lhs: Union[BaseDescriptor[LHS], LHS],
+        rhs: Union[BaseDescriptor[RHS], RHS],
+    ) -> None:
+        super().__init__(name=f"{lhs} + {rhs}", types=(list,))
+        self._lhs = lhs
+        self._rhs = rhs
+
+    def resolve(self, state: "BaseState") -> list:
+        lval = resolve_value(self._lhs, state)
+        rval = resolve_value(self._rhs, state)
+
+        if not isinstance(lval, list):
+            raise InvalidExpressionException(f"Expected LHS to be a list, got {type(lval)}")
+        if not isinstance(rval, list):
+            raise InvalidExpressionException(f"Expected RHS to be a list, got {type(rval)}")
+
+        return lval + rval

vellum/workflows/expressions/tests/test_concat.py

@@ -0,0 +1,53 @@
+import pytest
+
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
+from vellum.workflows.references.constant import ConstantValueReference
+from vellum.workflows.state.base import BaseState
+
+
+class TestState(BaseState):
+    pass
+
+
+def test_concat_expression_happy_path():
+    # GIVEN two lists
+    state = TestState()
+    lhs_ref = ConstantValueReference([1, 2, 3])
+    rhs_ref = ConstantValueReference([4, 5, 6])
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we resolve the expression
+    result = concat_expr.resolve(state)
+
+    # THEN the lists should be concatenated
+    assert result == [1, 2, 3, 4, 5, 6]
+
+
+def test_concat_expression_lhs_fail():
+    # GIVEN a non-list lhs and a list rhs
+    state = TestState()
+    lhs_ref = ConstantValueReference(0)
+    rhs_ref = ConstantValueReference([4, 5, 6])
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we attempt to resolve the expression
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        concat_expr.resolve(state)
+
+    # THEN an exception should be raised
+    assert "Expected LHS to be a list, got <class 'int'>" in str(exc_info.value)
+
+
+def test_concat_expression_rhs_fail():
+    # GIVEN a list lhs and a non-list rhs
+    state = TestState()
+    lhs_ref = ConstantValueReference([1, 2, 3])
+    rhs_ref = ConstantValueReference(False)
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we attempt to resolve the expression
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        concat_expr.resolve(state)
+
+    # THEN an exception should be raised
+    assert "Expected RHS to be a list, got <class 'bool'>" in str(exc_info.value)

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

@@ -64,8 +64,7 @@ class InlinePromptNode(BaseInlinePromptNode[StateType]):
             elif output.type == "FUNCTION_CALL":
                 string_outputs.append(output.value.model_dump_json(indent=4))
             elif output.type == "THINKING":
-                if output.value.type == "STRING":
-                    string_outputs.append(output.value.value)
+                continue
             else:
                 string_outputs.append(output.value.message)
 

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

@@ -66,8 +66,7 @@ class PromptDeploymentNode(BasePromptDeploymentNode[StateType]):
             elif output.type == "FUNCTION_CALL":
                 string_outputs.append(output.value.model_dump_json(indent=4))
             elif output.type == "THINKING":
-                if output.value.type == "STRING":
-                    string_outputs.append(output.value.value)
+                continue
             else:
                 string_outputs.append(output.value.message)
 

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

@@ -0,0 +1,83 @@
+from dataclasses import dataclass
+from typing import Any, Dict, List
+
+from composio import Action, Composio
+from composio_client import Composio as ComposioClient
+
+
+@dataclass
+class ConnectionInfo:
+    """Information about a user's authorized connection"""
+
+    connection_id: str
+    integration_name: str
+    created_at: str
+    updated_at: str
+    status: str = "ACTIVE"  # TODO: Use enum if we end up supporting integrations that the user has not yet connected to
+
+
+class ComposioAccountService:
+    """Manages user authorized connections using composio-client"""
+
+    def __init__(self, api_key: str):
+        self.client = ComposioClient(api_key=api_key)
+
+    def get_user_connections(self) -> List[ConnectionInfo]:
+        """Get all authorized connections for the user"""
+        response = self.client.connected_accounts.list()
+
+        return [
+            ConnectionInfo(
+                connection_id=item.id,
+                integration_name=item.toolkit.slug,
+                status=item.status,
+                created_at=item.created_at,
+                updated_at=item.updated_at,
+            )
+            for item in response.items
+        ]
+
+
+class ComposioCoreService:
+    """Handles tool execution using composio-core"""
+
+    def __init__(self, api_key: str):
+        self.client = Composio(api_key=api_key)
+
+    def execute_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Any:
+        """Execute a tool using composio-core
+
+        Args:
+            tool_name: The name of the tool to execute (e.g., "HACKERNEWS_GET_USER")
+            arguments: Dictionary of arguments to pass to the tool
+
+        Returns:
+            The result of the tool execution
+        """
+        # Convert tool name string to Action enum
+        action = getattr(Action, tool_name)
+        return self.client.actions.execute(action, params=arguments)
+
+
+class ComposioService:
+    """Unified interface for Composio operations"""
+
+    def __init__(self, api_key: str):
+        self.accounts = ComposioAccountService(api_key)
+        self.core = ComposioCoreService(api_key)
+
+    def get_user_connections(self) -> List[ConnectionInfo]:
+        """Get user's authorized connections"""
+        return self.accounts.get_user_connections()
+
+    def execute_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Any:
+        """Execute a tool using composio-core
+
+        Args:
+            tool_name: The name of the tool to execute (e.g., "HACKERNEWS_GET_USER")
+            arguments: Dictionary of arguments to pass to the tool
+
+        Returns:
+            The result of the tool execution
+        """
+        return self.core.execute_tool(tool_name, arguments)

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

@@ -0,0 +1,122 @@
+import pytest
+from unittest.mock import Mock, patch
+
+from vellum.workflows.nodes.displayable.tool_calling_node.composio_service import ComposioService, ConnectionInfo
+
+
+@pytest.fixture
+def mock_composio_client():
+    """Mock the Composio client completely"""
+    with patch("vellum.workflows.nodes.displayable.tool_calling_node.composio_service.ComposioClient") as mock_composio:
+        yield mock_composio.return_value
+
+
+@pytest.fixture
+def mock_connected_accounts_response():
+    """Mock response for connected accounts"""
+    mock_item1 = Mock()
+    mock_item1.id = "conn-123"
+    mock_item1.toolkit.slug = "github"
+    mock_item1.status = "ACTIVE"
+    mock_item1.created_at = "2023-01-01T00:00:00Z"
+    mock_item1.updated_at = "2023-01-15T10:30:00Z"
+
+    mock_item2 = Mock()
+    mock_item2.id = "conn-456"
+    mock_item2.toolkit.slug = "slack"
+    mock_item2.status = "ACTIVE"
+    mock_item2.created_at = "2023-01-01T00:00:00Z"
+    mock_item2.updated_at = "2023-01-10T08:00:00Z"
+
+    mock_response = Mock()
+    mock_response.items = [mock_item1, mock_item2]
+
+    return mock_response
+
+
+@pytest.fixture
+def mock_composio_core_client():
+    """Mock the composio-core Composio client"""
+    with patch("vellum.workflows.nodes.displayable.tool_calling_node.composio_service.Composio") as mock_composio:
+        yield mock_composio.return_value
+
+
+@pytest.fixture
+def mock_action():
+    """Mock the Action class and specific actions"""
+    with patch("vellum.workflows.nodes.displayable.tool_calling_node.composio_service.Action") as mock_action_class:
+        # Mock a specific action
+        mock_hackernews_action = Mock()
+        mock_action_class.HACKERNEWS_GET_USER = mock_hackernews_action
+        mock_action_class.GITHUB_GET_USER = Mock()
+        yield mock_action_class
+
+
+@pytest.fixture
+def composio_service(mock_composio_client, mock_composio_core_client):
+    """Create ComposioService with mocked clients"""
+    return ComposioService(api_key="test-key")
+
+
+class TestComposioAccountService:
+    """Test suite for ComposioAccountService"""
+
+    def test_get_user_connections_success(
+        self, composio_service, mock_composio_client, mock_connected_accounts_response
+    ):
+        """Test successful retrieval of user connections"""
+        # GIVEN the Composio client returns a valid response with two connections
+        mock_composio_client.connected_accounts.list.return_value = mock_connected_accounts_response
+
+        # WHEN we request user connections
+        result = composio_service.get_user_connections()
+
+        # THEN we get two properly formatted ConnectionInfo objects
+        assert len(result) == 2
+        assert isinstance(result[0], ConnectionInfo)
+        assert result[0].connection_id == "conn-123"
+        assert result[0].integration_name == "github"
+        assert result[0].status == "ACTIVE"
+        assert result[0].created_at == "2023-01-01T00:00:00Z"
+        assert result[0].updated_at == "2023-01-15T10:30:00Z"
+
+        assert result[1].connection_id == "conn-456"
+        assert result[1].integration_name == "slack"
+        assert result[1].status == "ACTIVE"
+        assert result[1].created_at == "2023-01-01T00:00:00Z"
+        assert result[1].updated_at == "2023-01-10T08:00:00Z"
+
+        mock_composio_client.connected_accounts.list.assert_called_once()
+
+    def test_get_user_connections_empty_response(self, composio_service, mock_composio_client):
+        """Test handling of empty connections response"""
+        # GIVEN the Composio client returns an empty response
+        mock_response = Mock()
+        mock_response.items = []
+        mock_composio_client.connected_accounts.list.return_value = mock_response
+
+        # WHEN we request user connections
+        result = composio_service.get_user_connections()
+
+        # THEN we get an empty list
+        assert result == []
+
+
+class TestComposioCoreService:
+    """Test suite for ComposioCoreService"""
+
+    def test_execute_tool_success(self, composio_service, mock_composio_core_client, mock_action):
+        """Test executing a tool with complex argument structure"""
+        # GIVEN complex arguments and a mock response
+        complex_args = {"filters": {"status": "active"}, "limit": 10, "sort": "created_at"}
+        expected_result = {"items": [], "total": 0}
+        mock_composio_core_client.actions.execute.return_value = expected_result
+
+        # WHEN we execute a tool with complex arguments
+        result = composio_service.execute_tool("HACKERNEWS_GET_USER", complex_args)
+
+        # THEN the arguments are passed through correctly
+        mock_composio_core_client.actions.execute.assert_called_once_with(
+            mock_action.HACKERNEWS_GET_USER, params=complex_args
+        )
+        assert result == expected_result

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

@@ -1,10 +1,12 @@
+import pytest
+
 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.utils import get_function_name
 from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.state.base import BaseState
-from vellum.workflows.types.definition import DeploymentDefinition
+from vellum.workflows.types.definition import ComposioToolDefinition, DeploymentDefinition
 
 
 def test_get_function_name_callable():
@@ -56,3 +58,21 @@ def test_get_function_name_subworkflow_deployment_uuid():
     result = get_function_name(deployment_config)
 
     assert result == "57f09bebb46340e0bf9ec972e664352f"
+
+
+@pytest.mark.parametrize(
+    "toolkit,action,description,expected_result",
+    [
+        ("SLACK", "SLACK_SEND_MESSAGE", "Send message to Slack", "slack_send_message"),
+        ("GMAIL", "GMAIL_CREATE_EMAIL_DRAFT", "Create Gmail draft", "gmail_create_email_draft"),
+    ],
+)
+def test_get_function_name_composio_tool_definition_various_toolkits(
+    toolkit: str, action: str, description: str, expected_result: str
+):
+    """Test ComposioToolDefinition function name generation with various toolkits."""
+    composio_tool = ComposioToolDefinition(toolkit=toolkit, action=action, description=description)
+
+    result = get_function_name(composio_tool)
+
+    assert result == expected_result