vellum-ai 0.14.44__tar.gz → 0.14.46__tar.gz

{vellum_ai-0.14.44 → vellum_ai-0.14.46}/PKG-INFO

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

{vellum_ai-0.14.44 → vellum_ai-0.14.46}/ee/vellum_cli/config.py

@@ -16,10 +16,15 @@ PYPROJECT_TOML_PATH = "pyproject.toml"
 
 class WorkspaceConfig(UniversalBaseModel):
     name: str
-    api_key: str
+    api_key: str = "VELLUM_API_KEY"
+    api_url: Optional[str] = None
 
     def merge(self, other: "WorkspaceConfig") -> "WorkspaceConfig":
-        return WorkspaceConfig(name=self.name or other.name, api_key=self.api_key or other.api_key)
+        return WorkspaceConfig(
+            name=self.name or other.name,
+            api_key=self.api_key or other.api_key,
+            api_url=self.api_url or other.api_url,
+        )
 
 
 DEFAULT_WORKSPACE_CONFIG = WorkspaceConfig(name="default", api_key="VELLUM_API_KEY")

{vellum_ai-0.14.44 → vellum_ai-0.14.46}/ee/vellum_cli/push.py

@@ -97,6 +97,7 @@ def push_command(
 
     client = create_vellum_client(
         api_key=api_key,
+        api_url=workspace_config.api_url,
     )
     sys.path.insert(0, os.getcwd())
 
@@ -105,6 +106,7 @@ def push_command(
     workflow = BaseWorkflow.load_from_module(workflow_config.module)
     workflow_display = get_workflow_display(
         workflow_class=workflow,
+        client=client,
         dry_run=dry_run or False,
     )
     exec_config = workflow_display.serialize()
@@ -234,9 +236,11 @@ def push_command(
 """
         )  # type: ignore[attr-defined]
     else:
+        default_api_url = client._client_wrapper._environment.default
+        base_url = default_api_url.split("/v1")[0].replace("//api.", "//app.")
         logger.info(
             f"""Successfully pushed {workflow_config.module} to Vellum!
-Visit at: https://app.vellum.ai/workflow-sandboxes/{response.workflow_sandbox_id}"""
+Visit at: {base_url}/workflow-sandboxes/{response.workflow_sandbox_id}"""
         )
 
     if not workflow_config.workflow_sandbox_id:

{vellum_ai-0.14.44 → vellum_ai-0.14.46}/ee/vellum_cli/tests/test_push.py

@@ -7,6 +7,7 @@ from unittest import mock
 from uuid import uuid4
 
 from click.testing import CliRunner
+from httpx import Response
 
 from vellum.client.core.api_error import ApiError
 from vellum.client.types.workflow_push_response import WorkflowPushResponse
@@ -29,19 +30,25 @@ def _extract_tar_gz(tar_gz_bytes: bytes) -> dict[str, str]:
     return files
 
 
-def _ensure_workflow_py(temp_dir: str, module: str) -> str:
-    base_dir = os.path.join(temp_dir, *module.split("."))
+def _ensure_file(temp_dir: str, module: str, file_name: str, content: str) -> str:
+    file_path = os.path.join(temp_dir, *module.split("."), file_name)
+    base_dir = os.path.dirname(file_path)
     os.makedirs(base_dir, exist_ok=True)
+
+    with open(file_path, "w") as f:
+        f.write(content)
+
+    return content
+
+
+def _ensure_workflow_py(temp_dir: str, module: str) -> str:
     workflow_py_file_content = """\
 from vellum.workflows import BaseWorkflow
 
 class ExampleWorkflow(BaseWorkflow):
     pass
 """
-    with open(os.path.join(temp_dir, *module.split("."), "workflow.py"), "w") as f:
-        f.write(workflow_py_file_content)
-
-    return workflow_py_file_content
+    return _ensure_file(temp_dir, module, "workflow.py", workflow_py_file_content)
 
 
 def test_push__no_config(mock_module):
@@ -133,6 +140,38 @@ def test_push__happy_path(mock_module, vellum_client, base_command):
     assert extracted_files["workflow.py"] == workflow_py_file_content
 
 
+def test_push__verify_default_url_in_raw_httpx_transport(mock_module, mock_httpx_transport):
+    # GIVEN a single workflow configured
+    module = mock_module.module
+    temp_dir = mock_module.temp_dir
+    _ensure_workflow_py(temp_dir, module)
+
+    # AND the push API call returns successfully
+    mock_httpx_transport.handle_request.return_value = Response(
+        status_code=200,
+        text=json.dumps(
+            {
+                "workflow_sandbox_id": str(uuid4()),
+            }
+        ),
+    )
+
+    # WHEN calling `vellum push`
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["workflows", "push", module])
+
+    # THEN it should succeed
+    assert result.exit_code == 0
+
+    # AND we should have called the push API with the correct args
+    mock_httpx_transport.handle_request.assert_called_once()
+    request = mock_httpx_transport.handle_request.call_args[0][0]
+    assert str(request.url) == "https://api.vellum.ai/v1/workflows/push"
+
+    # AND the new URL is in the message at the end
+    assert "Visit at: https://app.vellum.ai/workflow-sandboxes/" in result.output
+
+
 def test_push__no_config__module_found(mock_module, vellum_client):
     # GIVEN no config file set
     temp_dir = mock_module.temp_dir
@@ -486,7 +525,74 @@ Files that were different between the original project and the generated artifac
     )
 
 
-def test_push__workspace_option__uses_different_api_key(mock_module, vellum_client_class):
+@pytest.mark.parametrize(
+    "file_data",
+    [
+        {
+            "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+
+class ExampleWorkflow(BaseWorkflow):
+    pass
+"""
+        },
+        {
+            "nodes/start_node.py": """\
+from vellum.workflows.nodes import CodeExecutionNode
+from vellum.workflows.references import VellumSecretReference
+
+class StartNode(CodeExecutionNode):
+    code_inputs = {
+        "foo": VellumSecretReference("MY_SECRET_KEY"),
+    }
+""",
+            "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+from .nodes.start_node import StartNode
+
+class ExampleWorkflow(BaseWorkflow):
+    graph = StartNode
+""",
+        },
+        {
+            "nodes/start_node.py": """\
+from vellum.workflows.nodes import PromptDeploymentNode
+
+class StartNode(PromptDeploymentNode):
+    deployment = "my-deployment"
+""",
+            "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+from .nodes.start_node import StartNode
+
+class ExampleWorkflow(BaseWorkflow):
+    graph = StartNode
+""",
+        },
+        {
+            "nodes/start_node.py": """\
+from vellum.workflows.nodes import SubworkflowDeploymentNode
+
+class StartNode(SubworkflowDeploymentNode):
+    deployment = "my-deployment"
+""",
+            "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+from .nodes.start_node import StartNode
+
+class ExampleWorkflow(BaseWorkflow):
+    graph = StartNode
+""",
+        },
+    ],
+    ids=[
+        "base_case",
+        "with_secret_reference",
+        "with_prompt_deployment",
+        "with_subworkflow_deployment",
+    ],
+)
+def test_push__workspace_option__uses_different_api_key(mock_module, vellum_client_class, file_data):
     # GIVEN a single workflow configured
     temp_dir = mock_module.temp_dir
     module = mock_module.module
@@ -521,7 +627,8 @@ MY_OTHER_VELLUM_API_KEY=aaabbbcccddd
         )
 
     # AND a workflow exists in the module successfully
-    _ensure_workflow_py(temp_dir, module)
+    for file_name, content in file_data.items():
+        _ensure_file(temp_dir, module, file_name, content)
 
     # AND the push API call returns a new workflow sandbox id
     new_workflow_sandbox_id = str(uuid4())
@@ -564,6 +671,83 @@ MY_OTHER_VELLUM_API_KEY=aaabbbcccddd
         }
 
 
+def test_push__workspace_option__uses_different_api_url_env(mock_module, mock_httpx_transport):
+    # GIVEN a single workflow configured
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
+    workflow_sandbox_id = mock_module.workflow_sandbox_id
+    set_pyproject_toml = mock_module.set_pyproject_toml
+
+    # AND a different workspace is set in the pyproject.toml
+    set_pyproject_toml(
+        {
+            "workflows": [
+                {
+                    "module": module,
+                    "workflow_sandbox_id": workflow_sandbox_id,
+                }
+            ],
+            "workspaces": [
+                {
+                    "name": "my_other_workspace",
+                    "api_url": "MY_OTHER_VELLUM_API_URL",
+                }
+            ],
+        }
+    )
+
+    # AND the .env file has the other api key stored
+    with open(os.path.join(temp_dir, ".env"), "w") as f:
+        f.write(
+            """\
+VELLUM_API_KEY=abcdef123456
+MY_OTHER_VELLUM_API_URL=https://app.aws-vpc-staging.vellum.ai
+"""
+        )
+
+    # AND a workflow exists in the module successfully
+    _ensure_workflow_py(temp_dir, module)
+
+    # AND the push API call returns a new workflow sandbox id
+    new_workflow_sandbox_id = str(uuid4())
+    mock_httpx_transport.handle_request.return_value = Response(
+        status_code=200,
+        text=json.dumps(
+            {
+                "workflow_sandbox_id": new_workflow_sandbox_id,
+            }
+        ),
+    )
+
+    # WHEN calling `vellum push` on strict mode
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["push", module, "--workspace", "my_other_workspace"])
+
+    # THEN it should succeed
+    assert result.exit_code == 0, result.output
+
+    # AND we should have called the push API once with the correct api url
+    request = mock_httpx_transport.handle_request.call_args[0][0]
+    assert str(request.url) == "https://app.aws-vpc-staging.vellum.ai/v1/workflows/push"
+
+    # AND the vellum lock file should have been updated with the correct workspace
+    with open(os.path.join(temp_dir, "vellum.lock.json")) as f:
+        lock_file_content = json.load(f)
+        assert lock_file_content["workflows"][1] == {
+            "module": module,
+            "workflow_sandbox_id": new_workflow_sandbox_id,
+            "workspace": "my_other_workspace",
+            "container_image_name": None,
+            "container_image_tag": None,
+            "deployments": [],
+            "ignore": None,
+            "target_directory": None,
+        }
+
+    # AND the new URL is in the message at the end
+    assert "Visit at: https://app.aws-vpc-staging.vellum.ai/workflow-sandboxes/" in result.output
+
+
 def test_push__workspace_option__both_options_already_configured(mock_module, vellum_client_class):
     # GIVEN a single workflow configured
     temp_dir = mock_module.temp_dir

{vellum_ai-0.14.44 → vellum_ai-0.14.46}/ee/vellum_ee/workflows/display/nodes/base_node_display.py

@@ -20,45 +20,10 @@ from typing import (
 from vellum.client.types.code_resource_definition import CodeResourceDefinition
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.constants import undefined
-from vellum.workflows.descriptors.base import BaseDescriptor
-from vellum.workflows.expressions.accessor import AccessorExpression
-from vellum.workflows.expressions.and_ import AndExpression
-from vellum.workflows.expressions.begins_with import BeginsWithExpression
-from vellum.workflows.expressions.between import BetweenExpression
-from vellum.workflows.expressions.coalesce_expression import CoalesceExpression
-from vellum.workflows.expressions.contains import ContainsExpression
-from vellum.workflows.expressions.does_not_begin_with import DoesNotBeginWithExpression
-from vellum.workflows.expressions.does_not_contain import DoesNotContainExpression
-from vellum.workflows.expressions.does_not_end_with import DoesNotEndWithExpression
-from vellum.workflows.expressions.does_not_equal import DoesNotEqualExpression
-from vellum.workflows.expressions.ends_with import EndsWithExpression
-from vellum.workflows.expressions.equals import EqualsExpression
-from vellum.workflows.expressions.greater_than import GreaterThanExpression
-from vellum.workflows.expressions.greater_than_or_equal_to import GreaterThanOrEqualToExpression
-from vellum.workflows.expressions.in_ import InExpression
-from vellum.workflows.expressions.is_nil import IsNilExpression
-from vellum.workflows.expressions.is_not_nil import IsNotNilExpression
-from vellum.workflows.expressions.is_not_null import IsNotNullExpression
-from vellum.workflows.expressions.is_not_undefined import IsNotUndefinedExpression
-from vellum.workflows.expressions.is_null import IsNullExpression
-from vellum.workflows.expressions.is_undefined import IsUndefinedExpression
-from vellum.workflows.expressions.less_than import LessThanExpression
-from vellum.workflows.expressions.less_than_or_equal_to import LessThanOrEqualToExpression
-from vellum.workflows.expressions.not_between import NotBetweenExpression
-from vellum.workflows.expressions.not_in import NotInExpression
-from vellum.workflows.expressions.or_ import OrExpression
-from vellum.workflows.expressions.parse_json import ParseJsonExpression
 from vellum.workflows.nodes.bases.base import BaseNode
-from vellum.workflows.nodes.displayable.bases.utils import primitive_to_vellum_value
 from vellum.workflows.nodes.utils import get_unadorned_node, get_wrapped_node
 from vellum.workflows.ports import Port
 from vellum.workflows.references import OutputReference
-from vellum.workflows.references.constant import ConstantValueReference
-from vellum.workflows.references.execution_count import ExecutionCountReference
-from vellum.workflows.references.lazy import LazyReference
-from vellum.workflows.references.state_value import StateValueReference
-from vellum.workflows.references.vellum_secret import VellumSecretReference
-from vellum.workflows.references.workflow_input import WorkflowInputReference
 from vellum.workflows.types.core import JsonArray, JsonObject
 from vellum.workflows.types.generics import NodeType
 from vellum.workflows.types.utils import get_original_base
@@ -68,10 +33,8 @@ from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_var
 from vellum_ee.workflows.display.editor.types import NodeDisplayComment, NodeDisplayData
 from vellum_ee.workflows.display.nodes.get_node_display_class import get_node_display_class
 from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay, PortDisplay, PortDisplayOverrides
-from vellum_ee.workflows.display.utils.exceptions import UnsupportedSerializationException
-from vellum_ee.workflows.display.utils.expressions import get_child_descriptor
+from vellum_ee.workflows.display.utils.expressions import serialize_condition, serialize_value
 from vellum_ee.workflows.display.utils.registry import register_node_display_class
-from vellum_ee.workflows.display.utils.vellum import convert_descriptor_to_operator
 
 if TYPE_CHECKING:
     from vellum_ee.workflows.display.types import WorkflowDisplayContext
@@ -157,7 +120,7 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
                     {
                         "id": id,
                         "name": attribute.name,
-                        "value": self.serialize_value(display_context, attribute.instance),
+                        "value": serialize_value(display_context, attribute.instance),
                     }
                 )
             except ValueError as e:
@@ -184,7 +147,7 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
         for output in node.Outputs:
             type = primitive_type_to_vellum_variable_type(output)
             value = (
-                self.serialize_value(display_context, output.instance)
+                serialize_value(display_context, output.instance)
                 if output.instance is not None and output.instance != undefined
                 else None
             )
@@ -229,7 +192,7 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
                         "name": port.name,
                         "type": port._condition_type.value,
                         "expression": (
-                            self.serialize_condition(display_context, port._condition) if port._condition else None
+                            serialize_condition(display_context, port._condition) if port._condition else None
                         ),
                     }
                 )
@@ -405,137 +368,5 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
 
         return NodeDisplayData()
 
-    def serialize_condition(self, display_context: "WorkflowDisplayContext", condition: BaseDescriptor) -> JsonObject:
-        if isinstance(
-            condition,
-            (
-                IsNullExpression,
-                IsNotNullExpression,
-                IsNilExpression,
-                IsNotNilExpression,
-                IsUndefinedExpression,
-                IsNotUndefinedExpression,
-                ParseJsonExpression,
-            ),
-        ):
-            lhs = self.serialize_value(display_context, condition._expression)
-            return {
-                "type": "UNARY_EXPRESSION",
-                "lhs": lhs,
-                "operator": convert_descriptor_to_operator(condition),
-            }
-        elif isinstance(condition, (BetweenExpression, NotBetweenExpression)):
-            base = self.serialize_value(display_context, condition._value)
-            lhs = self.serialize_value(display_context, condition._start)
-            rhs = self.serialize_value(display_context, condition._end)
-
-            return {
-                "type": "TERNARY_EXPRESSION",
-                "base": base,
-                "operator": convert_descriptor_to_operator(condition),
-                "lhs": lhs,
-                "rhs": rhs,
-            }
-        elif isinstance(
-            condition,
-            (
-                AndExpression,
-                BeginsWithExpression,
-                CoalesceExpression,
-                ContainsExpression,
-                DoesNotBeginWithExpression,
-                DoesNotContainExpression,
-                DoesNotEndWithExpression,
-                DoesNotEqualExpression,
-                EndsWithExpression,
-                EqualsExpression,
-                GreaterThanExpression,
-                GreaterThanOrEqualToExpression,
-                InExpression,
-                LessThanExpression,
-                LessThanOrEqualToExpression,
-                NotInExpression,
-                OrExpression,
-            ),
-        ):
-            lhs = self.serialize_value(display_context, condition._lhs)
-            rhs = self.serialize_value(display_context, condition._rhs)
-
-            return {
-                "type": "BINARY_EXPRESSION",
-                "lhs": lhs,
-                "operator": convert_descriptor_to_operator(condition),
-                "rhs": rhs,
-            }
-        elif isinstance(condition, AccessorExpression):
-            return {
-                "type": "BINARY_EXPRESSION",
-                "lhs": self.serialize_value(display_context, condition._base),
-                "operator": "accessField",
-                "rhs": self.serialize_value(display_context, condition._field),
-            }
-
-        raise UnsupportedSerializationException(f"Unsupported condition type: {condition.__class__.__name__}")
-
-    def serialize_value(self, display_context: "WorkflowDisplayContext", value: Any) -> JsonObject:
-        if isinstance(value, ConstantValueReference):
-            return self.serialize_value(display_context, value._value)
-
-        if isinstance(value, LazyReference):
-            child_descriptor = get_child_descriptor(value, display_context)
-            return self.serialize_value(display_context, child_descriptor)
-
-        if isinstance(value, WorkflowInputReference):
-            workflow_input_display = display_context.global_workflow_input_displays[value]
-            return {
-                "type": "WORKFLOW_INPUT",
-                "input_variable_id": str(workflow_input_display.id),
-            }
-
-        if isinstance(value, StateValueReference):
-            state_value_display = display_context.global_state_value_displays[value]
-            return {
-                "type": "STATE_VALUE",
-                "state_variable_id": str(state_value_display.id),
-            }
-
-        if isinstance(value, OutputReference):
-            upstream_node, output_display = display_context.global_node_output_displays[value]
-            upstream_node_display = display_context.global_node_displays[upstream_node]
-
-            return {
-                "type": "NODE_OUTPUT",
-                "node_id": str(upstream_node_display.node_id),
-                "node_output_id": str(output_display.id),
-            }
-
-        if isinstance(value, VellumSecretReference):
-            return {
-                "type": "VELLUM_SECRET",
-                "vellum_secret_name": value.name,
-            }
-
-        if isinstance(value, ExecutionCountReference):
-            node_class_display = display_context.global_node_displays[value.node_class]
-
-            return {
-                "type": "EXECUTION_COUNTER",
-                "node_id": str(node_class_display.node_id),
-            }
-
-        if isinstance(value, dict) and any(isinstance(v, BaseDescriptor) for v in value.values()):
-            raise ValueError("Nested references are not supported.")
-
-        if not isinstance(value, BaseDescriptor):
-            vellum_value = primitive_to_vellum_value(value)
-            return {
-                "type": "CONSTANT_VALUE",
-                "value": vellum_value.dict(),
-            }
-
-        # If it's not any of the references we know about,
-        # then try to serialize it as a nested value
-        return self.serialize_condition(display_context, value)
-
 
 register_node_display_class(node_class=BaseNode, node_display_class=BaseNodeDisplay)

{vellum_ai-0.14.44 → vellum_ai-0.14.46}/ee/vellum_ee/workflows/display/nodes/vellum/conditional_node.py

@@ -19,7 +19,7 @@ from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 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.vellum import convert_descriptor_to_operator
+from vellum_ee.workflows.display.utils.expressions import convert_descriptor_to_operator
 from vellum_ee.workflows.display.vellum import NodeInput
 
 _ConditionalNodeType = TypeVar("_ConditionalNodeType", bound=ConditionalNode)

{vellum_ai-0.14.44 → vellum_ai-0.14.46}/ee/vellum_ee/workflows/display/nodes/vellum/final_output_node.py

@@ -8,6 +8,7 @@ from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import to_kebab_case
 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.expressions import serialize_value
 from vellum_ee.workflows.display.utils.vellum import infer_vellum_variable_type
 
 _FinalOutputNodeType = TypeVar("_FinalOutputNodeType", bound=FinalOutputNode)
@@ -52,7 +53,7 @@ class BaseFinalOutputNodeDisplay(BaseNodeDisplay[_FinalOutputNodeType], Generic[
                     "id": str(self._get_output_id()),
                     "name": node.Outputs.value.name,
                     "type": inferred_type,
-                    "value": self.serialize_value(display_context, node.Outputs.value.instance),
+                    "value": serialize_value(display_context, node.Outputs.value.instance),
                 }
             ],
         }

{vellum_ai-0.14.44 → vellum_ai-0.14.46}/ee/vellum_ee/workflows/display/nodes/vellum/prompt_deployment_node.py

@@ -4,7 +4,6 @@ from typing import Generic, Optional, TypeVar, cast
 from vellum.workflows.nodes.displayable.prompt_deployment_node import PromptDeploymentNode
 from vellum.workflows.references import OutputReference
 from vellum.workflows.types.core import JsonObject
-from vellum.workflows.vellum_client import create_vellum_client
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
@@ -28,7 +27,10 @@ class BasePromptDeploymentNodeDisplay(BaseNodeDisplay[_PromptDeploymentNodeType]
                     input_name=variable_name,
                     value=variable_value,
                     display_context=display_context,
-                    input_id=self.node_input_ids_by_name.get(variable_name),
+                    input_id=self.node_input_ids_by_name.get(
+                        f"{PromptDeploymentNode.prompt_inputs.name}.{variable_name}"
+                    )
+                    or self.node_input_ids_by_name.get(variable_name),
                 )
                 for variable_name, variable_value in prompt_inputs.items()
             ]
@@ -39,10 +41,7 @@ class BasePromptDeploymentNodeDisplay(BaseNodeDisplay[_PromptDeploymentNodeType]
         _, output_display = display_context.global_node_output_displays[cast(OutputReference, node.Outputs.text)]
         _, array_display = display_context.global_node_output_displays[cast(OutputReference, node.Outputs.results)]
 
-        # TODO: Pass through the name instead of retrieving the ID
-        # https://app.shortcut.com/vellum/story/4702
-        vellum_client = create_vellum_client()
-        deployment = vellum_client.deployments.retrieve(
+        deployment = display_context.client.deployments.retrieve(
             id=str(raise_if_descriptor(node.deployment)),
         )
         ml_model_fallbacks = raise_if_descriptor(node.ml_model_fallbacks)

{vellum_ai-0.14.44 → vellum_ai-0.14.46}/ee/vellum_ee/workflows/display/nodes/vellum/retry_node.py

@@ -1,7 +1,6 @@
 import inspect
-from typing import Any, Generic, Tuple, Type, TypeVar, cast
+from typing import Any, Generic, Tuple, Type, TypeVar
 
-from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.core.retry_node.node import RetryNode
 from vellum.workflows.nodes.utils import ADORNMENT_MODULE_NAME
@@ -13,6 +12,7 @@ from vellum_ee.workflows.display.nodes.get_node_display_class import get_node_di
 from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay
 from vellum_ee.workflows.display.nodes.vellum.base_adornment_node import BaseAdornmentNodeDisplay
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
+from vellum_ee.workflows.display.utils.expressions import serialize_value
 
 _RetryNodeType = TypeVar("_RetryNodeType", bound=RetryNode)
 
@@ -33,7 +33,7 @@ class BaseRetryNodeDisplay(BaseAdornmentNodeDisplay[_RetryNodeType], Generic[_Re
                 {
                     "id": id,
                     "name": attribute.name,
-                    "value": self.serialize_value(display_context, cast(BaseDescriptor, attribute.instance)),
+                    "value": serialize_value(display_context, attribute.instance),
                 }
             )
 

{vellum_ai-0.14.44 → vellum_ai-0.14.46}/ee/vellum_ee/workflows/display/nodes/vellum/subworkflow_deployment_node.py

@@ -3,7 +3,6 @@ from typing import Generic, Optional, TypeVar
 
 from vellum.workflows.nodes import SubworkflowDeploymentNode
 from vellum.workflows.types.core import JsonObject
-from vellum.workflows.vellum_client import create_vellum_client
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
@@ -29,15 +28,15 @@ class BaseSubworkflowDeploymentNodeDisplay(
                 input_name=variable_name,
                 value=variable_value,
                 display_context=display_context,
-                input_id=self.node_input_ids_by_name.get(variable_name),
+                input_id=self.node_input_ids_by_name.get(
+                    f"{SubworkflowDeploymentNode.subworkflow_inputs.name}.{variable_name}"
+                )
+                or self.node_input_ids_by_name.get(variable_name),
             )
             for variable_name, variable_value in subworkflow_inputs.items()
         ]
 
-        # TODO: Pass through the name instead of retrieving the ID
-        # https://app.shortcut.com/vellum/story/4702
-        vellum_client = create_vellum_client()
-        deployment = vellum_client.workflow_deployments.retrieve(
+        deployment = display_context.client.workflow_deployments.retrieve(
             id=str(raise_if_descriptor(node.deployment)),
         )