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

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

@@ -12,6 +12,7 @@ from vellum.client.types.string_chat_message_content import StringChatMessageCon
 from vellum.client.types.variable_prompt_block import VariablePromptBlock
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
+from vellum.workflows.expressions.concat import ConcatExpression
 from vellum.workflows.inputs import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.core.inline_subworkflow_node.node import InlineSubworkflowNode
@@ -24,7 +25,7 @@ from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.state import BaseState
 from vellum.workflows.state.encoder import DefaultStateEncoder
 from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior, Tool
-from vellum.workflows.types.definition import DeploymentDefinition
+from vellum.workflows.types.definition import ComposioToolDefinition, DeploymentDefinition
 from vellum.workflows.types.generics import is_workflow_class
 
 CHAT_HISTORY_VARIABLE = "chat_history"
@@ -41,10 +42,6 @@ class ToolRouterNode(InlinePromptNode[ToolCallingState]):
             max_iterations_message = f"Maximum number of prompt iterations `{self.max_prompt_iterations}` reached."
             raise NodeException(message=max_iterations_message, code=WorkflowErrorCode.NODE_EXECUTION)
 
-        # Merge user-provided chat history with node's chat history
-        user_chat_history = self.prompt_inputs.get(CHAT_HISTORY_VARIABLE, []) if self.prompt_inputs else []
-        merged_chat_history = user_chat_history + self.state.chat_history
-        self.prompt_inputs = {**self.prompt_inputs, CHAT_HISTORY_VARIABLE: merged_chat_history}  # type: ignore
         generator = super().run()
         for output in generator:
             if output.name == "results" and output.value:
@@ -234,6 +231,14 @@ def create_tool_router_node(
             )
         )
 
+    node_prompt_inputs = {
+        **(prompt_inputs or {}),
+        CHAT_HISTORY_VARIABLE: ConcatExpression[List[ChatMessage], List[ChatMessage]](
+            lhs=(prompt_inputs or {}).get(CHAT_HISTORY_VARIABLE, []),
+            rhs=ToolCallingState.chat_history,
+        ),
+    }
+
     node = cast(
         Type[ToolRouterNode],
         type(
@@ -243,7 +248,7 @@ def create_tool_router_node(
                 "ml_model": ml_model,
                 "blocks": blocks,
                 "functions": functions,
-                "prompt_inputs": prompt_inputs,
+                "prompt_inputs": node_prompt_inputs,
                 "parameters": parameters,
                 "max_prompt_iterations": max_prompt_iterations,
                 "Ports": Ports,
@@ -285,6 +290,21 @@ def create_function_node(
 
         return node
 
+    elif isinstance(function, ComposioToolDefinition):
+        # ComposioToolDefinition execution not yet implemented
+        def composio_not_implemented(**kwargs):
+            raise NotImplementedError("ComposioToolDefinition execution not yet implemented")
+
+        node = type(
+            f"ComposioNode_{function.name}",
+            (FunctionNode,),
+            {
+                "function_definition": composio_not_implemented,
+                "function_call_output": tool_router_node.Outputs.results,
+                "__module__": __name__,
+            },
+        )
+
     elif is_workflow_class(function):
         node = type(
             f"DynamicInlineSubworkflowNode_{function.__name__}",
@@ -314,5 +334,7 @@ def get_function_name(function: Tool) -> str:
     if isinstance(function, DeploymentDefinition):
         name = str(function.deployment_id or function.deployment_name)
         return name.replace("-", "")
+    elif isinstance(function, ComposioToolDefinition):
+        return function.name
     else:
         return snake_case(function.__name__)

vellum/workflows/types/core.py

@@ -13,7 +13,7 @@ from typing import (  # type: ignore[attr-defined]
 )
 
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
-from vellum.workflows.types.definition import DeploymentDefinition
+from vellum.workflows.types.definition import ComposioToolDefinition, DeploymentDefinition
 
 if TYPE_CHECKING:
     from vellum.workflows.workflows.base import BaseWorkflow
@@ -50,4 +50,4 @@ class ConditionType(Enum):
 
 
 # Type alias for functions that can be called in tool calling nodes
-Tool = Union[Callable[..., Any], DeploymentDefinition, Type["BaseWorkflow"]]
+Tool = Union[Callable[..., Any], DeploymentDefinition, Type["BaseWorkflow"], ComposioToolDefinition]

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, Optional, Union
+from typing import Annotated, Any, Dict, Literal, Optional, Union
 
 from pydantic import BeforeValidator
 
@@ -97,3 +97,22 @@ class DeploymentDefinition(UniversalBaseModel):
         if not self._is_uuid():
             return self.deployment
         return None
+
+
+class ComposioToolDefinition(UniversalBaseModel):
+    """Represents a specific Composio action that can be used in Tool Calling Node"""
+
+    type: Literal["COMPOSIO"] = "COMPOSIO"
+
+    # Core identification
+    toolkit: str  # "GITHUB", "SLACK", etc.
+    action: str  # Specific action like "GITHUB_CREATE_AN_ISSUE"
+    description: str
+
+    # Optional cached metadata
+    display_name: Optional[str] = None
+
+    @property
+    def name(self) -> str:
+        """Generate a function name for this tool"""
+        return self.action.lower()

vellum/workflows/types/tests/test_definition.py

@@ -1,7 +1,7 @@
 import pytest
 from uuid import UUID
 
-from vellum.workflows.types.definition import DeploymentDefinition
+from vellum.workflows.types.definition import ComposioToolDefinition, DeploymentDefinition
 
 
 @pytest.mark.parametrize(
@@ -31,3 +31,16 @@ def test_deployment_definition(deployment_value, expected_deployment_id, expecte
 
     assert deployment.deployment_id == expected_deployment_id
     assert deployment.deployment_name == expected_deployment_name
+
+
+def test_composio_tool_definition_creation():
+    """Test that ComposioToolDefinition can be created with required fields."""
+    composio_tool = ComposioToolDefinition(
+        toolkit="GITHUB", action="GITHUB_CREATE_AN_ISSUE", description="Create a new issue in a GitHub repository"
+    )
+
+    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.name == "github_create_an_issue"

{vellum_ai-1.0.3.dist-info → vellum_ai-1.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 1.0.3
+Version: 1.0.4
 Summary: 
 License: MIT
 Requires-Python: >=3.9,<4.0
@@ -22,6 +22,8 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Dist: Jinja2 (>=3.1.0,<4.0.0)
 Requires-Dist: click (>=8.1.7,<9.0.0)
+Requires-Dist: composio-client (>=1.5.0,<2.0.0)
+Requires-Dist: composio-core (>=0.7.20,<1.0.0)
 Requires-Dist: docker (>=7.1.0,<8.0.0)
 Requires-Dist: httpx (>=0.21.2)
 Requires-Dist: openai (>=1.0.0,<2.0.0)

{vellum_ai-1.0.3.dist-info → vellum_ai-1.0.4.dist-info}/RECORD

@@ -144,7 +144,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=hWvEhwi9Wp5EJXEwxdFG2CgGyBpzEihn6uuDg5PNZ6c,2383
+vellum/client/core/client_wrapper.py,sha256=im_0U7PdkUrr4begxJ1IwohjLbmzi8c2diHiklFefHE,2383
 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
@@ -499,7 +499,7 @@ vellum/client/types/open_ai_vectorizer_text_embedding_3_small.py,sha256=T_-P7qGj
 vellum/client/types/open_ai_vectorizer_text_embedding_3_small_request.py,sha256=-lwNeWj7ExP-JLncUp1Uyd20FxweVIDu-aEnenPB98A,841
 vellum/client/types/open_ai_vectorizer_text_embedding_ada_002.py,sha256=c4vNlR6lRvUjq-67M06sroDMNMG_qC4JUBqwmKEJQ2I,812
 vellum/client/types/open_ai_vectorizer_text_embedding_ada_002_request.py,sha256=FdpkkNBGgRwfqFjBwpfH4t2zKIM0pIYminX2iZQUzvY,841
-vellum/client/types/organization_limit_config.py,sha256=-d3xOt5EPqPwqIhPi85Ez70eFi-ClwBn6_IPQhD6b_Y,894
+vellum/client/types/organization_limit_config.py,sha256=-RXRY_Rpt8hHbJtNxJZvfKo1cUEnlvvGCRhk401jLU0,956
 vellum/client/types/organization_read.py,sha256=c5Wl5KY6plC7DuPJq6zAK_UTH2XVhT7H8OdEtxLqN98,854
 vellum/client/types/paginated_container_image_read_list.py,sha256=7lwIgs1q7Z0xDYPGWPnjSNC1kU_peu79CotzaaQfRdA,801
 vellum/client/types/paginated_deployment_release_tag_read_list.py,sha256=hp7D74CxPY14dEPRZ-fnTCwp63upxkYquL1e74oYXh4,826
@@ -853,11 +853,11 @@ vellum/plugins/utils.py,sha256=cPmxE9R2CK1bki2jKE8rB-G9zMf2pzHjSPDHFPXwd3Q,878
 vellum/plugins/vellum_mypy.py,sha256=hfjC2rIxNdQuJa6fIN4PDgODnQ3YaUszyaV2eNbLJlE,27952
 vellum/prompts/__init__.py,sha256=kn-btvQOMNnnBuyQiUpie48_VBJAk7tFFU-ul5dwK60,107
 vellum/prompts/blocks/__init__.py,sha256=Zwvncjd8sUCPmT-8pFpgLYsKJl0xB6td1GTQzjV9hYA,108
-vellum/prompts/blocks/compilation.py,sha256=qeC_4La5auQkm4EyzCMpN34F5R8mjiGcLV7IxKgVf3k,9973
+vellum/prompts/blocks/compilation.py,sha256=wI9IRj-atd8GYJnOhBnyumhH25e3rUYC5uTcMVEyktw,10212
 vellum/prompts/blocks/exceptions.py,sha256=vmk5PV6Vyw9nKjZYQDUDW0LH8MfQNIgFvFb_mFWdIRI,50
 vellum/prompts/blocks/helpers.py,sha256=7G1Qi6N3V1K73iqTypMTcl6Rum7wk449yHStkakLy-U,961
 vellum/prompts/blocks/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/prompts/blocks/tests/test_compilation.py,sha256=EOUtdzJDFGbGhoc_y5XTMyO0HOpOM7FYJssPzd_yRVg,5235
+vellum/prompts/blocks/tests/test_compilation.py,sha256=r8Z2x6QUiHhP183MtRTYxNxoxADWx_DN2HM5iStnfAg,7885
 vellum/prompts/blocks/types.py,sha256=6aSJQco-5kKeadfKVVXF_SrQPlIJgMYVNc-C7so1sY8,975
 vellum/prompts/constants.py,sha256=fnjiRWLoRlC4Puo5oQcpZD5Hd-EesxsAo9l5tGAkpZQ,270
 vellum/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1535,7 +1535,7 @@ 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=X47a4TClHknsnjs53DkiXnop_5uLGVor487oxhHuGo4,14902
+vellum/workflows/descriptors/base.py,sha256=nZeCuuoJj3eJJjhrqOyfBB4FLUkN6fuO8PDdx6YDkzc,15373
 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
@@ -1561,6 +1561,7 @@ vellum/workflows/expressions/and_.py,sha256=I7lNqrUM3-m_5hmjjiMhaHhJtKcLj39kEFVW
 vellum/workflows/expressions/begins_with.py,sha256=FnWsQXbENm0ZwkfEP7dR8Qx4_MMrzj6C1yqAV2KaNHw,1123
 vellum/workflows/expressions/between.py,sha256=dVeddT6YA91eOAlE1Utg7C7gnCiYE7WP-dg17yXUeAY,1492
 vellum/workflows/expressions/coalesce_expression.py,sha256=s4pcfu8KkUaUlQkB6BoQUKitGmV1FIQfV4agHHZtd98,1194
+vellum/workflows/expressions/concat.py,sha256=bFiHeCpZWfMMO_nvFmM5RgN-hoh-5ThBtxP0EJ2F7BE,1105
 vellum/workflows/expressions/contains.py,sha256=B1Ub63119QmwPKvBt8vDqQbuiaJWh-_2k5ZUnUNZZak,1392
 vellum/workflows/expressions/does_not_begin_with.py,sha256=qcnIJsxg4Jt82i2L-PW6ZhKP3C-OlEiXbiIgwHQc5RE,1137
 vellum/workflows/expressions/does_not_contain.py,sha256=ZdHVewTe_pbPGB0cGv_gIq_4jKkv_oG2tX3RBdEGWoA,1266
@@ -1588,6 +1589,7 @@ vellum/workflows/expressions/or_.py,sha256=s-8YdMSSCDS2yijR38kguwok3iqmDMMgDYKV9
 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_concat.py,sha256=fDHXlmFvCtqPkdZQD9Qs22i6sJq_MJjbUXCnTlSMvA0,1666
 vellum/workflows/expressions/tests/test_expressions.py,sha256=3b6k8xs-CItBBw95NygFLUNoNPKxI4VA1GyWbkMtqyI,11623
 vellum/workflows/expressions/tests/test_parse_json.py,sha256=zpB_qE5_EwWQL7ULQUJm0o1PRSfWZdAqZNW6Ah13oJE,1059
 vellum/workflows/graph/__init__.py,sha256=3sHlay5d_-uD7j3QJXiGl0WHFZZ_QScRvgyDhN2GhHY,74
@@ -1668,7 +1670,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=LkFaS7GDPdhqMjQ3duHPX6pjl0z6xKzGxDueQC4aeA0,2999
+vellum/workflows/nodes/displayable/inline_prompt_node/node.py,sha256=wgZ9bt9IFe5cqWSghfMlD1NgmFhRnuDLRzXzMhJomV0,2912
 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
@@ -1676,7 +1678,7 @@ vellum/workflows/nodes/displayable/merge_node/node.py,sha256=nZtGGVAvY4fvGg8vwV6
 vellum/workflows/nodes/displayable/note_node/__init__.py,sha256=KWA3P4fyYJ-fOTky8qNGlcOotQ-HeHJ9AjZt6mRQmCE,58
 vellum/workflows/nodes/displayable/note_node/node.py,sha256=sIN1VBQ7zeT3GhN0kupXbFfdpvgedWV79k4woJNp5IQ,394
 vellum/workflows/nodes/displayable/prompt_deployment_node/__init__.py,sha256=krX1Hds-TSVYZsx0wJFX4wsAKkEFYOX1ifwRGiIM-EA,82
-vellum/workflows/nodes/displayable/prompt_deployment_node/node.py,sha256=rRUIM-zbVCV_0odyPExEZay0k4VCjsYyZ3OC9ZpHQsc,3399
+vellum/workflows/nodes/displayable/prompt_deployment_node/node.py,sha256=r-HGevtJ0wXPPW58dNfF3euuDmXO-p1Qm8WuJTJqVtg,3312
 vellum/workflows/nodes/displayable/prompt_deployment_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/prompt_deployment_node/tests/test_node.py,sha256=c_nuuqrwiIjgj4qIbVypfDuOc-3TlgO6CbXFqQl2Nqw,19725
 vellum/workflows/nodes/displayable/search_node/__init__.py,sha256=hpBpvbrDYf43DElRZFLzieSn8weXiwNiiNOJurERQbs,62
@@ -1693,12 +1695,14 @@ 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/composio_service.py,sha256=C53hgStA-BHe7EFu4j_N650LqsLBOiMovs_nGW8J7nc,2669
 vellum/workflows/nodes/displayable/tool_calling_node/node.py,sha256=BRA6YRCEOk0Nw3DCIT13WY7WCZ7Gx30s-egJe_md0FA,6504
 vellum/workflows/nodes/displayable/tool_calling_node/state.py,sha256=oQg_GAtc349nPB5BL_oeDYYD7q1qSDPAqjj8iA8OoAw,215
 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=BOb4LTAELS-cX5xPH8fH4E2CKl1IBBjiOBYhQl51PpI,4758
 vellum/workflows/nodes/displayable/tool_calling_node/tests/test_node.py,sha256=raY_E5-EgtYNXEPbO2I-Ythe4YeuFdGsXGZ_BAN98uI,7979
 vellum/workflows/nodes/displayable/tool_calling_node/tests/test_utils.py,sha256=eu6WTyENhGLg9pGp_j69rysZjf_qiQXske1YdZn9PzU,1718
-vellum/workflows/nodes/displayable/tool_calling_node/utils.py,sha256=cWlQpEyeLwJX3peMxuTNG3uy26JoXuaQPG4zTuonB5Y,12671
+vellum/workflows/nodes/displayable/tool_calling_node/utils.py,sha256=jMXStMKr3BFfQKdQa9hFFxI7RQp8eAMAknpqkbY0Nk0,13344
 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
@@ -1745,12 +1749,12 @@ vellum/workflows/tests/test_sandbox.py,sha256=JKwaluI-lODQo7Ek9sjDstjL_WTdSqUlVi
 vellum/workflows/tests/test_undefined.py,sha256=zMCVliCXVNLrlC6hEGyOWDnQADJ2g83yc5FIM33zuo8,353
 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=iLJkMKf417kjwRncWdT_qsfJ-qBv5x58um7SfrydJbs,1266
-vellum/workflows/types/definition.py,sha256=WSTi7DfwgIUMaHaNl0jV_9thw_wsLbzt5WRElJebaHw,3172
+vellum/workflows/types/core.py,sha256=6MW_BRLcx4oEJpItQWQa64xfCrsk76suZSsMKKEsJLg,1314
+vellum/workflows/types/definition.py,sha256=Oq2E5Ae6AsvqAOLWzP0k6H5M7su00JZP_QFhlV2rz7s,3721
 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=5wh_WEnE51epkoo-4PE-JbPlg8OGJUNlaBVWa9TcNSw,993
+vellum/workflows/types/tests/test_definition.py,sha256=c3GczPtWxuH3BOULwZacxYTQlP2ryqH7rvT_anDORVo,1604
 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
@@ -1771,8 +1775,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.3.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-1.0.3.dist-info/METADATA,sha256=BhSR95Ti_OY6NHP8v4qgMd9L3RM-6NxohzOdWRF6nxY,5554
-vellum_ai-1.0.3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-1.0.3.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-1.0.3.dist-info/RECORD,,
+vellum_ai-1.0.4.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-1.0.4.dist-info/METADATA,sha256=a7IAzLZ3FlACUej3-52w1DORsAgXM5tpzkLJ8XAgnIQ,5649
+vellum_ai-1.0.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-1.0.4.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-1.0.4.dist-info/RECORD,,