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

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,81 @@
+import asyncio
+import json
+from unittest import mock
+
+from vellum.workflows.integrations.mcp_service import MCPHttpClient
+
+
+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

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/displayable/final_output_node/node.py

@@ -4,6 +4,7 @@ from vellum.workflows.constants import undefined
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.bases.base import BaseNodeMeta
 from vellum.workflows.nodes.utils import cast_to_output_type
+from vellum.workflows.ports import NodePorts
 from vellum.workflows.types import MergeBehavior
 from vellum.workflows.types.generics import StateType
 from vellum.workflows.types.utils import get_original_base
@@ -47,6 +48,9 @@ class FinalOutputNode(BaseNode[StateType], Generic[StateType, _OutputType], meta
     class Trigger(BaseNode.Trigger):
         merge_behavior = MergeBehavior.AWAIT_ANY
 
+    class Ports(NodePorts):
+        pass
+
     class Outputs(BaseNode.Outputs):
         # We use our mypy plugin to override the _OutputType with the actual output type
         # for downstream references to this output.

vellum/workflows/nodes/displayable/subworkflow_deployment_node/node.py

@@ -232,7 +232,7 @@ class SubworkflowDeploymentNode(BaseNode[StateType], Generic[StateType]):
             )
 
         resolved_workflow = self._context.resolve_workflow_deployment(
-            deployment_name=deployment_name, release_tag=self.release_tag
+            deployment_name=deployment_name, release_tag=self.release_tag, state=self.state
         )
         if resolved_workflow:
             yield from self._run_resolved_workflow(resolved_workflow)

vellum/workflows/ports/node_ports.py

@@ -40,6 +40,9 @@ class NodePorts(metaclass=_NodePortsMeta):
 
         invoked_ports: Set[Port] = set()
         all_ports = [port for port in self.__class__]
+        if not all_ports:
+            return set()
+
         enforce_single_invoked_conditional_port = validate_ports(all_ports)
 
         for port in all_ports:

vellum/workflows/ports/port.py

@@ -9,6 +9,7 @@ from vellum.workflows.edges.edge import Edge
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.graph import Graph, GraphTarget
+from vellum.workflows.graph.graph import NoPortsNode
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.types.core import ConditionType
 
@@ -66,6 +67,12 @@ class Port:
         if isinstance(other, Port):
             return Graph.from_port(self) >> Graph.from_port(other)
 
+        if isinstance(other, NoPortsNode):
+            raise ValueError(
+                f"Cannot create edge to {other.node_class.__name__} because it has no ports defined. "
+                f"Nodes with empty Ports classes cannot be connected to other nodes."
+            )
+
         edge = Edge(from_port=self, to_node=other)
         if edge not in self._edges:
             self._edges.append(edge)

vellum/workflows/state/context.py

@@ -4,15 +4,17 @@ from uuid import uuid4
 from typing import TYPE_CHECKING, Dict, List, Optional, Type
 
 from vellum import Vellum
-from vellum.workflows.context import ExecutionContext, get_execution_context
+from vellum.workflows.context import ExecutionContext, get_execution_context, set_execution_context
 from vellum.workflows.events.types import ExternalParentContext
 from vellum.workflows.nodes.mocks import MockNodeExecution, MockNodeExecutionArg
 from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.references.constant import ConstantValueReference
+from vellum.workflows.utils.uuids import generate_workflow_deployment_prefix
 from vellum.workflows.vellum_client import create_vellum_client
 
 if TYPE_CHECKING:
     from vellum.workflows.events.workflow import WorkflowEvent
+    from vellum.workflows.state.base import BaseState
     from vellum.workflows.workflows.base import BaseWorkflow
 
 
@@ -23,11 +25,13 @@ class WorkflowContext:
         vellum_client: Optional[Vellum] = None,
         execution_context: Optional[ExecutionContext] = None,
         generated_files: Optional[dict[str, str]] = None,
+        namespace: Optional[str] = None,
     ):
         self._vellum_client = vellum_client
         self._event_queue: Optional[Queue["WorkflowEvent"]] = None
         self._node_output_mocks_map: Dict[Type[BaseOutputs], List[MockNodeExecution]] = {}
         self._execution_context = get_execution_context()
+        self._namespace = namespace
 
         if execution_context is not None:
             self._execution_context.trace_id = execution_context.trace_id
@@ -36,6 +40,8 @@ class WorkflowContext:
 
         if self._execution_context.parent_context is None:
             self._execution_context.parent_context = ExternalParentContext(span_id=uuid4())
+            # Propagate the updated context back to the global execution context
+            set_execution_context(self._execution_context)
 
         self._generated_files = generated_files
 
@@ -54,6 +60,10 @@ class WorkflowContext:
     def generated_files(self) -> Optional[dict[str, str]]:
         return self._generated_files
 
+    @cached_property
+    def namespace(self) -> Optional[str]:
+        return self._namespace
+
     @cached_property
     def node_output_mocks_map(self) -> Dict[Type[BaseOutputs], List[MockNodeExecution]]:
         return self._node_output_mocks_map
@@ -132,19 +142,40 @@ class WorkflowContext:
     def _get_all_node_output_mocks(self) -> List[MockNodeExecution]:
         return [mock for mocks in self._node_output_mocks_map.values() for mock in mocks]
 
-    def resolve_workflow_deployment(self, deployment_name: str, release_tag: str) -> Optional["BaseWorkflow"]:
+    def resolve_workflow_deployment(
+        self, deployment_name: str, release_tag: str, state: "BaseState"
+    ) -> Optional["BaseWorkflow"]:
         """
         Resolve a workflow deployment by name and release tag.
 
         Args:
             deployment_name: The name of the workflow deployment
             release_tag: The release tag to resolve
+            state: The base state to pass to the workflow
 
         Returns:
             BaseWorkflow instance if found, None otherwise
         """
-        return None
+        if not self.generated_files or not self.namespace:
+            return None
+
+        expected_prefix = generate_workflow_deployment_prefix(deployment_name, release_tag)
+
+        workflow_file_key = f"{expected_prefix}/workflow.py"
+        if workflow_file_key not in self.generated_files:
+            return None
+
+        try:
+            from vellum.workflows.workflows.base import BaseWorkflow
+
+            WorkflowClass = BaseWorkflow.load_from_module(f"{self.namespace}.{expected_prefix}")
+            workflow_instance = WorkflowClass(context=WorkflowContext.create_from(self), parent_state=state)
+            return workflow_instance
+        except Exception:
+            return None
 
     @classmethod
     def create_from(cls, context):
-        return cls(vellum_client=context.vellum_client, generated_files=context.generated_files)
+        return cls(
+            vellum_client=context.vellum_client, generated_files=context.generated_files, namespace=context.namespace
+        )

vellum/workflows/utils/uuids.py

@@ -2,6 +2,21 @@ import hashlib
 from uuid import UUID
 
 
+def generate_workflow_deployment_prefix(deployment_name: str, release_tag: str) -> str:
+    """
+    Generate a workflow deployment prefix from deployment name and release tag.
+
+    Args:
+        deployment_name: The name of the workflow deployment
+        release_tag: The release tag to resolve
+
+    Returns:
+        The generated prefix in format vellum_workflow_deployment_{hash}
+    """
+    expected_hash = str(uuid4_from_hash(f"{deployment_name}|{release_tag}")).replace("-", "_")
+    return f"vellum_workflow_deployment_{expected_hash}"
+
+
 def uuid4_from_hash(input_str: str) -> UUID:
     # Create a SHA-256 hash of the input string
     hash_bytes = hashlib.sha256(input_str.encode()).digest()

{vellum_ai-1.2.2.dist-info → vellum_ai-1.2.3.dist-info}/METADATA

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