vellum-ai 1.0.4__tar.gz → 1.0.6__tar.gz

{vellum_ai-1.0.4 → vellum_ai-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 1.0.4
+Version: 1.0.6
 Summary: 
 License: MIT
 Requires-Python: >=3.9,<4.0
@@ -22,8 +22,6 @@ 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.4 → vellum_ai-1.0.6}/ee/vellum_cli/push.py

@@ -16,6 +16,7 @@ from vellum.resources.workflows.client import OMIT
 from vellum.workflows.vellum_client import create_vellum_client
 from vellum_cli.config import DEFAULT_WORKSPACE_CONFIG, WorkflowConfig, WorkflowDeploymentConfig, load_vellum_cli_config
 from vellum_cli.logger import handle_cli_error, load_cli_logger
+from vellum_ee.workflows.display.nodes.utils import to_kebab_case
 from vellum_ee.workflows.display.workflows.base_workflow_display import BaseWorkflowDisplay
 
 
@@ -131,9 +132,10 @@ def push_command(
         )
 
         try:
+            module_name = workflow_config.module.split(".")[-1]
             deployment_config = WorkflowPushDeploymentConfigRequest(
                 label=deployment_label or cli_deployment_config.label,
-                name=deployment_name or cli_deployment_config.name,
+                name=deployment_name or cli_deployment_config.name or to_kebab_case(module_name),
                 description=deployment_description or cli_deployment_config.description,
                 release_tags=release_tags or cli_deployment_config.release_tags,
             )
@@ -274,7 +276,14 @@ Visit at: {base_url}/workflow-sandboxes/{response.workflow_sandbox_id}"""
         workflow_config.workflow_sandbox_id = response.workflow_sandbox_id
 
     if not workflow_config.deployments and response.workflow_deployment_id:
-        workflow_config.deployments.append(WorkflowDeploymentConfig(id=UUID(response.workflow_deployment_id)))
+        stored_deployment_config = WorkflowDeploymentConfig(
+            id=UUID(response.workflow_deployment_id),
+            label=deployment_config.label if deploy else None,
+            name=deployment_config.name if deploy else None,
+            description=deployment_config.description if deploy else None,
+            release_tags=deployment_config.release_tags if deploy else None,
+        )
+        workflow_config.deployments.append(stored_deployment_config)
 
     config.save()
     logger.info("Updated vellum.lock.json file.")

{vellum_ai-1.0.4 → vellum_ai-1.0.6}/ee/vellum_cli/tests/test_push.py

@@ -13,6 +13,7 @@ from vellum.client.core.api_error import ApiError
 from vellum.client.types.workflow_push_response import WorkflowPushResponse
 from vellum.utils.uuid import is_valid_uuid
 from vellum_cli import main as cli_main
+from vellum_ee.workflows.display.nodes.utils import to_kebab_case
 
 
 def _extract_tar_gz(tar_gz_bytes: bytes) -> dict[str, str]:
@@ -391,7 +392,9 @@ def test_push__deployment(mock_module, vellum_client, base_command):
     assert json.loads(call_args["exec_config"])["workflow_raw_data"]["definition"]["name"] == "ExampleWorkflow"
     assert is_valid_uuid(call_args["workflow_sandbox_id"])
     assert call_args["artifact"].name == expected_artifact_name
-    assert call_args["deployment_config"] == "{}"
+    expected_deployment_name = to_kebab_case(module.split(".")[-1])
+    deployment_config = json.loads(call_args["deployment_config"])
+    assert deployment_config["name"] == expected_deployment_name
 
     extracted_files = _extract_tar_gz(call_args["artifact"].read())
     assert extracted_files["workflow.py"] == workflow_py_file_content
@@ -1039,3 +1042,56 @@ def test_push__deploy_with_release_tags_success(mock_module, vellum_client):
     # AND should show success message
     assert "Successfully pushed" in result.output
     assert "Updated vellum.lock.json file." in result.output
+
+
+def test_push__deploy_stores_deployment_config_in_lock_file(mock_module, vellum_client):
+    # GIVEN a single workflow
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
+
+    # AND a workflow exists in the module successfully
+    _ensure_workflow_py(temp_dir, module)
+
+    # AND the push API call returns successfully with a deployment
+    workflow_deployment_id = str(uuid4())
+    vellum_client.workflows.push.return_value = WorkflowPushResponse(
+        workflow_sandbox_id=str(uuid4()),
+        workflow_deployment_id=workflow_deployment_id,
+    )
+
+    # WHEN calling `vellum workflows push --deploy` for the first time
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["workflows", "push", module, "--deploy"])
+
+    # THEN it should succeed
+    assert result.exit_code == 0, result.output
+
+    # AND the deployment config should be stored in the lock file with the deployment ID and module name
+    with open(os.path.join(temp_dir, "vellum.lock.json")) as f:
+        lock_data = json.loads(f.read())
+        assert len(lock_data["workflows"][0]["deployments"]) == 1
+        deployment = lock_data["workflows"][0]["deployments"][0]
+        assert str(deployment["id"]) == workflow_deployment_id
+        assert deployment["name"] == "test-push-deploy-stores-deployment-config-in-lock-file"
+        assert deployment.get("label") is None
+        assert deployment.get("description") is None
+        assert deployment.get("release_tags") is None
+
+    # AND when we do a second push
+    vellum_client.workflows.push.reset_mock()
+    vellum_client.workflows.push.return_value = WorkflowPushResponse(
+        workflow_sandbox_id=str(uuid4()),
+        workflow_deployment_id=workflow_deployment_id,
+    )
+
+    result = runner.invoke(cli_main, ["workflows", "push", module, "--deploy"])
+
+    # THEN it should succeed
+    assert result.exit_code == 0, result.output
+
+    # AND we should have called the push API with the module name as deployment name
+    vellum_client.workflows.push.assert_called_once()
+    call_args = vellum_client.workflows.push.call_args.kwargs
+    deployment_config_str = call_args["deployment_config"]
+    deployment_config = json.loads(deployment_config_str)
+    assert deployment_config["name"] == "test-push-deploy-stores-deployment-config-in-lock-file"

{vellum_ai-1.0.4 → vellum_ai-1.0.6}/ee/vellum_ee/workflows/display/nodes/vellum/code_execution_node.py

@@ -40,6 +40,8 @@ class BaseCodeExecutionNodeDisplay(BaseNodeDisplay[_CodeExecutionNodeType], Gene
                 node_filepath=node_file_path,
                 script_filepath=filepath,
             )
+            if not file_code:
+                raise Exception(f"Filepath '{filepath}' of node {node.__name__} does not exist")
             code_value = file_code
         else:
             code_value = ""

{vellum_ai-1.0.4 → vellum_ai-1.0.6}/ee/vellum_ee/workflows/display/nodes/vellum/tests/test_code_execution_node.py

@@ -153,3 +153,19 @@ def test_serialize_node__with_unresolved_secret_references(vellum_client):
     # warnings = list(workflow_display.errors)
     # assert len(warnings) == 1
     # assert "Failed to resolve secret reference 'MY_API_KEY'" in str(warnings[0])
+
+
+def test_serialize_node__with_non_exist_code_input_path():
+    # GIVEN a code node with a non-existent code input path
+    class MyNode(CodeExecutionNode):
+        filepath = "non_existent_file.py"
+
+    # AND a workflow with the code node
+    class Workflow(BaseWorkflow):
+        graph = MyNode
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=Workflow)
+    with pytest.raises(Exception) as exc_info:
+        workflow_display.serialize()
+    assert "Filepath 'non_existent_file.py' of node MyNode does not exist" in str(exc_info.value)

vellum_ai-1.0.6/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_composio_serialization.py

@@ -0,0 +1,89 @@
+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",
+        "parameters": None,
+        "version": None,
+        "tags": None,
+    }
+
+    # 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.4 → vellum_ai-1.0.6}/pyproject.toml

@@ -3,7 +3,7 @@ name = "vellum-ai"
 
 [tool.poetry]
 name = "vellum-ai"
-version = "1.0.4"
+version = "1.0.6"
 description = ""
 readme = "README.md"
 authors = []
@@ -38,8 +38,6 @@ 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.4 → vellum_ai-1.0.6}/src/vellum/__init__.py

@@ -288,7 +288,6 @@ from .client.types import (
     OpenAiVectorizerTextEmbedding3SmallRequest,
     OpenAiVectorizerTextEmbeddingAda002,
     OpenAiVectorizerTextEmbeddingAda002Request,
-    OrganizationLimitConfig,
     OrganizationRead,
     PaginatedContainerImageReadList,
     PaginatedDeploymentReleaseTagReadList,
@@ -329,7 +328,6 @@ from .client.types import (
     PromptRequestStringInput,
     PromptSettings,
     PromptVersionBuildConfigSandbox,
-    Quota,
     RawPromptExecutionOverridesRequest,
     ReductoChunkerConfig,
     ReductoChunkerConfigRequest,
@@ -527,7 +525,6 @@ from .client.types import (
     VellumVariableExtensions,
     VellumVariableType,
     VellumWorkflowExecutionEvent,
-    VembdaServiceTierEnum,
     WorkflowDeploymentEventExecutionsResponse,
     WorkflowDeploymentHistoryItem,
     WorkflowDeploymentParentContext,
@@ -939,7 +936,6 @@ __all__ = [
     "OpenAiVectorizerTextEmbedding3SmallRequest",
     "OpenAiVectorizerTextEmbeddingAda002",
     "OpenAiVectorizerTextEmbeddingAda002Request",
-    "OrganizationLimitConfig",
     "OrganizationRead",
     "PaginatedContainerImageReadList",
     "PaginatedDeploymentReleaseTagReadList",
@@ -980,7 +976,6 @@ __all__ = [
     "PromptRequestStringInput",
     "PromptSettings",
     "PromptVersionBuildConfigSandbox",
-    "Quota",
     "RawPromptExecutionOverridesRequest",
     "ReductoChunkerConfig",
     "ReductoChunkerConfigRequest",
@@ -1180,7 +1175,6 @@ __all__ = [
     "VellumVariableExtensions",
     "VellumVariableType",
     "VellumWorkflowExecutionEvent",
-    "VembdaServiceTierEnum",
     "WorkflowDeploymentEventExecutionsResponse",
     "WorkflowDeploymentHistoryItem",
     "WorkflowDeploymentParentContext",

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

{vellum_ai-1.0.4 → vellum_ai-1.0.6}/src/vellum/client/types/__init__.py

@@ -296,7 +296,6 @@ from .open_ai_vectorizer_text_embedding_3_small import OpenAiVectorizerTextEmbed
 from .open_ai_vectorizer_text_embedding_3_small_request import OpenAiVectorizerTextEmbedding3SmallRequest
 from .open_ai_vectorizer_text_embedding_ada_002 import OpenAiVectorizerTextEmbeddingAda002
 from .open_ai_vectorizer_text_embedding_ada_002_request import OpenAiVectorizerTextEmbeddingAda002Request
-from .organization_limit_config import OrganizationLimitConfig
 from .organization_read import OrganizationRead
 from .paginated_container_image_read_list import PaginatedContainerImageReadList
 from .paginated_deployment_release_tag_read_list import PaginatedDeploymentReleaseTagReadList
@@ -337,7 +336,6 @@ from .prompt_request_json_input import PromptRequestJsonInput
 from .prompt_request_string_input import PromptRequestStringInput
 from .prompt_settings import PromptSettings
 from .prompt_version_build_config_sandbox import PromptVersionBuildConfigSandbox
-from .quota import Quota
 from .raw_prompt_execution_overrides_request import RawPromptExecutionOverridesRequest
 from .reducto_chunker_config import ReductoChunkerConfig
 from .reducto_chunker_config_request import ReductoChunkerConfigRequest
@@ -551,7 +549,6 @@ from .vellum_variable import VellumVariable
 from .vellum_variable_extensions import VellumVariableExtensions
 from .vellum_variable_type import VellumVariableType
 from .vellum_workflow_execution_event import VellumWorkflowExecutionEvent
-from .vembda_service_tier_enum import VembdaServiceTierEnum
 from .workflow_deployment_event_executions_response import WorkflowDeploymentEventExecutionsResponse
 from .workflow_deployment_history_item import WorkflowDeploymentHistoryItem
 from .workflow_deployment_parent_context import WorkflowDeploymentParentContext
@@ -918,7 +915,6 @@ __all__ = [
     "OpenAiVectorizerTextEmbedding3SmallRequest",
     "OpenAiVectorizerTextEmbeddingAda002",
     "OpenAiVectorizerTextEmbeddingAda002Request",
-    "OrganizationLimitConfig",
     "OrganizationRead",
     "PaginatedContainerImageReadList",
     "PaginatedDeploymentReleaseTagReadList",
@@ -959,7 +955,6 @@ __all__ = [
     "PromptRequestStringInput",
     "PromptSettings",
     "PromptVersionBuildConfigSandbox",
-    "Quota",
     "RawPromptExecutionOverridesRequest",
     "ReductoChunkerConfig",
     "ReductoChunkerConfigRequest",
@@ -1157,7 +1152,6 @@ __all__ = [
     "VellumVariableExtensions",
     "VellumVariableType",
     "VellumWorkflowExecutionEvent",
-    "VembdaServiceTierEnum",
     "WorkflowDeploymentEventExecutionsResponse",
     "WorkflowDeploymentHistoryItem",
     "WorkflowDeploymentParentContext",

{vellum_ai-1.0.4 → vellum_ai-1.0.6}/src/vellum/client/types/organization_read.py

@@ -3,7 +3,6 @@
 from ..core.pydantic_utilities import UniversalBaseModel
 import typing
 from .new_member_join_behavior_enum import NewMemberJoinBehaviorEnum
-from .organization_limit_config import OrganizationLimitConfig
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import pydantic
 
@@ -13,7 +12,7 @@ class OrganizationRead(UniversalBaseModel):
     name: str
     allow_staff_access: typing.Optional[bool] = None
     new_member_join_behavior: NewMemberJoinBehaviorEnum
-    limit_config: OrganizationLimitConfig
+    limit_config: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = 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.6/src/vellum/workflows/events/context.py

@@ -0,0 +1,111 @@
+"""Monitoring execution context for workflow tracing."""
+
+import threading
+from uuid import UUID
+from typing import Dict, Optional
+
+from vellum.workflows.context import ExecutionContext
+
+DEFAULT_TRACE_ID = UUID("00000000-0000-0000-0000-000000000000")
+
+# Thread-local storage for monitoring execution context
+_monitoring_execution_context: threading.local = threading.local()
+# Thread-local storage for current span_id
+_current_span_id: threading.local = threading.local()
+
+
+class _MonitoringContextStore:
+    """
+    thread-safe storage for monitoring contexts.
+    handles context persistence and retrieval across threads.
+    relies on the execution context manager for manual retrieval
+    """
+
+    def __init__(self):
+        self._lock = threading.Lock()
+        self._contexts: Dict[str, ExecutionContext] = {}
+        self._thread_contexts: Dict[int, ExecutionContext] = {}
+        self._current_trace_id: Optional[UUID] = None
+
+    def set_current_trace_id(self, trace_id: UUID) -> None:
+        """Set the current active trace_id that should be used by all threads."""
+        if trace_id != DEFAULT_TRACE_ID:
+            with self._lock:
+                self._current_trace_id = trace_id
+
+    def get_current_trace_id(self) -> Optional[UUID]:
+        """Get the current active trace_id that should be used by all threads."""
+        with self._lock:
+            return self._current_trace_id
+
+    def set_current_span_id(self, span_id: UUID) -> None:
+        """Set the current active span_id for this thread."""
+        _current_span_id.span_id = span_id
+
+    def get_current_span_id(self) -> Optional[UUID]:
+        """Get the current active span_id for this thread."""
+        return getattr(_current_span_id, "span_id", None)
+
+    def store_context(self, context: Optional[ExecutionContext]) -> None:
+        """Store monitoring parent context using multiple keys for reliable retrieval."""
+        if not context or context.parent_context is None:
+            return
+
+        thread_id = threading.get_ident()
+        trace_id = self.get_current_trace_id()
+        if context.trace_id != DEFAULT_TRACE_ID and trace_id is None:
+            self.set_current_trace_id(context.trace_id)
+
+        with self._lock:
+            # Use trace:span:thread for unique context storage
+            trace_span_thread_key = (
+                f"trace:{str(trace_id)}:span:{str(context.parent_context.span_id)}:thread:{thread_id}"
+            )
+            self._contexts[trace_span_thread_key] = context
+
+    def retrieve_context(self, trace_id: UUID, span_id: Optional[UUID] = None) -> Optional[ExecutionContext]:
+        """Retrieve monitoring parent context with multiple fallback strategies."""
+        thread_id = threading.get_ident()
+        with self._lock:
+            if not span_id:
+                span_id = getattr(_current_span_id, "span_id", None)
+                if not span_id:
+                    return None
+
+            span_key = f"trace:{str(trace_id)}:span:{str(span_id)}:thread:{thread_id}"
+            if span_key in self._contexts:
+                result = self._contexts[span_key]
+                return result
+
+        return None
+
+
+# Global instance for cross-boundary context persistence
+_monitoring_context_store = _MonitoringContextStore()
+
+
+def get_monitoring_execution_context() -> ExecutionContext:
+    """Get the current monitoring execution context, with intelligent fallback."""
+    if hasattr(_monitoring_execution_context, "context"):
+        context = _monitoring_execution_context.context
+        if context.trace_id != DEFAULT_TRACE_ID and context.parent_context:
+            return context
+
+    # If no thread-local context, try to restore from global store using current trace_id
+    trace_id = _monitoring_context_store.get_current_trace_id()
+    span_id = _current_span_id.span_id if hasattr(_current_span_id, "span_id") else None
+    if trace_id:
+        if trace_id != DEFAULT_TRACE_ID:
+            context = _monitoring_context_store.retrieve_context(trace_id, span_id)
+            if context:
+                _monitoring_execution_context.context = context
+                return context
+    return ExecutionContext()
+
+
+def set_monitoring_execution_context(context: ExecutionContext) -> None:
+    """Set the current monitoring execution context and persist it for cross-boundary access."""
+    _monitoring_execution_context.context = context
+
+    if context.trace_id and context.parent_context:
+        _monitoring_context_store.store_context(context)

vellum_ai-1.0.6/src/vellum/workflows/integrations/composio_service.py

@@ -0,0 +1,138 @@
+from dataclasses import dataclass
+import logging
+import os
+from typing import Any, Dict, List, Optional
+
+import requests
+
+from vellum.workflows.exceptions import NodeException
+
+logger = logging.getLogger(__name__)
+
+
+@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"
+
+
+class ComposioService:
+    """Composio API client for managing connections and executing tools"""
+
+    def __init__(self, api_key: Optional[str] = None):
+        # If no API key provided, look it up from environment variables
+        if api_key is None:
+            api_key = self._get_api_key_from_env()
+
+        if not api_key:
+            common_env_var_names = ["COMPOSIO_API_KEY", "COMPOSIO_KEY"]
+            raise NodeException(
+                "No Composio API key found. "
+                "Please provide an api_key parameter or set one of these environment variables: "
+                + ", ".join(common_env_var_names)
+            )
+
+        self.api_key = api_key
+        self.base_url = "https://backend.composio.dev/api/v3"
+
+    @staticmethod
+    def _get_api_key_from_env() -> Optional[str]:
+        """Get Composio API key from environment variables"""
+        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:
+                return value
+        return None
+
+    def _make_request(
+        self, endpoint: str, method: str = "GET", params: Optional[dict] = None, json_data: Optional[dict] = None
+    ) -> dict:
+        """Make a request to the Composio API"""
+        headers = {
+            "x-api-key": self.api_key,
+            "Content-Type": "application/json",
+        }
+
+        url = f"{self.base_url}{endpoint}"
+
+        try:
+            if method == "GET":
+                response = requests.get(url, headers=headers, params=params or {}, timeout=30)
+            elif method == "POST":
+                response = requests.post(url, headers=headers, json=json_data or {}, timeout=30)
+            else:
+                raise ValueError(f"Unsupported HTTP method: {method}")
+
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            raise NodeException(f"Composio API request failed: {e}")
+
+    def get_user_connections(self) -> List[ConnectionInfo]:
+        """Get all authorized connections for the user"""
+        response = self._make_request("/connected_accounts")
+
+        return [
+            ConnectionInfo(
+                connection_id=item.get("id"),
+                integration_name=item.get("toolkit", {}).get("slug", ""),
+                status=item.get("status", "ACTIVE"),
+                created_at=item.get("created_at", ""),
+                updated_at=item.get("updated_at", ""),
+            )
+            for item in response.get("items", [])
+        ]
+
+    def get_tool_by_slug(self, tool_slug: str) -> Dict[str, Any]:
+        """Get detailed information about a tool using its slug identifier
+
+        Args:
+            tool_slug: The unique slug identifier of the tool
+
+        Returns:
+            Dictionary containing detailed tool information including:
+            - slug, name, description
+            - toolkit info (slug, name, logo)
+            - input_parameters, output_parameters
+            - no_auth, available_versions, version
+            - scopes, tags, deprecated info
+
+        Raises:
+            NodeException: If tool not found (404), unauthorized (401), or other API errors
+        """
+        endpoint = f"/tools/{tool_slug}"
+
+        try:
+            response = self._make_request(endpoint, method="GET")
+            logger.info(f"Retrieved tool details for slug '{tool_slug}': {response}")
+            return response
+        except Exception as e:
+            # Enhanced error handling for specific cases
+            error_message = str(e)
+            if "404" in error_message:
+                raise NodeException(f"Tool with slug '{tool_slug}' not found in Composio")
+            elif "401" in error_message:
+                raise NodeException(f"Unauthorized access to tool '{tool_slug}'. Check your Composio API key.")
+            else:
+                raise NodeException(f"Failed to retrieve tool details for '{tool_slug}': {error_message}")
+
+    def execute_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Any:
+        """Execute a tool using direct API request
+
+        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
+        """
+        endpoint = f"/tools/execute/{tool_name}"
+        response = self._make_request(endpoint, method="POST", json_data={"arguments": arguments})
+        return response.get("data", response)