vellum-ai 0.11.3__tar.gz → 0.11.5__tar.gz

{vellum_ai-0.11.3 → vellum_ai-0.11.5}/PKG-INFO

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

{vellum_ai-0.11.3 → vellum_ai-0.11.5}/ee/vellum_cli/config.py

@@ -20,6 +20,15 @@ class WorkflowDeploymentConfig(UniversalBaseModel):
     description: Optional[str] = None
     release_tags: Optional[List[str]] = None
 
+    def merge(self, other: "WorkflowDeploymentConfig") -> "WorkflowDeploymentConfig":
+        return WorkflowDeploymentConfig(
+            id=self.id or other.id,
+            label=self.label or other.label,
+            name=self.name or other.name,
+            description=self.description or other.description,
+            release_tags=self.release_tags or other.release_tags,
+        )
+
 
 class WorkflowConfig(UniversalBaseModel):
     module: str
@@ -28,10 +37,37 @@ class WorkflowConfig(UniversalBaseModel):
     deployments: List[WorkflowDeploymentConfig] = field(default_factory=list)
 
     def merge(self, other: "WorkflowConfig") -> "WorkflowConfig":
+        self_deployment_by_id = {
+            deployment.id: deployment for deployment in self.deployments if deployment.id is not None
+        }
+        other_deployment_by_id = {
+            deployment.id: deployment for deployment in other.deployments if deployment.id is not None
+        }
+        all_ids = sorted(set(self_deployment_by_id.keys()).union(set(other_deployment_by_id.keys())))
+        merged_deployments = []
+        for id in all_ids:
+            self_deployment = self_deployment_by_id.get(id)
+            other_deployment = other_deployment_by_id.get(id)
+            if self_deployment and other_deployment:
+                merged_deployments.append(self_deployment.merge(other_deployment))
+            elif self_deployment:
+                merged_deployments.append(self_deployment)
+            elif other_deployment:
+                merged_deployments.append(other_deployment)
+
+        for deployment in self.deployments:
+            if deployment.id is None:
+                merged_deployments.append(deployment)
+
+        for deployment in other.deployments:
+            if deployment.id is None:
+                merged_deployments.append(deployment)
+
         return WorkflowConfig(
             module=self.module,
             workflow_sandbox_id=self.workflow_sandbox_id or other.workflow_sandbox_id,
             ignore=self.ignore or other.ignore,
+            deployments=merged_deployments,
         )
 
 

{vellum_ai-0.11.3 → vellum_ai-0.11.5}/ee/vellum_cli/push.py

@@ -1,3 +1,4 @@
+from importlib import metadata
 import io
 import json
 import os
@@ -50,6 +51,9 @@ def push_command(
     workflow = BaseWorkflow.load_from_module(workflow_config.module)
     workflow_display = get_workflow_display(base_display_class=VellumWorkflowDisplay, workflow_class=workflow)
     exec_config = workflow_display.serialize()
+    exec_config["runner_config"] = {
+        "sdk_version": metadata.version("vellum-ai"),
+    }
 
     label = snake_to_title_case(workflow_config.module.split(".")[-1])
 

{vellum_ai-0.11.3 → vellum_ai-0.11.5}/ee/vellum_cli/tests/conftest.py

@@ -1,19 +1,29 @@
 import pytest
+from dataclasses import dataclass
 import os
 import shutil
 import tempfile
 from uuid import uuid4
-from typing import Any, Callable, Dict, Generator, Tuple
+from typing import Any, Callable, Dict, Generator
 
 import tomli_w
 
 
+@dataclass
+class MockModuleResult:
+    temp_dir: str
+    module: str
+    set_pyproject_toml: Callable[[Dict[str, Any]], None]
+    workflow_sandbox_id: str
+
+
 @pytest.fixture
-def mock_module() -> Generator[Tuple[str, str, Callable[[Dict[str, Any]], None]], None, None]:
+def mock_module() -> Generator[MockModuleResult, None, None]:
     current_dir = os.getcwd()
     temp_dir = tempfile.mkdtemp()
     os.chdir(temp_dir)
     module = "examples.mock"
+    workflow_sandbox_id = str(uuid4())
 
     def set_pyproject_toml(vellum_config: Dict[str, Any]) -> None:
         pyproject_toml_path = os.path.join(temp_dir, "pyproject.toml")
@@ -28,13 +38,18 @@ def mock_module() -> Generator[Tuple[str, str, Callable[[Dict[str, Any]], None]]
             "workflows": [
                 {
                     "module": module,
-                    "workflow_sandbox_id": str(uuid4()),
+                    "workflow_sandbox_id": workflow_sandbox_id,
                 }
             ]
         }
     )
 
-    yield temp_dir, module, set_pyproject_toml
+    yield MockModuleResult(
+        temp_dir=temp_dir,
+        module=module,
+        set_pyproject_toml=set_pyproject_toml,
+        workflow_sandbox_id=workflow_sandbox_id,
+    )
 
     os.chdir(current_dir)
     shutil.rmtree(temp_dir)

{vellum_ai-0.11.3 → vellum_ai-0.11.5}/ee/vellum_cli/tests/test_pull.py

@@ -37,7 +37,8 @@ def _zip_file_map(file_map: dict[str, str]) -> bytes:
 )
 def test_pull(vellum_client, mock_module, base_command):
     # GIVEN a module on the user's filesystem
-    temp_dir, module, _ = mock_module
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
 
     # AND the workflow pull API call returns a zip file
     vellum_client.workflows.pull.return_value = iter([_zip_file_map({"workflow.py": "print('hello')"})])
@@ -58,7 +59,9 @@ def test_pull(vellum_client, mock_module, base_command):
 
 def test_pull__second_module(vellum_client, mock_module):
     # GIVEN a module on the user's filesystem
-    temp_dir, module, set_pyproject_toml = mock_module
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
+    set_pyproject_toml = mock_module.set_pyproject_toml
 
     # AND the workflow pull API call returns a zip file
     vellum_client.workflows.pull.return_value = iter([_zip_file_map({"workflow.py": "print('hello')"})])
@@ -134,7 +137,7 @@ def test_pull__sandbox_id_with_no_config(vellum_client):
 
 def test_pull__sandbox_id_with_other_workflow_configured(vellum_client, mock_module):
     # GIVEN a pyproject.toml with a workflow configured
-    temp_dir, _, _ = mock_module
+    temp_dir = mock_module.temp_dir
 
     # AND a different workflow sandbox id
     workflow_sandbox_id = "87654321-0000-0000-0000-000000000000"
@@ -163,7 +166,8 @@ def test_pull__sandbox_id_with_other_workflow_configured(vellum_client, mock_mod
 
 def test_pull__remove_missing_files(vellum_client, mock_module):
     # GIVEN a module on the user's filesystem
-    temp_dir, module, _ = mock_module
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
 
     # AND the workflow pull API call returns a zip file
     vellum_client.workflows.pull.return_value = iter([_zip_file_map({"workflow.py": "print('hello')"})])
@@ -192,7 +196,9 @@ def test_pull__remove_missing_files(vellum_client, mock_module):
 
 def test_pull__remove_missing_files__ignore_pattern(vellum_client, mock_module):
     # GIVEN a module on the user's filesystem
-    temp_dir, module, set_pyproject_toml = mock_module
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
+    set_pyproject_toml = mock_module.set_pyproject_toml
 
     # AND the workflow pull API call returns a zip file
     vellum_client.workflows.pull.return_value = iter([_zip_file_map({"workflow.py": "print('hello')"})])
@@ -243,7 +249,7 @@ def test_pull__remove_missing_files__ignore_pattern(vellum_client, mock_module):
 
 def test_pull__include_json(vellum_client, mock_module):
     # GIVEN a module on the user's filesystem
-    _, module, __ = mock_module
+    module = mock_module.module
 
     # AND the workflow pull API call returns a zip file
     vellum_client.workflows.pull.return_value = iter(
@@ -265,7 +271,7 @@ def test_pull__include_json(vellum_client, mock_module):
 
 def test_pull__exclude_code(vellum_client, mock_module):
     # GIVEN a module on the user's filesystem
-    _, module, __ = mock_module
+    module = mock_module.module
 
     # AND the workflow pull API call returns a zip file
     vellum_client.workflows.pull.return_value = iter(
@@ -283,3 +289,75 @@ def test_pull__exclude_code(vellum_client, mock_module):
     vellum_client.workflows.pull.assert_called_once()
     call_args = vellum_client.workflows.pull.call_args.kwargs
     assert call_args["request_options"]["additional_query_parameters"] == {"exclude_code": True}
+
+
+def test_pull__sandbox_id_with_other_workflow_deployment_in_lock(vellum_client, mock_module):
+    # GIVEN a pyproject.toml with a workflow configured
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
+    workflow_sandbox_id = mock_module.workflow_sandbox_id
+
+    # AND there's a workflow deployment in the lock file
+    vellum_lock_json = os.path.join(temp_dir, "vellum.lock.json")
+    with open(vellum_lock_json, "w") as f:
+        json.dump(
+            {
+                "version": "1.0",
+                "workflows": [
+                    {
+                        "module": module,
+                        "workflow_sandbox_id": "0edc07cd-45b9-43e8-99bc-1f181972a857",
+                        "ignore": "tests/*",
+                        "deployments": [
+                            {
+                                "id": "7e5a7610-4c46-4bc9-b06e-0fc6a9e28959",
+                                "label": None,
+                                "name": None,
+                                "description": None,
+                                "release_tags": None,
+                            }
+                        ],
+                    }
+                ],
+            },
+            f,
+        )
+
+    # AND a different workflow sandbox id
+    new_workflow_sandbox_id = "87654321-0000-0000-0000-000000000000"
+
+    # AND the workflow pull API call returns a zip file
+    vellum_client.workflows.pull.return_value = iter([_zip_file_map({"workflow.py": "print('hello')"})])
+
+    # WHEN the user runs the pull command with the new workflow sandbox id
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["workflows", "pull", "--workflow-sandbox-id", new_workflow_sandbox_id])
+
+    # THEN the command returns successfully
+    assert result.exit_code == 0
+
+    # AND the lock file is updated to preserve the deployment and include the new workflow
+    with open(vellum_lock_json) as f:
+        lock_data = json.load(f)
+        assert lock_data["workflows"] == [
+            {
+                "module": module,
+                "workflow_sandbox_id": workflow_sandbox_id,
+                "ignore": "tests/*",
+                "deployments": [
+                    {
+                        "id": "7e5a7610-4c46-4bc9-b06e-0fc6a9e28959",
+                        "label": None,
+                        "name": None,
+                        "description": None,
+                        "release_tags": None,
+                    },
+                ],
+            },
+            {
+                "module": "workflow_87654321",
+                "workflow_sandbox_id": new_workflow_sandbox_id,
+                "ignore": None,
+                "deployments": [],
+            },
+        ]

{vellum_ai-0.11.3 → vellum_ai-0.11.5}/ee/vellum_cli/tests/test_push.py

@@ -29,8 +29,7 @@ def _extract_tar_gz(tar_gz_bytes: bytes) -> dict[str, str]:
 
 def test_push__no_config(mock_module):
     # GIVEN no config file set
-    _, _, set_pyproject_toml = mock_module
-    set_pyproject_toml({"workflows": []})
+    mock_module.set_pyproject_toml({"workflows": []})
 
     # WHEN calling `vellum push`
     runner = CliRunner()
@@ -44,8 +43,7 @@ def test_push__no_config(mock_module):
 
 def test_push__multiple_workflows_configured__no_module_specified(mock_module):
     # GIVEN multiple workflows configured
-    _, _, set_pyproject_toml = mock_module
-    set_pyproject_toml({"workflows": [{"module": "examples.mock"}, {"module": "examples.mock2"}]})
+    mock_module.set_pyproject_toml({"workflows": [{"module": "examples.mock"}, {"module": "examples.mock2"}]})
 
     # WHEN calling `vellum push` without a module specified
     runner = CliRunner()
@@ -62,8 +60,8 @@ def test_push__multiple_workflows_configured__no_module_specified(mock_module):
 
 def test_push__multiple_workflows_configured__not_found_module(mock_module):
     # GIVEN multiple workflows configured
-    _, module, set_pyproject_toml = mock_module
-    set_pyproject_toml({"workflows": [{"module": "examples.mock2"}, {"module": "examples.mock3"}]})
+    module = mock_module.module
+    mock_module.set_pyproject_toml({"workflows": [{"module": "examples.mock2"}, {"module": "examples.mock3"}]})
 
     # WHEN calling `vellum push` with a module that doesn't exist
     runner = CliRunner()
@@ -85,7 +83,8 @@ def test_push__multiple_workflows_configured__not_found_module(mock_module):
 )
 def test_push__happy_path(mock_module, vellum_client, base_command):
     # GIVEN a single workflow configured
-    temp_dir, module, _ = mock_module
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
 
     # AND a workflow exists in the module successfully
     base_dir = os.path.join(temp_dir, *module.split("."))
@@ -134,7 +133,8 @@ class ExampleWorkflow(BaseWorkflow):
 )
 def test_push__deployment(mock_module, vellum_client, base_command):
     # GIVEN a single workflow configured
-    temp_dir, module, _ = mock_module
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
 
     # AND a workflow exists in the module successfully
     base_dir = os.path.join(temp_dir, *module.split("."))

{vellum_ai-0.11.3 → vellum_ai-0.11.5}/ee/vellum_ee/workflows/display/nodes/vellum/error_node.py

@@ -39,7 +39,6 @@ class BaseErrorNodeDisplay(BaseNodeVellumDisplay[_ErrorNodeType], Generic[_Error
             "data": {
                 "name": self.name,
                 "label": self.label,
-                "source_handle_id": str(self.get_source_handle_id(display_context.port_displays)),
                 "target_handle_id": str(self.get_target_handle_id()),
                 "error_source_input_id": str(error_source_input_id),
                 "error_output_id": str(self.error_output_id),

{vellum_ai-0.11.3 → vellum_ai-0.11.5}/ee/vellum_ee/workflows/display/nodes/vellum/search_node.py

@@ -15,7 +15,7 @@ from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
 from vellum_ee.workflows.display.utils.uuids import uuid4_from_hash
-from vellum_ee.workflows.display.vellum import NodeInput
+from vellum_ee.workflows.display.vellum import InputVariablePointer, NodeInput
 
 _SearchNodeType = TypeVar("_SearchNodeType", bound=SearchNode)
 
@@ -28,7 +28,7 @@ class VariableIdMap:
 
 
 class BaseSearchNodeDisplay(BaseNodeVellumDisplay[_SearchNodeType], Generic[_SearchNodeType]):
-    variable_ids: Optional[VariableIdMap] = None
+    input_variable_ids_by_logical_id: Optional[Dict[str, str]] = None
 
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
@@ -128,7 +128,6 @@ class BaseSearchNodeDisplay(BaseNodeVellumDisplay[_SearchNodeType], Generic[_Sea
         logical_expression: Union[VellumValueLogicalConditionGroupRequest, VellumValueLogicalConditionRequest],
         display_context: WorkflowDisplayContext,
         path: List[int] = [],
-        variable_id_map: Optional[VariableIdMap] = None,
     ) -> Tuple[JsonObject, List[NodeInput]]:
         if isinstance(logical_expression, VellumValueLogicalConditionGroupRequest):
             conditions: JsonArray = []
@@ -150,38 +149,42 @@ class BaseSearchNodeDisplay(BaseNodeVellumDisplay[_SearchNodeType], Generic[_Sea
                 variables,
             )
         elif isinstance(logical_expression, VellumValueLogicalConditionRequest):
-            lhs_variable_id = (
-                variable_id_map.lhs.id
-                if variable_id_map and variable_id_map.lhs and variable_id_map.lhs.id
-                else uuid4_from_hash(f"{self.node_id}|{hash(tuple(path))}|lhs")
+            lhs_variable_id = str(logical_expression.lhs_variable.value)
+            rhs_variable_id = str(logical_expression.rhs_variable.value)
+            lhs_query_input_id = (
+                self.input_variable_ids_by_logical_id[lhs_variable_id]
+                if self.input_variable_ids_by_logical_id
+                else uuid4_from_hash(f"{self.node_id}|{hash(path)}")
             )
-            rhs_variable_id = (
-                variable_id_map.rhs.id
-                if variable_id_map and variable_id_map.rhs and variable_id_map.rhs.id
-                else uuid4_from_hash(f"{self.node_id}|{hash(tuple(path))}|rhs")
+            rhs_query_input_id = (
+                self.input_variable_ids_by_logical_id[rhs_variable_id]
+                if self.input_variable_ids_by_logical_id
+                else uuid4_from_hash(f"{self.node_id}|{hash(path)}")
             )
 
             return (
                 {
                     "type": "LOGICAL_CONDITION",
-                    "lhs": str(lhs_variable_id),
+                    "lhs_variable_id": str(lhs_variable_id),
                     "operator": logical_expression.operator,
-                    "rhs": str(rhs_variable_id),
+                    "rhs_variable_id": str(rhs_variable_id),
                 },
                 [
                     create_node_input(
                         self.node_id,
                         f"vellum-query-builder-variable-{lhs_variable_id}",
-                        logical_expression.lhs_variable.value,
+                        lhs_query_input_id,
                         display_context,
-                        input_id=lhs_variable_id,
+                        input_id=UUID(lhs_variable_id),
+                        pointer_type=InputVariablePointer,
                     ),
                     create_node_input(
                         self.node_id,
                         f"vellum-query-builder-variable-{rhs_variable_id}",
-                        logical_expression.rhs_variable.value,
+                        rhs_query_input_id,
                         display_context,
-                        input_id=rhs_variable_id,
+                        input_id=UUID(rhs_variable_id),
+                        pointer_type=InputVariablePointer,
                     ),
                 ],
             )

{vellum_ai-0.11.3 → vellum_ai-0.11.5}/ee/vellum_ee/workflows/display/nodes/vellum/utils.py

@@ -10,6 +10,10 @@ from vellum_ee.workflows.display.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.utils.vellum import create_node_input_value_pointer_rule, primitive_to_vellum_value
 from vellum_ee.workflows.display.vellum import (
     ConstantValuePointer,
+    ExecutionCounterData,
+    ExecutionCounterPointer,
+    InputVariableData,
+    InputVariablePointer,
     NodeInput,
     NodeInputValuePointer,
     NodeInputValuePointerRule,
@@ -93,4 +97,15 @@ def create_pointer(
             )
 
     vellum_variable_value = primitive_to_vellum_value(value)
-    return ConstantValuePointer(type="CONSTANT_VALUE", data=vellum_variable_value)
+    if pointer_type is InputVariablePointer:
+        return InputVariablePointer(type="INPUT_VARIABLE", data=InputVariableData(input_variable_id=value))
+    elif pointer_type is WorkspaceSecretPointer:
+        return WorkspaceSecretPointer(
+            type="WORKSPACE_SECRET", data=WorkspaceSecretData(type="STRING", workspace_secret_id=value)
+        )
+    elif pointer_type is ExecutionCounterPointer:
+        return ExecutionCounterPointer(type="EXECUTION_COUNTER", data=ExecutionCounterData(node_id=value))
+    elif pointer_type is ConstantValuePointer or pointer_type is None:
+        return ConstantValuePointer(type="CONSTANT_VALUE", data=vellum_variable_value)
+    else:
+        raise ValueError(f"Pointer type {pointer_type} not supported")

{vellum_ai-0.11.3 → vellum_ai-0.11.5}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_error_node_serialization.py

@@ -102,7 +102,6 @@ def test_serialize_workflow():
             "data": {
                 "name": "error-node",
                 "label": "Fail Node",
-                "source_handle_id": "ca17d318-a0f5-4f7c-be6c-59c9dc1dd7ed",
                 "target_handle_id": "70c19f1c-309c-4a5d-ba65-664c0bb2fedf",
                 "error_source_input_id": "None",
                 "error_output_id": "None",

{vellum_ai-0.11.3 → vellum_ai-0.11.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vellum-ai"
-version = "0.11.3"
+version = "0.11.5"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-0.11.3 → vellum_ai-0.11.5}/src/vellum/client/core/client_wrapper.py

@@ -17,7 +17,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.11.2",
+            "X-Fern-SDK-Version": "0.11.5",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

{vellum_ai-0.11.3 → vellum_ai-0.11.5}/src/vellum/workflows/events/types.py

@@ -87,6 +87,13 @@ class WorkflowParentContext(BaseParentContext):
     workflow_definition: VellumCodeResourceDefinition
 
 
+class WorkflowSandboxParentContext(BaseParentContext):
+    type: Literal["WORKFLOW_SANDBOX"] = "WORKFLOW_SANDBOX"
+    sandbox_id: UUID
+    sandbox_history_item_id: UUID
+    scenario_id: UUID
+
+
 # Define the discriminated union
 ParentContext = Annotated[
     Union[
@@ -94,6 +101,7 @@ ParentContext = Annotated[
         NodeParentContext,
         WorkflowDeploymentParentContext,
         PromptDeploymentParentContext,
+        WorkflowSandboxParentContext,
     ],
     Field(discriminator="type"),
 ]

{vellum_ai-0.11.3 → vellum_ai-0.11.5}/src/vellum/workflows/graph/graph.py

@@ -12,11 +12,13 @@ if TYPE_CHECKING:
 GraphTargetOfSets = Union[
     Set[NodeType],
     Set["Graph"],
-    Set[Union[Type["BaseNode"], "Graph"]],
+    Set["Port"],
+    Set[Union[Type["BaseNode"], "Graph", "Port"]],
 ]
 
 GraphTarget = Union[
     Type["BaseNode"],
+    "Port",
     "Graph",
     GraphTargetOfSets,
 ]
@@ -53,9 +55,13 @@ class Graph:
                 entrypoints.update(target._entrypoints)
                 edges.update(target._edges)
                 terminals.update(target._terminals)
-            else:
+            elif hasattr(target, "Ports"):
                 entrypoints.update({port for port in target.Ports})
                 terminals.update({port for port in target.Ports})
+            else:
+                # target is a Port
+                entrypoints.update({target})
+                terminals.update({target})
 
         return Graph(entrypoints=entrypoints, edges=list(edges), terminals=terminals)
 
@@ -77,11 +83,16 @@ class Graph:
                         self._extend_edges(elem.edges)
                         for other_terminal in elem._terminals:
                             new_terminals.add(other_terminal)
-                    else:
+                    elif hasattr(elem, "Ports"):
                         midgraph = final_output_node >> elem
                         self._extend_edges(midgraph.edges)
                         for other_terminal in elem.Ports:
                             new_terminals.add(other_terminal)
+                    else:
+                        # elem is a Port
+                        midgraph = final_output_node >> elem
+                        self._extend_edges(midgraph.edges)
+                        new_terminals.add(elem)
             self._terminals = new_terminals
             return self
 
@@ -93,10 +104,18 @@ class Graph:
             self._terminals = other._terminals
             return self
 
+        if hasattr(other, "Ports"):
+            for final_output_node in self._terminals:
+                subgraph = final_output_node >> other
+                self._extend_edges(subgraph.edges)
+            self._terminals = {port for port in other.Ports}
+            return self
+
+        # other is a Port
         for final_output_node in self._terminals:
             subgraph = final_output_node >> other
             self._extend_edges(subgraph.edges)
-        self._terminals = {port for port in other.Ports}
+        self._terminals = {other}
         return self
 
     @property

{vellum_ai-0.11.3 → vellum_ai-0.11.5}/src/vellum/workflows/graph/tests/test_graph.py

@@ -435,3 +435,28 @@ def test_graph__set_to_node():
 
     # AND two edges
     assert len(list(graph.edges)) == 2
+
+
+def test_graph__node_to_port():
+    # GIVEN two nodes, one with a port
+    class SourceNode(BaseNode):
+        pass
+
+    class MiddleNode(BaseNode):
+        class Ports(BaseNode.Ports):
+            custom = Port.on_else()
+
+    class TargetNode(BaseNode):
+        pass
+
+    # WHEN we create a graph from the source node to the target node
+    graph = SourceNode >> MiddleNode.Ports.custom >> TargetNode
+
+    # THEN the graph has the source node as the entrypoint
+    assert set(graph.entrypoints) == {SourceNode}
+
+    # AND three nodes
+    assert len(list(graph.nodes)) == 3
+
+    # AND two edges
+    assert len(list(graph.edges)) == 2

{vellum_ai-0.11.3 → vellum_ai-0.11.5}/src/vellum/workflows/nodes/bases/base.py

@@ -57,7 +57,7 @@ class BaseNodeMeta(type):
             dct["Ports"] = type(
                 f"{name}.Ports",
                 (NodePorts,),
-                dict(dct["Ports"].__dict__),
+                {**dct["Ports"].__dict__, "__module__": dct["__module__"]},
             )
         else:
             for base in reversed(bases):

{vellum_ai-0.11.3 → vellum_ai-0.11.5}/src/vellum/workflows/nodes/core/try_node/node.py

@@ -160,6 +160,7 @@ Message: {event.error.message}""",
                     "__module__": dynamic_module,
                     "on_error_code": _on_error_code,
                     "subworkflow": Subworkflow,
+                    "Ports": type("Ports", (TryNode.Ports,), {port.name: port.copy() for port in inner_cls.Ports}),
                 },
             )
             return WrappedNode

{vellum_ai-0.11.3 → vellum_ai-0.11.5}/src/vellum/workflows/ports/port.py

@@ -40,6 +40,14 @@ class Port:
     def __repr__(self) -> str:
         return f"{self.node_class}.Ports.{self.name}"
 
+    def copy(self) -> "Port":
+        return Port(
+            default=self.default,
+            fork_state=self._fork_state,
+            condition=self._condition,
+            condition_type=self._condition_type,
+        )
+
     @property
     def fork_state(self) -> bool:
         return self._fork_state
@@ -52,6 +60,9 @@ class Port:
         if isinstance(other, set) or isinstance(other, Graph):
             return Graph.from_port(self) >> other
 
+        if isinstance(other, Port):
+            return Graph.from_port(self) >> Graph.from_port(other)
+
         edge = Edge(from_port=self, to_node=other)
         if edge not in self._edges:
             self._edges.append(edge)