vellum-ai 1.0.3__tar.gz → 1.0.5__tar.gz

{vellum_ai-1.0.3 → vellum_ai-1.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 1.0.3
+Version: 1.0.5
 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.5/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_composio_serialization.py

@@ -0,0 +1,86 @@
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+from tests.workflows.basic_tool_calling_node_with_composio_tool.workflow import (
+    BasicToolCallingNodeWithComposioToolWorkflow,
+)
+
+
+def test_serialize_workflow():
+    # GIVEN a Workflow that uses a tool calling node with a composio tool
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=BasicToolCallingNodeWithComposioToolWorkflow)
+
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN we should get a serialized representation of the Workflow
+    assert serialized_workflow.keys() == {
+        "workflow_raw_data",
+        "input_variables",
+        "state_variables",
+        "output_variables",
+    }
+
+    # AND its input variables should be what we expect
+    input_variables = serialized_workflow["input_variables"]
+    assert len(input_variables) == 1
+
+    # AND its output variables should be what we expect
+    output_variables = serialized_workflow["output_variables"]
+    assert len(output_variables) == 2
+
+    # Find the text and chat_history outputs
+    text_output = next(var for var in output_variables if var["key"] == "text")
+    chat_history_output = next(var for var in output_variables if var["key"] == "chat_history")
+
+    assert text_output["type"] == "STRING"
+    assert chat_history_output["type"] == "CHAT_HISTORY"
+
+    # AND its raw data should be what we expect
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    tool_calling_node = workflow_raw_data["nodes"][1]
+
+    # AND the tool calling node should have the composio tool properly serialized
+    functions_attribute = next(attr for attr in tool_calling_node["attributes"] if attr["name"] == "functions")
+    assert functions_attribute["value"]["type"] == "CONSTANT_VALUE"
+    assert functions_attribute["value"]["value"]["type"] == "JSON"
+
+    functions_list = functions_attribute["value"]["value"]["value"]
+    assert len(functions_list) == 1
+
+    composio_function = functions_list[0]
+    assert composio_function == {
+        "type": "COMPOSIO",
+        "toolkit": "GITHUB",
+        "action": "GITHUB_CREATE_AN_ISSUE",
+        "description": "Create a new issue in a GitHub repository",
+        "display_name": "Create GitHub Issue",
+    }
+
+    # AND the rest of the node structure should be correct
+    assert tool_calling_node["type"] == "GENERIC"
+    assert tool_calling_node["base"]["name"] == "ToolCallingNode"
+    assert tool_calling_node["definition"]["name"] == "ComposioToolCallingNode"
+
+    # AND the blocks should be properly serialized
+    blocks_attribute = next(attr for attr in tool_calling_node["attributes"] if attr["name"] == "blocks")
+    assert blocks_attribute["value"]["type"] == "CONSTANT_VALUE"
+    blocks_list = blocks_attribute["value"]["value"]["value"]
+    assert len(blocks_list) == 2
+    assert blocks_list[0]["chat_role"] == "SYSTEM"
+    assert blocks_list[1]["chat_role"] == "USER"
+
+    # AND the prompt inputs should be properly serialized
+    prompt_inputs_attribute = next(attr for attr in tool_calling_node["attributes"] if attr["name"] == "prompt_inputs")
+    assert prompt_inputs_attribute["value"]["type"] == "DICTIONARY_REFERENCE"
+    entries = prompt_inputs_attribute["value"]["entries"]
+    assert len(entries) == 1
+    assert entries[0]["key"] == "question"
+    assert entries[0]["value"]["type"] == "WORKFLOW_INPUT"
+
+    # AND the outputs should be correct
+    outputs = tool_calling_node["outputs"]
+    assert len(outputs) == 2
+    assert outputs[0]["name"] == "text"
+    assert outputs[0]["type"] == "STRING"
+    assert outputs[1]["name"] == "chat_history"
+    assert outputs[1]["type"] == "CHAT_HISTORY"

{vellum_ai-1.0.3 → vellum_ai-1.0.5}/pyproject.toml

@@ -3,7 +3,7 @@ name = "vellum-ai"
 
 [tool.poetry]
 name = "vellum-ai"
-version = "1.0.3"
+version = "1.0.5"
 description = ""
 readme = "README.md"
 authors = []
@@ -38,6 +38,8 @@ packages = [
 python = "^3.9"
 Jinja2 = ">=3.1.0,<4.0.0"
 click = ">=8.1.7,<9.0.0"
+composio-client = ">=1.5.0,<2.0.0"
+composio-core = ">=0.7.20,<1.0.0"
 docker = ">=7.1.0,<8.0.0"
 httpx = ">=0.21.2"
 openai = ">=1.0.0,<2.0.0"

{vellum_ai-1.0.3 → vellum_ai-1.0.5}/src/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_ai-1.0.3 → vellum_ai-1.0.5}/src/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_ai-1.0.3 → vellum_ai-1.0.5}/src/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_ai-1.0.5/src/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_ai-1.0.3 → vellum_ai-1.0.5}/src/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_ai-1.0.3 → vellum_ai-1.0.5}/src/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_ai-1.0.3 → vellum_ai-1.0.5}/src/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_ai-1.0.3 → vellum_ai-1.0.5}/src/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_ai-1.0.5/src/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_ai-1.0.3 → vellum_ai-1.0.5}/src/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_ai-1.0.5/src/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_ai-1.0.5/src/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_ai-1.0.3 → vellum_ai-1.0.5}/src/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_ai-1.0.3 → vellum_ai-1.0.5}/src/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_ai-1.0.5/src/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_ai-1.0.5/src/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