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

vellum/workflows/nodes/displayable/bases/api_node/tests/test_node.py

@@ -0,0 +1,124 @@
+import pytest
+
+from vellum.client.types.execute_api_response import ExecuteApiResponse
+from vellum.workflows.constants import APIRequestMethod
+from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.nodes.displayable.bases.api_node.node import BaseAPINode
+from vellum.workflows.types.core import VellumSecret
+
+
+@pytest.mark.parametrize("method_value", ["GET", "get", APIRequestMethod.GET])
+def test_api_node_with_string_method(method_value, vellum_client):
+    class TestAPINode(BaseAPINode):
+        method = method_value
+        url = "https://example.com"
+        headers = {"Authorization": VellumSecret(name="API_KEY")}
+
+    mock_response = ExecuteApiResponse(
+        json_={"status": "success"},
+        headers={"content-type": "application/json"},
+        status_code=200,
+        text='{"status": "success"}',
+    )
+    vellum_client.execute_api.return_value = mock_response
+
+    node = TestAPINode()
+    result = node.run()
+
+    assert result.status_code == 200
+
+    vellum_client.execute_api.assert_called_once()
+    call_args = vellum_client.execute_api.call_args
+    assert call_args[1]["method"] == "GET"
+
+
+def test_api_node_with_invalid_method():
+    class TestAPINode(BaseAPINode):
+        method = "INVALID_METHOD"
+        url = "https://example.com"
+
+    node = TestAPINode()
+
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    assert exc_info.value.code == WorkflowErrorCode.INVALID_INPUTS
+    assert "Invalid HTTP method 'INVALID_METHOD'" == str(exc_info.value)
+
+
+def test_api_node_adds_user_agent_header_when_none_provided(requests_mock):
+    """
+    Tests that the API node adds User-Agent header when no headers are provided.
+    """
+
+    class TestAPINode(BaseAPINode):
+        method = APIRequestMethod.GET
+        url = "https://example.com/test"
+
+    response_mock = requests_mock.get(
+        "https://example.com/test",
+        json={"result": "success"},
+        status_code=200,
+    )
+
+    node = TestAPINode()
+    result = node.run()
+
+    assert response_mock.last_request
+    assert "vellum-ai" in response_mock.last_request.headers.get("User-Agent", "")
+
+    assert result.status_code == 200
+
+
+def test_api_node_adds_user_agent_header_when_headers_provided_without_user_agent(requests_mock):
+    """
+    Tests that the API node adds User-Agent header when headers are provided but don't include User-Agent.
+    """
+
+    class TestAPINode(BaseAPINode):
+        method = APIRequestMethod.POST
+        url = "https://example.com/test"
+        headers = {"Content-Type": "application/json", "Custom-Header": "value"}
+        json = {"test": "data"}
+
+    response_mock = requests_mock.post(
+        "https://example.com/test",
+        json={"result": "success"},
+        status_code=200,
+    )
+
+    node = TestAPINode()
+    result = node.run()
+
+    assert response_mock.last_request
+    assert "vellum-ai" in response_mock.last_request.headers.get("User-Agent", "")
+    assert response_mock.last_request.headers.get("Content-Type") == "application/json"
+    assert response_mock.last_request.headers.get("Custom-Header") == "value"
+
+    assert result.status_code == 200
+
+
+def test_api_node_preserves_custom_user_agent_header(requests_mock):
+    """
+    Tests that the API node preserves a custom User-Agent header if provided.
+    """
+
+    class TestAPINode(BaseAPINode):
+        method = APIRequestMethod.GET
+        url = "https://example.com/test"
+        headers = {"User-Agent": "Custom-Agent/1.0"}
+
+    response_mock = requests_mock.get(
+        "https://example.com/test",
+        json={"result": "success"},
+        status_code=200,
+    )
+
+    node = TestAPINode()
+    result = node.run()
+
+    assert response_mock.last_request
+    assert response_mock.last_request.headers.get("User-Agent") == "Custom-Agent/1.0"
+
+    assert result.status_code == 200

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

@@ -1,4 +1,4 @@
-from typing import ClassVar, Iterator, List, Optional, Set
+from typing import Any, ClassVar, Dict, Iterator, List, Optional, Set, Union
 
 from vellum import ChatMessage, PromptBlock
 from vellum.client.types.prompt_parameters import PromptParameters
@@ -36,7 +36,7 @@ class ToolCallingNode(BaseNode):
     """
 
     ml_model: ClassVar[str] = "gpt-4o-mini"
-    blocks: ClassVar[List[PromptBlock]] = []
+    blocks: ClassVar[List[Union[PromptBlock, Dict[str, Any]]]] = []
     functions: ClassVar[List[Tool]] = []
     prompt_inputs: ClassVar[Optional[EntityInputsInterface]] = None
     parameters: PromptParameters = DEFAULT_PROMPT_PARAMETERS

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

@@ -1,72 +1,65 @@
 import pytest
 from unittest.mock import Mock, patch
 
-from vellum.workflows.nodes.displayable.tool_calling_node.composio_service import ComposioService, ConnectionInfo
+from vellum.workflows.integrations.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
+def mock_requests():
+    """Mock requests module"""
+    with patch("vellum.workflows.integrations.composio_service.requests") as mock_requests:
+        yield mock_requests
 
 
 @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
+    """Mock response for connected accounts API"""
+    return {
+        "items": [
+            {
+                "id": "conn-123",
+                "toolkit": {"slug": "github"},
+                "status": "ACTIVE",
+                "created_at": "2023-01-01T00:00:00Z",
+                "updated_at": "2023-01-15T10:30:00Z",
+            },
+            {
+                "id": "conn-456",
+                "toolkit": {"slug": "slack"},
+                "status": "ACTIVE",
+                "created_at": "2023-01-01T00:00:00Z",
+                "updated_at": "2023-01-10T08:00:00Z",
+            },
+        ]
+    }
 
 
 @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
+def mock_tool_execution_response():
+    """Mock response for tool execution API"""
+    return {
+        "data": {"items": [], "total": 0},
+        "successful": True,
+        "error": None,
+    }
 
 
 @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"""
+def composio_service():
+    """Create ComposioService with test API key"""
     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
-    ):
+    def test_get_user_connections_success(self, composio_service, mock_requests, 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
+        # GIVEN the requests mock returns a valid response with two connections
+        mock_response = Mock()
+        mock_response.json.return_value = mock_connected_accounts_response
+        mock_response.raise_for_status.return_value = None
+        mock_requests.get.return_value = mock_response
 
         # WHEN we request user connections
         result = composio_service.get_user_connections()
@@ -86,14 +79,21 @@ class TestComposioAccountService:
         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()
+        # Verify the correct API endpoint was called
+        mock_requests.get.assert_called_once_with(
+            "https://backend.composio.dev/api/v3/connected_accounts",
+            headers={"x-api-key": "test-key", "Content-Type": "application/json"},
+            params={},
+            timeout=30,
+        )
 
-    def test_get_user_connections_empty_response(self, composio_service, mock_composio_client):
+    def test_get_user_connections_empty_response(self, composio_service, mock_requests):
         """Test handling of empty connections response"""
-        # GIVEN the Composio client returns an empty response
+        # GIVEN the requests mock returns an empty response
         mock_response = Mock()
-        mock_response.items = []
-        mock_composio_client.connected_accounts.list.return_value = mock_response
+        mock_response.json.return_value = {"items": []}
+        mock_response.raise_for_status.return_value = None
+        mock_requests.get.return_value = mock_response
 
         # WHEN we request user connections
         result = composio_service.get_user_connections()
@@ -105,18 +105,23 @@ class TestComposioAccountService:
 class TestComposioCoreService:
     """Test suite for ComposioCoreService"""
 
-    def test_execute_tool_success(self, composio_service, mock_composio_core_client, mock_action):
+    def test_execute_tool_success(self, composio_service, mock_requests, mock_tool_execution_response):
         """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
+        mock_response = Mock()
+        mock_response.json.return_value = mock_tool_execution_response
+        mock_response.raise_for_status.return_value = None
+        mock_requests.post.return_value = mock_response
 
         # 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
+        # THEN the arguments are passed through correctly and we get the expected result
+        mock_requests.post.assert_called_once_with(
+            "https://backend.composio.dev/api/v3/tools/execute/HACKERNEWS_GET_USER",
+            headers={"x-api-key": "test-key", "Content-Type": "application/json"},
+            json={"arguments": complex_args},
+            timeout=30,
         )
-        assert result == expected_result
+        assert result == {"items": [], "total": 0}

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

@@ -1,9 +1,18 @@
 import pytest
-
+from uuid import uuid4
+
+from vellum.client.types.chat_message_prompt_block import ChatMessagePromptBlock
+from vellum.client.types.fulfilled_execute_prompt_event import FulfilledExecutePromptEvent
+from vellum.client.types.initiated_execute_prompt_event import InitiatedExecutePromptEvent
+from vellum.client.types.plain_text_prompt_block import PlainTextPromptBlock
+from vellum.client.types.rich_text_prompt_block import RichTextPromptBlock
+from vellum.client.types.string_vellum_value import StringVellumValue
+from vellum.client.types.variable_prompt_block import VariablePromptBlock
+from vellum.prompts.constants import DEFAULT_PROMPT_PARAMETERS
 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.nodes.displayable.tool_calling_node.utils import create_tool_router_node, get_function_name
 from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.types.definition import ComposioToolDefinition, DeploymentDefinition
@@ -76,3 +85,139 @@ def test_get_function_name_composio_tool_definition_various_toolkits(
     result = get_function_name(composio_tool)
 
     assert result == expected_result
+
+
+def test_create_tool_router_node_max_prompt_iterations(vellum_adhoc_prompt_client):
+    # GIVEN a tool router node with max_prompt_iterations set to None
+    tool_router_node = create_tool_router_node(
+        ml_model="gpt-4o-mini",
+        blocks=[],
+        functions=[],
+        prompt_inputs=None,
+        parameters=DEFAULT_PROMPT_PARAMETERS,
+        max_prompt_iterations=None,
+    )
+
+    def generate_prompt_events(*args, **kwargs):
+        execution_id = str(uuid4())
+        events = [
+            InitiatedExecutePromptEvent(execution_id=execution_id),
+            FulfilledExecutePromptEvent(
+                execution_id=execution_id,
+                outputs=[StringVellumValue(value="test output")],
+            ),
+        ]
+        yield from events
+
+    vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.side_effect = generate_prompt_events
+
+    # WHEN we run the tool router node
+    node_instance = tool_router_node()
+    outputs = list(node_instance.run())
+    assert outputs[0].name == "results"
+    assert outputs[0].value == [StringVellumValue(type="STRING", value="test output")]
+    assert outputs[1].name == "text"
+    assert outputs[1].value == "test output"
+
+
+def test_create_tool_router_node_chat_history_block_dict(vellum_adhoc_prompt_client):
+    # GIVEN a list of blocks with a chat history block
+    blocks = [
+        {
+            "block_type": "CHAT_MESSAGE",
+            "chat_role": "SYSTEM",
+            "blocks": [
+                {
+                    "block_type": "RICH_TEXT",
+                    "blocks": [{"block_type": "PLAIN_TEXT", "cache_config": None, "text": "first message"}],
+                }
+            ],
+        },
+        {
+            "block_type": "CHAT_MESSAGE",
+            "chat_role": "USER",
+            "blocks": [
+                {
+                    "block_type": "RICH_TEXT",
+                    "blocks": [
+                        {"block_type": "PLAIN_TEXT", "text": "second message"},
+                        {"block_type": "PLAIN_TEXT", "text": "third message"},
+                    ],
+                }
+            ],
+        },
+    ]
+
+    tool_router_node = create_tool_router_node(
+        ml_model="gpt-4o-mini",
+        blocks=blocks,  # type: ignore
+        functions=[],
+        prompt_inputs=None,
+        parameters=DEFAULT_PROMPT_PARAMETERS,
+    )
+
+    def generate_prompt_events(*args, **kwargs):
+        execution_id = str(uuid4())
+        events = [
+            InitiatedExecutePromptEvent(execution_id=execution_id),
+            FulfilledExecutePromptEvent(
+                execution_id=execution_id,
+                outputs=[StringVellumValue(value="test output")],
+            ),
+        ]
+        yield from events
+
+    vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.side_effect = generate_prompt_events
+
+    # WHEN we run the tool router node
+    node_instance = tool_router_node()
+    list(node_instance.run())
+
+    # THEN the API was called with compiled blocks
+    blocks = vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.call_args[1]["blocks"]
+    assert blocks == [
+        ChatMessagePromptBlock(
+            block_type="CHAT_MESSAGE",
+            state=None,
+            cache_config=None,
+            chat_role="SYSTEM",
+            chat_source=None,
+            chat_message_unterminated=None,
+            blocks=[
+                RichTextPromptBlock(
+                    block_type="RICH_TEXT",
+                    state=None,
+                    cache_config=None,
+                    blocks=[
+                        PlainTextPromptBlock(
+                            block_type="PLAIN_TEXT", state=None, cache_config=None, text="first message"
+                        )
+                    ],
+                )
+            ],
+        ),
+        ChatMessagePromptBlock(
+            block_type="CHAT_MESSAGE",
+            state=None,
+            cache_config=None,
+            chat_role="USER",
+            chat_source=None,
+            chat_message_unterminated=None,
+            blocks=[
+                RichTextPromptBlock(
+                    block_type="RICH_TEXT",
+                    state=None,
+                    cache_config=None,
+                    blocks=[
+                        PlainTextPromptBlock(
+                            block_type="PLAIN_TEXT", state=None, cache_config=None, text="second message"
+                        ),
+                        PlainTextPromptBlock(
+                            block_type="PLAIN_TEXT", state=None, cache_config=None, text="third message"
+                        ),
+                    ],
+                )
+            ],
+        ),
+        VariablePromptBlock(block_type="VARIABLE", state=None, cache_config=None, input_variable="chat_history"),
+    ]

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

@@ -1,12 +1,13 @@
 import json
-import os
-from typing import Any, Callable, Iterator, List, Optional, Type, cast
+import logging
+from typing import Any, Callable, Dict, Iterator, List, Optional, Type, Union, cast
 
 from pydash import snake_case
 
 from vellum import ChatMessage, PromptBlock
 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
 from vellum.client.types.prompt_output import PromptOutput
 from vellum.client.types.prompt_parameters import PromptParameters
 from vellum.client.types.string_chat_message_content import StringChatMessageContent
@@ -15,11 +16,11 @@ 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.integrations.composio_service import ComposioService
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.core.inline_subworkflow_node.node import InlineSubworkflowNode
 from vellum.workflows.nodes.displayable.inline_prompt_node.node import InlinePromptNode
 from vellum.workflows.nodes.displayable.subworkflow_deployment_node.node import SubworkflowDeploymentNode
-from vellum.workflows.nodes.displayable.tool_calling_node.composio_service import ComposioService
 from vellum.workflows.nodes.displayable.tool_calling_node.state import ToolCallingState
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.ports.port import Port
@@ -33,6 +34,9 @@ from vellum.workflows.types.generics import is_workflow_class
 CHAT_HISTORY_VARIABLE = "chat_history"
 
 
+logger = logging.getLogger(__name__)
+
+
 class FunctionCallNodeMixin:
     """Mixin providing common functionality for nodes that handle function calls."""
 
@@ -63,7 +67,7 @@ class ToolRouterNode(InlinePromptNode[ToolCallingState]):
         merge_behavior = MergeBehavior.AWAIT_ATTRIBUTES
 
     def run(self) -> Iterator[BaseOutput]:
-        if self.state.prompt_iterations >= self.max_prompt_iterations:
+        if self.max_prompt_iterations is not None and self.state.prompt_iterations >= self.max_prompt_iterations:
             max_iterations_message = f"Maximum number of prompt iterations `{self.max_prompt_iterations}` reached."
             raise NodeException(message=max_iterations_message, code=WorkflowErrorCode.NODE_EXECUTION)
 
@@ -176,29 +180,9 @@ class ComposioNode(BaseNode[ToolCallingState], FunctionCallNodeMixin):
         # Extract arguments from function call
         arguments = self._extract_function_arguments()
 
-        # HACK: Use first Composio API key found in environment variables
-        composio_api_key = None
-        common_env_var_names = ["COMPOSIO_API_KEY", "COMPOSIO_KEY"]
-
-        for env_var_name in common_env_var_names:
-            value = os.environ.get(env_var_name)
-            if value:
-                composio_api_key = value
-                break
-
-        if not composio_api_key:
-            raise NodeException(
-                message=(
-                    "No Composio API key found in environment variables. "
-                    "Please ensure one of these environment variables is set: "
-                )
-                + ", ".join(common_env_var_names),
-                code=WorkflowErrorCode.NODE_EXECUTION,
-            )
-
         try:
             # Execute using ComposioService
-            composio_service = ComposioService(api_key=composio_api_key)
+            composio_service = ComposioService()
             result = composio_service.execute_tool(tool_name=self.composio_tool.action, arguments=arguments)
         except Exception as e:
             raise NodeException(
@@ -212,26 +196,46 @@ class ComposioNode(BaseNode[ToolCallingState], FunctionCallNodeMixin):
         yield from []
 
 
-def create_composio_wrapper_function(tool_def: ComposioToolDefinition):
-    """Create a real Python function that wraps the Composio tool for prompt layer compatibility."""
+def _hydrate_composio_tool_definition(tool_def: ComposioToolDefinition) -> ComposioToolDefinition:
+    """Hydrate a ComposioToolDefinition with detailed information from the Composio API.
 
-    def wrapper_function(**kwargs):
-        # This should never be called due to routing, but satisfies introspection
-        raise RuntimeError(
-            f"ComposioToolDefinition wrapper for '{tool_def.action}' should not be called directly. "
-            f"Execution should go through ComposioNode. This suggests a routing issue."
+    Args:
+        tool_def: The basic ComposioToolDefinition to enhance
+
+    Returns:
+        ComposioToolDefinition 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
         )
 
-    # Set proper function attributes for prompt layer introspection
-    wrapper_function.__name__ = tool_def.name
-    wrapper_function.__doc__ = tool_def.description
+        # 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),
+            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),
+        )
 
-    return wrapper_function
+    except Exception as e:
+        # If hydration fails (including no API key), log and return original
+        logger.warning(f"Failed to enhance Composio tool '{tool_def.action}': {e}")
+        return tool_def
 
 
 def create_tool_router_node(
     ml_model: str,
-    blocks: List[PromptBlock],
+    blocks: List[Union[PromptBlock, Dict[str, Any]]],
     functions: List[Tool],
     prompt_inputs: Optional[EntityInputsInterface],
     parameters: PromptParameters,
@@ -240,12 +244,19 @@ def create_tool_router_node(
     if functions and len(functions) > 0:
         # Create dynamic ports and convert functions in a single loop
         Ports = type("Ports", (), {})
-        prompt_functions = []
+        prompt_functions: List[Union[Tool, FunctionDefinition]] = []
 
         for function in functions:
-            # Convert ComposioToolDefinition to wrapper function for prompt layer
             if isinstance(function, ComposioToolDefinition):
-                prompt_functions.append(create_composio_wrapper_function(function))
+                # 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,
+                    )
+                )
             else:
                 prompt_functions.append(function)
 
@@ -276,7 +287,16 @@ def create_tool_router_node(
 
     # Add a chat history block to blocks only if one doesn't already exist
     has_chat_history_block = any(
-        block.block_type == "VARIABLE" and block.input_variable == CHAT_HISTORY_VARIABLE for block in blocks
+        (
+            (block["block_type"] if isinstance(block, dict) else block.block_type) == "VARIABLE"
+            and (
+                block["input_variable"]
+                if isinstance(block, dict)
+                else block.input_variable if isinstance(block, VariablePromptBlock) else None
+            )
+            == CHAT_HISTORY_VARIABLE
+        )
+        for block in blocks
     )
 
     if not has_chat_history_block:

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, Literal, Optional, Union
+from typing import Annotated, Any, Dict, List, Literal, Optional, Union
 
 from pydantic import BeforeValidator
 
@@ -109,8 +109,10 @@ class ComposioToolDefinition(UniversalBaseModel):
     action: str  # Specific action like "GITHUB_CREATE_AN_ISSUE"
     description: str
 
-    # Optional cached metadata
     display_name: Optional[str] = None
+    parameters: Optional[Dict[str, Any]] = None
+    version: Optional[str] = None
+    tags: Optional[List[str]] = None
 
     @property
     def name(self) -> str: