vellum-ai 1.2.2__py3-none-any.whl → 1.2.4__py3-none-any.whl

vellum/workflows/expressions/tests/test_contains.py

@@ -0,0 +1,175 @@
+import pytest
+
+from vellum.workflows.constants import undefined
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
+from vellum.workflows.expressions.contains import ContainsExpression
+from vellum.workflows.references.constant import ConstantValueReference
+from vellum.workflows.state.base import BaseState
+
+
+class TestState(BaseState):
+    dict_value: dict = {"key": "value"}
+    list_value: list = [1, 2, 3]
+    string_value: str = "hello world"
+
+
+def test_dict_contains_dict_raises_error():
+    """
+    Tests that ContainsExpression raises clear error for dict-contains-dict scenarios.
+    """
+    state = TestState()
+    lhs_dict = {"foo": "bar"}
+    rhs_dict = {"foo": "bar"}
+
+    expression = ContainsExpression(lhs=lhs_dict, rhs=rhs_dict)
+
+    with pytest.raises(InvalidExpressionException, match="Cannot use dict as right-hand side"):
+        expression.resolve(state)
+
+
+def test_dict_contains_different_dict_raises_error():
+    """
+    Tests that ContainsExpression raises clear error for different dict-contains-dict scenarios.
+    """
+    state = TestState()
+    lhs_dict = {"foo": "bar"}
+    rhs_dict = {"hello": "world"}
+
+    expression = ContainsExpression(lhs=lhs_dict, rhs=rhs_dict)
+
+    with pytest.raises(InvalidExpressionException, match="Cannot use dict as right-hand side"):
+        expression.resolve(state)
+
+
+def test_string_contains_dict_raises_error():
+    """
+    Tests that ContainsExpression raises clear error for string-contains-dict scenarios.
+    """
+    state = TestState()
+    lhs_string = 'Response: {"status": "success"} was returned'
+    rhs_dict = {"status": "success"}
+
+    expression = ContainsExpression(lhs=lhs_string, rhs=rhs_dict)
+
+    with pytest.raises(InvalidExpressionException, match="Cannot use dict as right-hand side"):
+        expression.resolve(state)
+
+
+def test_nested_dict_contains_dict_raises_error():
+    """
+    Tests that ContainsExpression raises clear error for nested dict scenarios.
+    """
+    state = TestState()
+    lhs_dict = {"user": {"name": "john", "age": 30}}
+    rhs_dict = {"age": 30, "name": "john"}
+
+    expression = ContainsExpression(lhs=lhs_dict, rhs=rhs_dict)
+
+    with pytest.raises(InvalidExpressionException, match="Cannot use dict as right-hand side"):
+        expression.resolve(state)
+
+
+def test_list_contains_string():
+    """
+    Tests that ContainsExpression preserves original list functionality.
+    """
+    state = TestState()
+
+    expression = TestState.list_value.contains(2)
+    result = expression.resolve(state)
+
+    assert result is True
+
+
+def test_string_contains_substring():
+    """
+    Tests that ContainsExpression preserves original string functionality.
+    """
+    state = TestState()
+
+    expression = TestState.string_value.contains("world")
+    result = expression.resolve(state)
+
+    assert result is True
+
+
+def test_set_contains_item():
+    """
+    Tests that ContainsExpression works with sets.
+    """
+    state = TestState()
+    lhs_set = {1, 2, 3}
+    rhs_item = 2
+
+    expression = ContainsExpression(lhs=lhs_set, rhs=rhs_item)
+    result = expression.resolve(state)
+
+    assert result is True
+
+
+def test_tuple_contains_item():
+    """
+    Tests that ContainsExpression works with tuples.
+    """
+    state = TestState()
+    lhs_tuple = (1, 2, 3)
+    rhs_item = 2
+
+    expression = ContainsExpression(lhs=lhs_tuple, rhs=rhs_item)
+    result = expression.resolve(state)
+
+    assert result is True
+
+
+def test_invalid_lhs_type():
+    """
+    Tests that ContainsExpression raises exception for invalid LHS types.
+    """
+
+    class NoContainsSupport:
+        pass
+
+    state = TestState()
+    no_contains_obj = NoContainsSupport()
+    expression = ContainsExpression(lhs=no_contains_obj, rhs="test")
+
+    with pytest.raises(
+        InvalidExpressionException, match="Expected a LHS that supported `contains`, got `NoContainsSupport`"
+    ):
+        expression.resolve(state)
+
+
+def test_undefined_lhs_returns_false():
+    """
+    Tests that ContainsExpression returns False for undefined LHS.
+    """
+    state = TestState()
+    expression = ContainsExpression(lhs=undefined, rhs="test")
+
+    result = expression.resolve(state)
+
+    assert result is False
+
+
+def test_contains_with_constant_value_reference():
+    """
+    Tests ContainsExpression with ConstantValueReference for valid operations.
+    """
+    state = TestState()
+    lhs_ref = ConstantValueReference([1, 2, 3])
+    rhs_ref = ConstantValueReference(2)
+
+    expression: ContainsExpression = ContainsExpression(lhs=lhs_ref, rhs=rhs_ref)
+    result = expression.resolve(state)
+
+    assert result is True
+
+
+def test_expression_metadata():
+    """
+    Tests that ContainsExpression has correct name and types properties.
+    """
+    expression = ContainsExpression(lhs=[1, 2, 3], rhs=2)
+
+    assert expression.name == "[1, 2, 3] contains 2"
+    assert expression.types == (bool,)

vellum/workflows/graph/graph.py

@@ -9,40 +9,67 @@ if TYPE_CHECKING:
     from vellum.workflows.nodes.bases.base import BaseNode
     from vellum.workflows.ports.port import Port
 
+
+class NoPortsNode:
+    """Wrapper for nodes that have no ports defined."""
+
+    def __init__(self, node_class: Type["BaseNode"]):
+        self.node_class = node_class
+
+    def __repr__(self) -> str:
+        return self.node_class.__name__
+
+    def __rshift__(self, other: "GraphTarget") -> "Graph":
+        raise ValueError(
+            f"Cannot create edges from {self.node_class.__name__} because it has no ports defined. "
+            f"Nodes with empty Ports classes cannot be connected to other nodes."
+        )
+
+
 GraphTargetOfSets = Union[
     Set[NodeType],
     Set["Graph"],
     Set["Port"],
-    Set[Union[Type["BaseNode"], "Graph", "Port"]],
+    Set[Union[Type["BaseNode"], "Graph", "Port", "NoPortsNode"]],
 ]
 
 GraphTarget = Union[
     Type["BaseNode"],
     "Port",
     "Graph",
+    "NoPortsNode",
     GraphTargetOfSets,
 ]
 
 
 class Graph:
-    _entrypoints: Set["Port"]
+    _entrypoints: Set[Union["Port", "NoPortsNode"]]
     _edges: List[Edge]
-    _terminals: Set["Port"]
-
-    def __init__(self, entrypoints: Set["Port"], edges: List[Edge], terminals: Set["Port"]):
+    _terminals: Set[Union["Port", "NoPortsNode"]]
+
+    def __init__(
+        self,
+        entrypoints: Set[Union["Port", "NoPortsNode"]],
+        edges: List[Edge],
+        terminals: Set[Union["Port", "NoPortsNode"]],
+    ):
         self._edges = edges
         self._entrypoints = entrypoints
         self._terminals = terminals
 
     @staticmethod
     def from_port(port: "Port") -> "Graph":
-        ports = {port}
+        ports: Set[Union["Port", "NoPortsNode"]] = {port}
         return Graph(entrypoints=ports, edges=[], terminals=ports)
 
     @staticmethod
     def from_node(node: Type["BaseNode"]) -> "Graph":
         ports = {port for port in node.Ports}
-        return Graph(entrypoints=ports, edges=[], terminals=ports)
+        if not ports:
+            no_ports_node = NoPortsNode(node)
+            return Graph(entrypoints={no_ports_node}, edges=[], terminals={no_ports_node})
+        ports_set: Set[Union["Port", "NoPortsNode"]] = set(ports)
+        return Graph(entrypoints=ports_set, edges=[], terminals=ports_set)
 
     @staticmethod
     def from_set(targets: GraphTargetOfSets) -> "Graph":
@@ -73,10 +100,19 @@ class Graph:
         if not self._edges and not self._entrypoints:
             raise ValueError("Graph instance can only create new edges from nodes within existing edges")
 
+        if self._terminals and all(isinstance(terminal, NoPortsNode) for terminal in self._terminals):
+            terminal_names = [terminal.node_class.__name__ for terminal in self._terminals]
+            raise ValueError(
+                f"Cannot create edges from graph because all terminal nodes have no ports defined: "
+                f"{', '.join(terminal_names)}. Nodes with empty Ports classes cannot be connected to other nodes."
+            )
+
         if isinstance(other, set):
             new_terminals = set()
             for elem in other:
                 for final_output_node in self._terminals:
+                    if isinstance(final_output_node, NoPortsNode):
+                        continue
                     if isinstance(elem, Graph):
                         midgraph = final_output_node >> set(elem.entrypoints)
                         self._extend_edges(midgraph.edges)
@@ -98,6 +134,8 @@ class Graph:
 
         if isinstance(other, Graph):
             for final_output_node in self._terminals:
+                if isinstance(final_output_node, NoPortsNode):
+                    continue
                 midgraph = final_output_node >> set(other.entrypoints)
                 self._extend_edges(midgraph.edges)
                 self._extend_edges(other.edges)
@@ -106,6 +144,8 @@ class Graph:
 
         if hasattr(other, "Ports"):
             for final_output_node in self._terminals:
+                if isinstance(final_output_node, NoPortsNode):
+                    continue
                 subgraph = final_output_node >> other
                 self._extend_edges(subgraph.edges)
             self._terminals = {port for port in other.Ports}
@@ -113,6 +153,8 @@ class Graph:
 
         # other is a Port
         for final_output_node in self._terminals:
+            if isinstance(final_output_node, NoPortsNode):
+                continue
             subgraph = final_output_node >> other
             self._extend_edges(subgraph.edges)
         self._terminals = {other}
@@ -238,8 +280,10 @@ class Graph:
 
         return "\n".join(lines)
 
-    def _get_port_name(self, port: "Port") -> str:
+    def _get_port_name(self, port: Union["Port", "NoPortsNode"]) -> str:
         """Get a readable name for a port."""
+        if isinstance(port, NoPortsNode):
+            return f"{port.node_class.__name__} (no ports)"
         try:
             if hasattr(port, "node_class") and hasattr(port.node_class, "__name__"):
                 node_name = port.node_class.__name__

vellum/workflows/graph/tests/test_graph.py

@@ -583,3 +583,20 @@ def test_graph__str_single_node():
     # THEN it shows the single node
     assert "SingleNode.default" in result
     assert "Graph:" in result
+
+
+def test_graph__from_node_with_empty_ports():
+    """
+    Tests that building a graph from a single node with empty Ports class generates 1 node.
+    """
+
+    # GIVEN a node with an empty Ports class
+    class NodeWithEmptyPorts(BaseNode):
+        class Ports(BaseNode.Ports):
+            pass
+
+    # WHEN we create a graph from the node
+    graph = Graph.from_node(NodeWithEmptyPorts)
+
+    # THEN the graph should have exactly 1 node
+    assert len(list(graph.nodes)) == 1

vellum/workflows/integrations/mcp_service.py

@@ -73,7 +73,7 @@ class MCPHttpClient:
         # Prepare headers
         headers = {
             "Content-Type": "application/json",
-            "Accept": "application/json",
+            "Accept": "application/json, text/event-stream",
         }
 
         # Include session ID if we have one
@@ -88,11 +88,41 @@ class MCPHttpClient:
         # 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)}")
+        # Handle response based on content type
+        content_type = response.headers.get("content-type", "").lower()
+
+        if "text/event-stream" in content_type:
+            # Handle SSE response
+            response_text = response.text
+
+            # Parse SSE format to extract JSON data
+            lines = response_text.strip().split("\n")
+            json_data = None
+
+            for line in lines:
+                if line.startswith("data: "):
+                    data_content = line[6:]  # Remove 'data: ' prefix
+                    if data_content.strip() and data_content != "[DONE]":
+                        try:
+                            json_data = json.loads(data_content)
+                            break
+                        except json.JSONDecodeError:
+                            continue
+
+            if json_data is None:
+                raise Exception("No valid JSON data found in SSE response")
+
+            response_data = json_data
+        else:
+            # Handle regular JSON response
+            if not response.text.strip():
+                raise Exception("Empty response received from server")
+
+            try:
+                response_data = response.json()
+            except json.JSONDecodeError as e:
+                raise Exception(f"Invalid JSON response: {str(e)}")
 
         if "error" in response_data:
             raise Exception(f"MCP Error: {response_data['error']}")

vellum/workflows/integrations/tests/test_mcp_service.py

@@ -0,0 +1,120 @@
+import asyncio
+import json
+from unittest import mock
+
+from vellum.workflows.constants import AuthorizationType
+from vellum.workflows.integrations.mcp_service import MCPHttpClient, MCPService
+from vellum.workflows.types.definition import MCPServer
+
+
+def test_mcp_http_client_sse_response():
+    """Test that SSE responses are correctly parsed to JSON"""
+    # GIVEN an SSE response from the server
+    sample_sse_response = (
+        "event: message\n"
+        'data: {"result":{"protocolVersion":"2025-06-18",'
+        '"capabilities":{"tools":{"listChanged":true}},'
+        '"serverInfo":{"name":"TestServer","version":"1.0.0"},'
+        '"instructions":"Test server for unit tests."},'
+        '"jsonrpc":"2.0","id":1}\n\n'
+    )
+    expected_json = {
+        "result": {
+            "protocolVersion": "2025-06-18",
+            "capabilities": {"tools": {"listChanged": True}},
+            "serverInfo": {"name": "TestServer", "version": "1.0.0"},
+            "instructions": "Test server for unit tests.",
+        },
+        "jsonrpc": "2.0",
+        "id": 1,
+    }
+
+    with mock.patch("vellum.workflows.integrations.mcp_service.httpx.AsyncClient") as mock_client_class:
+        mock_client = mock.AsyncMock()
+        mock_client_class.return_value = mock_client
+
+        mock_response = mock.Mock()
+        mock_response.headers = {"content-type": "text/event-stream"}
+        mock_response.text = sample_sse_response
+        mock_client.post.return_value = mock_response
+
+        # WHEN we send a request through the MCP client
+        async def test_request():
+            async with MCPHttpClient("https://test.server.com", {}) as client:
+                result = await client._send_request("initialize", {"test": "params"})
+                return result
+
+        result = asyncio.run(test_request())
+
+        # THEN the SSE response should be parsed correctly to JSON
+        assert result == expected_json
+
+        # AND the request should have been made with correct headers
+        mock_client.post.assert_called_once()
+        call_args = mock_client.post.call_args
+        assert call_args[1]["headers"]["Accept"] == "application/json, text/event-stream"
+        assert call_args[1]["headers"]["Content-Type"] == "application/json"
+
+
+def test_mcp_http_client_json_response():
+    """Test that regular JSON responses still work"""
+    # GIVEN a regular JSON response from the server
+    sample_json_response = {"result": {"test": "data"}, "jsonrpc": "2.0", "id": 1}
+
+    with mock.patch("vellum.workflows.integrations.mcp_service.httpx.AsyncClient") as mock_client_class:
+        mock_client = mock.AsyncMock()
+        mock_client_class.return_value = mock_client
+
+        mock_response = mock.Mock()
+        mock_response.headers = {"content-type": "application/json"}
+        mock_response.text = json.dumps(sample_json_response)
+        mock_response.json.return_value = sample_json_response
+        mock_client.post.return_value = mock_response
+
+        # WHEN we send a request through the MCP client
+        async def test_request():
+            async with MCPHttpClient("https://test.server.com", {}) as client:
+                result = await client._send_request("initialize", {"test": "params"})
+                return result
+
+        result = asyncio.run(test_request())
+
+        # THEN the JSON response should be returned as expected
+        assert result == sample_json_response
+
+
+def test_mcp_service_bearer_token_auth():
+    """Test that bearer token auth headers are set correctly"""
+    # GIVEN an MCP server with bearer token auth
+    server = MCPServer(
+        name="test-server",
+        url="https://test.server.com",
+        authorization_type=AuthorizationType.BEARER_TOKEN,
+        bearer_token_value="test-token-123",
+    )
+
+    # WHEN we get auth headers
+    service = MCPService()
+    headers = service._get_auth_headers(server)
+
+    # THEN the Authorization header should be set correctly
+    assert headers == {"Authorization": "Bearer test-token-123"}
+
+
+def test_mcp_service_api_key_auth():
+    """Test that API key auth headers are set correctly"""
+    # GIVEN an MCP server with API key auth
+    server = MCPServer(
+        name="test-server",
+        url="https://test.server.com",
+        authorization_type=AuthorizationType.API_KEY,
+        api_key_header_key="X-API-Key",
+        api_key_header_value="api-key-123",
+    )
+
+    # WHEN we get auth headers
+    service = MCPService()
+    headers = service._get_auth_headers(server)
+
+    # THEN the custom API key header should be set correctly
+    assert headers == {"X-API-Key": "api-key-123"}

vellum/workflows/nodes/core/error_node/node.py

@@ -4,6 +4,7 @@ from vellum.client.types.vellum_error import VellumError
 from vellum.workflows.errors.types import WorkflowError, WorkflowErrorCode, vellum_error_to_workflow_error
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.ports import NodePorts
 
 
 class ErrorNode(BaseNode):
@@ -15,6 +16,9 @@ class ErrorNode(BaseNode):
 
     error: ClassVar[Union[str, WorkflowError, VellumError]]
 
+    class Ports(NodePorts):
+        pass
+
     def run(self) -> BaseNode.Outputs:
         if isinstance(self.error, str):
             raise NodeException(message=self.error, code=WorkflowErrorCode.USER_DEFINED_ERROR)

vellum/workflows/nodes/core/map_node/node.py

@@ -30,6 +30,7 @@ from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.references.output import OutputReference
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.types.generics import StateType
+from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
 if TYPE_CHECKING:
@@ -211,4 +212,10 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
         annotation = List[parameter_type]  # type: ignore[valid-type]
 
         previous_annotations = {prev: annotation for prev in outputs_class.__annotations__ if not prev.startswith("_")}
+        # Map node output is a list of the same type so we use annotation=List[parameter_type] and not reference
+        # class Outputs(BaseOutputs):
+        #     value: List[str]
         outputs_class.__annotations__ = {**previous_annotations, reference.name: annotation}
+
+        output_id = uuid4_from_hash(f"{cls.__id__}|{reference.name}")
+        cls.__output_ids__[reference.name] = output_id

vellum/workflows/nodes/core/map_node/tests/test_node.py

@@ -119,6 +119,7 @@ def test_map_node__inner_try():
     # THEN the workflow should succeed
     assert outputs[-1].name == "final_output"
     assert len(outputs[-1].value) == 2
+    assert len(SimpleMapNode.__output_ids__) == 1
 
 
 def test_map_node__nested_map_node():
@@ -275,3 +276,21 @@ def test_map_node__shared_state_race_condition():
         # AND all results should be in correct order
         expected_result = ["a!", "b!", "c!", "d!", "e!", "f!"]
         assert final_result == expected_result, f"Failed on run {index}"
+
+
+def test_map_node__output_ids():
+    class TestNode(BaseNode):
+        class Outputs(BaseOutputs):
+            value: str
+
+    class SimpleMapNodeWorkflow(BaseWorkflow[MapNode.SubworkflowInputs, BaseState]):
+        graph = TestNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_output = TestNode.Outputs.value
+
+    class TestMapNode(MapNode):
+        items = [1, 2, 3]
+        subworkflow = SimpleMapNodeWorkflow
+
+    assert len(TestMapNode.__output_ids__) == 1

vellum/workflows/nodes/core/templating_node/node.py

@@ -7,7 +7,7 @@ from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.bases.base import BaseNodeMeta
-from vellum.workflows.nodes.utils import parse_type_from_str
+from vellum.workflows.nodes.utils import parse_type_from_str, wrap_inputs_for_backward_compatibility
 from vellum.workflows.types.core import EntityInputsInterface
 from vellum.workflows.types.generics import StateType
 from vellum.workflows.types.utils import get_original_base
@@ -86,9 +86,10 @@ class TemplatingNode(BaseNode[StateType], Generic[StateType, _OutputType], metac
 
     def _render_template(self) -> str:
         try:
+            wrapped_inputs = wrap_inputs_for_backward_compatibility(self.inputs)
             return render_sandboxed_jinja_template(
                 template=self.template,
-                input_values=self.inputs,
+                input_values=wrapped_inputs,
                 jinja_custom_filters={**self.jinja_custom_filters},
                 jinja_globals=self.jinja_globals,
             )