vellum-ai 1.0.4__py3-none-any.whl → 1.0.6__py3-none-any.whl

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/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/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/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/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/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)

vellum/workflows/nodes/displayable/bases/api_node/node.py

@@ -5,6 +5,7 @@ from requests.exceptions import JSONDecodeError
 
 from vellum.client import ApiError
 from vellum.client.core.request_options import RequestOptions
+from vellum.client.types.method_enum import MethodEnum
 from vellum.client.types.vellum_secret import VellumSecret as ClientVellumSecret
 from vellum.workflows.constants import APIRequestMethod
 from vellum.workflows.errors.types import WorkflowErrorCode
@@ -20,7 +21,7 @@ class BaseAPINode(BaseNode, Generic[StateType]):
     Used to execute an API call.
 
     url: str - The URL to send the request to.
-    method: APIRequestMethod - The HTTP method to use for the request.
+    method: Union[APIRequestMethod, str] - The HTTP method to use for the request.
     data: Optional[str] - The data to send in the request body.
     json: Optional["JsonObject"] - The JSON data to send in the request body.
     headers: Optional[Dict[str, Union[str, VellumSecret]]] - The headers to send in the request.
@@ -31,7 +32,7 @@ class BaseAPINode(BaseNode, Generic[StateType]):
         merge_behavior = MergeBehavior.AWAIT_ANY
 
     url: str = ""
-    method: Optional[APIRequestMethod] = APIRequestMethod.GET
+    method: Optional[Union[APIRequestMethod, MethodEnum]] = APIRequestMethod.GET
     data: Optional[str] = None
     json: Optional[Json] = None
     headers: Optional[Dict[str, Union[str, VellumSecret]]] = None
@@ -43,6 +44,21 @@ class BaseAPINode(BaseNode, Generic[StateType]):
         status_code: int
         text: str
 
+    def _normalize_http_method(self, method: Union[APIRequestMethod, MethodEnum]) -> str:
+        if isinstance(method, APIRequestMethod):
+            method_str = method.value
+        elif isinstance(method, str):
+            method_str = method.upper()
+            valid_methods = {m.value for m in APIRequestMethod}
+            if method_str not in valid_methods:
+                raise NodeException(f"Invalid HTTP method '{method}'", code=WorkflowErrorCode.INVALID_INPUTS)
+        else:
+            raise NodeException(
+                f"Method must be either APIRequestMethod enum or string, got {type(method)}",
+                code=WorkflowErrorCode.INVALID_INPUTS,
+            )
+        return method_str
+
     def _validate(self) -> None:
         if not self.url or not isinstance(self.url, str) or not self.url.strip():
             raise NodeException("URL is required and must be a non-empty string", code=WorkflowErrorCode.INVALID_INPUTS)
@@ -55,7 +71,7 @@ class BaseAPINode(BaseNode, Generic[StateType]):
     def _run(
         self,
         url: str,
-        method: Optional[APIRequestMethod] = APIRequestMethod.GET,
+        method: Optional[Union[APIRequestMethod, MethodEnum]] = APIRequestMethod.GET,
         data: Optional[Union[str, Any]] = None,
         json: Any = None,
         headers: Any = None,
@@ -64,23 +80,25 @@ class BaseAPINode(BaseNode, Generic[StateType]):
     ) -> Outputs:
         self._validate()
 
+        normalized_method = self._normalize_http_method(method) if method is not None else APIRequestMethod.GET.value
+
         vellum_instance = False
         for header in headers or {}:
             if isinstance(headers[header], VellumSecret):
                 vellum_instance = True
         if vellum_instance or bearer_token:
-            return self._vellum_execute_api(bearer_token, json, headers, method, url, timeout)
+            return self._vellum_execute_api(bearer_token, json, headers, normalized_method, url, timeout)
         else:
-            return self._local_execute_api(data, headers, json, method, url, timeout)
+            return self._local_execute_api(data, headers, json, normalized_method, url, timeout)
 
     def _local_execute_api(self, data, headers, json, method, url, timeout):
         try:
             if data is not None:
-                prepped = Request(method=method.value, url=url, data=data, headers=headers).prepare()
+                prepped = Request(method=method, url=url, data=data, headers=headers).prepare()
             elif json is not None:
-                prepped = Request(method=method.value, url=url, json=json, headers=headers).prepare()
+                prepped = Request(method=method, url=url, json=json, headers=headers).prepare()
             else:
-                prepped = Request(method=method.value, url=url, headers=headers).prepare()
+                prepped = Request(method=method, url=url, headers=headers).prepare()
         except Exception as e:
             raise NodeException(f"Failed to prepare HTTP request: {e}", code=WorkflowErrorCode.PROVIDER_ERROR)
         try:
@@ -110,7 +128,7 @@ class BaseAPINode(BaseNode, Generic[StateType]):
         try:
             vellum_response = self._context.vellum_client.execute_api(
                 url=url,
-                method=method.value,
+                method=method,
                 body=data,
                 headers=headers,
                 bearer_token=client_vellum_secret,

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

@@ -0,0 +1,47 @@
+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)