vellum-ai 1.0.7__tar.gz → 1.0.9__tar.gz

{vellum_ai-1.0.7 → vellum_ai-1.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 1.0.7
+Version: 1.0.9
 Summary: 
 License: MIT
 Requires-Python: >=3.9,<4.0

{vellum_ai-1.0.7 → vellum_ai-1.0.9}/ee/vellum_cli/push.py

@@ -67,7 +67,10 @@ def push_command(
             raise ValueError(f"No workflow config for '{module}' found in project to push.")
 
     if len(workflow_configs) > 1:
-        raise ValueError("Multiple workflows found in project to push. Pushing only a single workflow is supported.")
+        raise ValueError(
+            "Multiple workflows found. Please specify a single workflow to push. "
+            f"Found: {', '.join([w.module for w in workflow_configs])}"
+        )
 
     workflow_config = workflow_configs[0]
 
@@ -95,8 +98,9 @@ def push_command(
         and workflow_config.workflow_sandbox_id
         and workflow_config.workflow_sandbox_id != workflow_sandbox_id
     ):
-        raise ValueError(
-            f"Workflow sandbox id '{workflow_sandbox_id}' is already associated with '{workflow_config.module}'."
+        logger.warning(
+            f"Workflow sandbox id '{workflow_sandbox_id}' is already associated with '{workflow_config.module}'. "
+            f"Continuing with the provided workflow sandbox id '{workflow_sandbox_id}'."
         )
 
     client = create_vellum_client(

{vellum_ai-1.0.7 → vellum_ai-1.0.9}/ee/vellum_cli/tests/test_push.py

@@ -77,9 +77,8 @@ def test_push__multiple_workflows_configured__no_module_specified(mock_module):
     # THEN it should fail
     assert result.exit_code == 1
     assert result.exception
-    assert (
-        str(result.exception)
-        == "Multiple workflows found in project to push. Pushing only a single workflow is supported."
+    assert str(result.exception) == (
+        "Multiple workflows found. Please specify a single workflow to push. Found: examples.mock, examples.mock2"
     )
 
 
@@ -349,9 +348,8 @@ def test_push__workflow_sandbox_option__existing_id_different_module(mock_module
     # THEN it should fail
     assert result.exit_code == 1
     assert result.exception
-    assert (
-        str(result.exception)
-        == "Multiple workflows found in project to push. Pushing only a single workflow is supported."
+    assert str(result.exception) == (
+        f"Multiple workflows found. Please specify a single workflow to push. Found: {module}, {second_module}"
     )
 
 

{vellum_ai-1.0.7 → vellum_ai-1.0.9}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_inline_workflow_serialization.py

@@ -407,6 +407,11 @@ def test_serialize_workflow():
                     ],
                 },
             },
+            {
+                "id": "89084be2-0853-4483-9031-c24bdf872c32",
+                "name": "tool_sources",
+                "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": []}},
+            },
             {
                 "id": "229cd1ca-dc2f-4586-b933-c4d4966f7bd1",
                 "name": "parameters",

{vellum_ai-1.0.7 → vellum_ai-1.0.9}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_serialization.py

@@ -175,6 +175,11 @@ def test_serialize_workflow():
                     ],
                 },
             },
+            {
+                "id": "89084be2-0853-4483-9031-c24bdf872c32",
+                "name": "tool_sources",
+                "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": []}},
+            },
             {
                 "id": "229cd1ca-dc2f-4586-b933-c4d4966f7bd1",
                 "name": "parameters",

{vellum_ai-1.0.7 → vellum_ai-1.0.9}/pyproject.toml

@@ -3,7 +3,7 @@ name = "vellum-ai"
 
 [tool.poetry]
 name = "vellum-ai"
-version = "1.0.7"
+version = "1.0.9"
 description = ""
 readme = "README.md"
 authors = []

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

{vellum_ai-1.0.7 → vellum_ai-1.0.9}/src/vellum/client/resources/workflows/client.py

@@ -27,6 +27,7 @@ class WorkflowsClient:
         id: str,
         *,
         exclude_code: typing.Optional[bool] = None,
+        exclude_display: typing.Optional[bool] = None,
         include_json: typing.Optional[bool] = None,
         include_sandbox: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
@@ -40,6 +41,8 @@ class WorkflowsClient:
 
         exclude_code : typing.Optional[bool]
 
+        exclude_display : typing.Optional[bool]
+
         include_json : typing.Optional[bool]
 
         include_sandbox : typing.Optional[bool]
@@ -60,6 +63,7 @@ class WorkflowsClient:
             method="GET",
             params={
                 "exclude_code": exclude_code,
+                "exclude_display": exclude_display,
                 "include_json": include_json,
                 "include_sandbox": include_sandbox,
                 "strict": strict,
@@ -165,6 +169,7 @@ class AsyncWorkflowsClient:
         id: str,
         *,
         exclude_code: typing.Optional[bool] = None,
+        exclude_display: typing.Optional[bool] = None,
         include_json: typing.Optional[bool] = None,
         include_sandbox: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
@@ -178,6 +183,8 @@ class AsyncWorkflowsClient:
 
         exclude_code : typing.Optional[bool]
 
+        exclude_display : typing.Optional[bool]
+
         include_json : typing.Optional[bool]
 
         include_sandbox : typing.Optional[bool]
@@ -198,6 +205,7 @@ class AsyncWorkflowsClient:
             method="GET",
             params={
                 "exclude_code": exclude_code,
+                "exclude_display": exclude_display,
                 "include_json": include_json,
                 "include_sandbox": include_sandbox,
                 "strict": strict,

{vellum_ai-1.0.7 → vellum_ai-1.0.9}/src/vellum/client/types/document_document_to_document_index.py

@@ -22,7 +22,7 @@ class DocumentDocumentToDocumentIndex(UniversalBaseModel):
     Vellum-generated ID that uniquely identifies the environment index this document is included in.
     """
 
-    document_index_id: str = pydantic.Field()
+    document_index_id: typing.Optional[str] = pydantic.Field(default=None)
     """
     Vellum-generated ID that uniquely identifies the index this document is included in.
     """

{vellum_ai-1.0.7 → vellum_ai-1.0.9}/src/vellum/client/types/organization_read.py

@@ -2,6 +2,7 @@
 
 from ..core.pydantic_utilities import UniversalBaseModel
 import typing
+import datetime as dt
 from .new_member_join_behavior_enum import NewMemberJoinBehaviorEnum
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import pydantic
@@ -10,6 +11,7 @@ import pydantic
 class OrganizationRead(UniversalBaseModel):
     id: str
     name: str
+    created: typing.Optional[dt.datetime] = None
     allow_staff_access: typing.Optional[bool] = None
     new_member_join_behavior: NewMemberJoinBehaviorEnum
     limit_config: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = None

{vellum_ai-1.0.7 → vellum_ai-1.0.9}/src/vellum/client/types/slim_document_document_to_document_index.py

@@ -22,7 +22,7 @@ class SlimDocumentDocumentToDocumentIndex(UniversalBaseModel):
     Vellum-generated ID that uniquely identifies the environment index this document is included in.
     """
 
-    document_index_id: str = pydantic.Field()
+    document_index_id: typing.Optional[str] = pydantic.Field(default=None)
     """
     Vellum-generated ID that uniquely identifies the index this document is included in.
     """

{vellum_ai-1.0.7 → vellum_ai-1.0.9}/src/vellum/plugins/pydantic.py

@@ -28,9 +28,12 @@ def import_base_descriptor():
     """
     We have to avoid importing from vellum.* in this file because it will cause a circular import.
     """
-    from vellum.workflows.descriptors.base import BaseDescriptor
+    try:
+        from vellum.workflows.descriptors.base import BaseDescriptor
 
-    return BaseDescriptor
+        return BaseDescriptor
+    except Exception:
+        return None
 
 
 # https://docs.pydantic.dev/2.8/concepts/plugins/#build-a-plugin
@@ -60,6 +63,10 @@ class OnValidatePython(ValidatePythonHandlerProtocol):
         self.tracked_descriptors = {}
         BaseDescriptor = import_base_descriptor()
 
+        # If BaseDescriptor import failed, skip descriptor processing
+        if BaseDescriptor is None:
+            return
+
         for key, value in input.items():
             field_info = model_fields.get(key)
             if isinstance(value, BaseDescriptor) and (

{vellum_ai-1.0.7 → vellum_ai-1.0.9}/src/vellum/workflows/integrations/composio_service.py

@@ -5,6 +5,7 @@ from typing import Any, Dict, List, Optional
 
 import requests
 
+from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 
 logger = logging.getLogger(__name__)
@@ -72,6 +73,17 @@ class ComposioService:
 
             response.raise_for_status()
             return response.json()
+        except requests.exceptions.HTTPError as e:
+            if e.response.status_code == 401:
+                raise NodeException(
+                    message="Failed to authorize Composio request. Make sure to define a COMPOSIO_API_KEY",
+                    code=WorkflowErrorCode.PROVIDER_CREDENTIALS_UNAVAILABLE,
+                )
+            else:
+                response_text = e.response.text if e.response else "No response"
+                raise NodeException(
+                    f"Composio API request failed with status {e.response.status_code}: {response_text}"
+                )
         except Exception as e:
             raise NodeException(f"Composio API request failed: {e}")
 

vellum_ai-1.0.9/src/vellum/workflows/integrations/mcp_service.py

@@ -0,0 +1,245 @@
+import asyncio
+import json
+import logging
+from typing import Any, Dict, List, Optional
+
+import httpx
+
+from vellum.workflows.constants import AuthorizationType
+from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.types.core import VellumSecret
+from vellum.workflows.types.definition import MCPServer, MCPToolDefinition
+
+logger = logging.getLogger(__name__)
+
+
+class MCPHttpClient:
+    """
+    Direct HTTP implementation for MCP (Model Context Protocol) client
+    without using the official Python SDK.
+
+    Supports Streamable HTTP transport using httpx.
+    """
+
+    def __init__(self, server_url: str, headers: Dict[str, str], session_timeout: int = 30):
+        """
+        Initialize MCP HTTP client.
+
+        Args:
+            server_url: The MCP server endpoint URL (e.g., "https://example.com/mcp")
+            headers: Authentication headers
+            session_timeout: Timeout for HTTP requests in seconds
+        """
+        self.server_url = server_url.rstrip("/")
+        self.headers = headers
+        self.session_timeout = session_timeout
+        self.session_id: Optional[str] = None
+        self.request_id = 0
+        self._client: Optional[httpx.AsyncClient] = None
+
+    async def __aenter__(self):
+        """Async context manager entry."""
+        self._client = httpx.AsyncClient(timeout=httpx.Timeout(self.session_timeout), headers=self.headers)
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        if self._client:
+            await self._client.aclose()
+
+    def _next_request_id(self) -> int:
+        """Generate next request ID."""
+        self.request_id += 1
+        return self.request_id
+
+    async def _send_request(self, method: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Send a JSON-RPC request to the MCP server.
+
+        Args:
+            method: The JSON-RPC method name
+            params: Optional parameters for the method
+
+        Returns:
+            The JSON-RPC response
+        """
+        if not self._client:
+            raise RuntimeError("Client session not initialized. Use 'async with' context manager.")
+
+        # Prepare JSON-RPC request
+        request_data = {"jsonrpc": "2.0", "id": self._next_request_id(), "method": method, "params": params or {}}
+
+        # Prepare headers
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+
+        # Include session ID if we have one
+        if self.session_id:
+            headers["Mcp-Session-Id"] = self.session_id
+
+        logger.debug(f"Sending request: {json.dumps(request_data, indent=2)}")
+
+        # Send POST request
+        response = await self._client.post(self.server_url, json=request_data, headers=headers)
+
+        # Check for session ID in response headers
+        if "Mcp-Session-Id" in response.headers:
+            self.session_id = response.headers["Mcp-Session-Id"]
+            logger.debug(f"Received session ID: {self.session_id}")
+
+        # Handle JSON response
+        response_data = response.json()
+        logger.debug(f"Received response: {json.dumps(response_data, indent=2)}")
+
+        if "error" in response_data:
+            raise Exception(f"MCP Error: {response_data['error']}")
+
+        return response_data
+
+    async def initialize(self, client_info: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Initialize the MCP connection.
+
+        Args:
+            client_info: Optional client information
+
+        Returns:
+            Server capabilities and information
+        """
+        params = {
+            "protocolVersion": "2025-06-18",
+            "capabilities": {},
+            "clientInfo": client_info or {"name": "vellum-mcp-client", "version": "1.0.0"},
+        }
+
+        response = await self._send_request("initialize", params)
+        return response.get("result", {})
+
+    async def list_tools(self) -> List[Dict[str, Any]]:
+        """
+        Get list of available tools from the server.
+
+        Returns:
+            List of tool definitions
+        """
+        response = await self._send_request("tools/list")
+        return response.get("result", {}).get("tools", [])
+
+    async def call_tool(self, name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Call a tool on the server.
+
+        Args:
+            name: Tool name
+            arguments: Tool arguments
+
+        Returns:
+            Tool execution result
+        """
+        params = {"name": name, "arguments": arguments}
+
+        response = await self._send_request("tools/call", params)
+        return response.get("result", {})
+
+
+class MCPService:
+    def _get_auth_headers(self, server: MCPServer) -> Dict[str, str]:
+        headers = {}
+        if server.authorization_type == AuthorizationType.BEARER_TOKEN:
+            token = server.bearer_token_value
+            if not token:
+                raise NodeException(
+                    "Bearer token is required for BEARER_TOKEN authorization type",
+                    code=WorkflowErrorCode.INVALID_INPUTS,
+                )
+
+            headers["Authorization"] = f"Bearer {token}"
+
+        elif server.authorization_type == AuthorizationType.API_KEY:
+            key = server.api_key_header_key
+            value = server.api_key_header_value
+            if not key or not value:
+                raise NodeException(
+                    "API key header key and value are required for API_KEY authorization type",
+                    code=WorkflowErrorCode.INVALID_INPUTS,
+                )
+            if isinstance(value, VellumSecret):
+                headers[key] = value.name
+            elif isinstance(value, str):
+                headers[key] = value
+
+        return headers
+
+    async def _execute_mcp_call(self, server: MCPServer, operation: str, **kwargs) -> Any:
+        """Execute an MCP operation using direct HTTP calls."""
+        headers = self._get_auth_headers(server)
+
+        try:
+            async with MCPHttpClient(server.url, headers) as client:
+                await client.initialize()
+
+                if operation == "list_tools":
+                    return await client.list_tools()
+                elif operation == "call_tool":
+                    return await client.call_tool(
+                        name=kwargs["name"],
+                        arguments=kwargs["arguments"],
+                    )
+                else:
+                    raise ValueError(f"Unknown MCP operation: {operation}")
+
+        except Exception as e:
+            logger.error(f"Error executing MCP operation {operation}: {e}")
+            raise NodeException(
+                message=f"Error executing MCP operation '{operation}': {str(e)}",
+                code=WorkflowErrorCode.NODE_EXECUTION,
+            )
+
+    def list_tools(self, server: MCPServer) -> List[Dict[str, Any]]:
+        """List available tools from an MCP server."""
+        try:
+            tools = asyncio.run(self._execute_mcp_call(server, "list_tools"))
+            return tools
+        except Exception as e:
+            logger.warning(f"Failed to list tools from MCP server '{server.name}': {e}")
+            return []
+
+    def execute_tool(self, tool_def: MCPToolDefinition, arguments: Dict[str, Any]) -> Any:
+        """Execute a tool on an MCP server."""
+        try:
+            result = asyncio.run(
+                self._execute_mcp_call(
+                    tool_def.server,
+                    "call_tool",
+                    name=tool_def.name,
+                    arguments=arguments,
+                )
+            )
+            return result
+        except Exception as e:
+            logger.error(f"Error executing MCP tool '{tool_def.name}': {e}")
+            raise NodeException(
+                message=f"Error executing MCP tool '{tool_def.name}': {str(e)}",
+                code=WorkflowErrorCode.NODE_EXECUTION,
+            )
+
+    def hydrate_tool_definitions(self, server_def: MCPServer) -> List[MCPToolDefinition]:
+        """Hydrate an MCPToolDefinition with detailed information from the MCP server."""
+        try:
+            tools = self.list_tools(server_def)
+
+            return [
+                MCPToolDefinition(
+                    name=tool["name"],
+                    server=server_def,
+                    description=tool["description"],
+                    parameters=tool["inputSchema"],
+                )
+                for tool in tools
+            ]
+        except Exception as e:
+            logger.warning(f"Failed to hydrate MCP server '{server_def.name}': {e}")
+            return []

{vellum_ai-1.0.7 → vellum_ai-1.0.9}/src/vellum/workflows/nodes/displayable/tool_calling_node/node.py

@@ -15,10 +15,12 @@ from vellum.workflows.nodes.displayable.tool_calling_node.utils import (
     create_function_node,
     create_tool_router_node,
     get_function_name,
+    hydrate_mcp_tool_definitions,
 )
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
 from vellum.workflows.state.context import WorkflowContext
-from vellum.workflows.types.core import EntityInputsInterface, Tool
+from vellum.workflows.types.core import EntityInputsInterface, Tool, ToolSource
+from vellum.workflows.types.definition import MCPServer
 from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
 
@@ -30,6 +32,7 @@ class ToolCallingNode(BaseNode):
         ml_model: str - The model to use for tool calling (e.g., "gpt-4o-mini")
         blocks: List[PromptBlock] - The prompt blocks to use (same format as InlinePromptNode)
         functions: List[Tool] - The functions that can be called
+        tool_sources: List[ToolSource] - The tool sources that can be called
         prompt_inputs: Optional[EntityInputsInterface] - Mapping of input variable names to values
         parameters: PromptParameters - The parameters for the Prompt
         max_prompt_iterations: Optional[int] - Maximum number of prompt iterations before stopping
@@ -38,6 +41,7 @@ class ToolCallingNode(BaseNode):
     ml_model: ClassVar[str] = "gpt-4o-mini"
     blocks: ClassVar[List[Union[PromptBlock, Dict[str, Any]]]] = []
     functions: ClassVar[List[Tool]] = []
+    tool_sources: ClassVar[List[ToolSource]] = []
     prompt_inputs: ClassVar[Optional[EntityInputsInterface]] = None
     parameters: PromptParameters = DEFAULT_PROMPT_PARAMETERS
     max_prompt_iterations: ClassVar[Optional[int]] = 5
@@ -134,6 +138,7 @@ class ToolCallingNode(BaseNode):
             ml_model=self.ml_model,
             blocks=self.blocks,
             functions=self.functions,
+            tool_sources=self.tool_sources,
             prompt_inputs=self.prompt_inputs,
             parameters=self.parameters,
             max_prompt_iterations=self.max_prompt_iterations,
@@ -148,6 +153,17 @@ class ToolCallingNode(BaseNode):
                 tool_router_node=self.tool_router_node,
             )
 
+        for tool_source in self.tool_sources:
+            if isinstance(tool_source, MCPServer):
+                tool_definitions = hydrate_mcp_tool_definitions(tool_source)
+                for tool_definition in tool_definitions:
+                    function_name = get_function_name(tool_definition)
+
+                    self._function_nodes[function_name] = create_function_node(
+                        function=tool_definition,
+                        tool_router_node=self.tool_router_node,
+                    )
+
         graph_set = set()
 
         # Add connections from ports of router to function nodes and back to router

{vellum_ai-1.0.7 → vellum_ai-1.0.9}/src/vellum/workflows/nodes/displayable/tool_calling_node/tests/test_node.py

@@ -39,6 +39,7 @@ def test_port_condition_match_function_name():
         ml_model="test-model",
         blocks=[],
         functions=[first_function, second_function],
+        tool_sources=[],
         prompt_inputs=None,
         parameters=DEFAULT_PROMPT_PARAMETERS,
     )
@@ -97,6 +98,7 @@ def test_tool_calling_node_inline_workflow_context():
         ml_model="test-model",
         blocks=[],
         functions=[MyWorkflow],
+        tool_sources=[],
         prompt_inputs=None,
         parameters=DEFAULT_PROMPT_PARAMETERS,
     )

{vellum_ai-1.0.7 → vellum_ai-1.0.9}/src/vellum/workflows/nodes/displayable/tool_calling_node/tests/test_utils.py

@@ -15,7 +15,7 @@ from vellum.workflows.nodes.bases import BaseNode
 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
+from vellum.workflows.types.definition import ComposioToolDefinition, DeploymentDefinition, MCPServer, MCPToolDefinition
 
 
 def test_get_function_name_callable():
@@ -69,6 +69,19 @@ def test_get_function_name_subworkflow_deployment_uuid():
     assert result == "57f09bebb46340e0bf9ec972e664352f"
 
 
+def test_get_function_name_mcp_tool_definition():
+    """Test MCPToolDefinition function name generation."""
+    mcp_tool = MCPToolDefinition(
+        name="create_repository",
+        server=MCPServer(name="github", url="https://api.github.com"),
+        parameters={"repository_name": "string", "description": "string"},
+    )
+
+    result = get_function_name(mcp_tool)
+
+    assert result == "github__create_repository"
+
+
 @pytest.mark.parametrize(
     "toolkit,action,description,expected_result",
     [
@@ -93,6 +106,7 @@ def test_create_tool_router_node_max_prompt_iterations(vellum_adhoc_prompt_clien
         ml_model="gpt-4o-mini",
         blocks=[],
         functions=[],
+        tool_sources=[],
         prompt_inputs=None,
         parameters=DEFAULT_PROMPT_PARAMETERS,
         max_prompt_iterations=None,
@@ -152,6 +166,7 @@ def test_create_tool_router_node_chat_history_block_dict(vellum_adhoc_prompt_cli
         ml_model="gpt-4o-mini",
         blocks=blocks,  # type: ignore
         functions=[],
+        tool_sources=[],
         prompt_inputs=None,
         parameters=DEFAULT_PROMPT_PARAMETERS,
     )