vellum-ai 0.14.47__tar.gz → 0.14.48__tar.gz

{vellum_ai-0.14.47 → vellum_ai-0.14.48}/PKG-INFO

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

{vellum_ai-0.14.47 → vellum_ai-0.14.48}/ee/vellum_cli/__init__.py

@@ -354,9 +354,10 @@ def images() -> None:
     help="Tags the provided image inside of Vellum's repo. "
     "This field does not push multiple local tags of the passed in image.",
 )
-def image_push(image: str, tag: Optional[List[str]] = None) -> None:
+@click.option("--workspace", type=str, help="The specific Workspace config to use when pushing")
+def image_push(image: str, tag: Optional[List[str]] = None, workspace: Optional[str] = None) -> None:
     """Push Docker image to Vellum"""
-    image_push_command(image, tag)
+    image_push_command(image, tag, workspace)
 
 
 @workflows.command(name="init")

{vellum_ai-0.14.47 → vellum_ai-0.14.48}/ee/vellum_cli/image_push.py

@@ -1,5 +1,6 @@
 import json
 import logging
+import os
 import re
 import subprocess
 from typing import List, Optional
@@ -9,15 +10,26 @@ from docker import DockerClient
 from dotenv import load_dotenv
 
 from vellum.workflows.vellum_client import create_vellum_client, create_vellum_environment
+from vellum_cli.config import DEFAULT_WORKSPACE_CONFIG, load_vellum_cli_config
 from vellum_cli.logger import load_cli_logger
 
 _SUPPORTED_ARCHITECTURE = "amd64"
 
 
-def image_push_command(image: str, tags: Optional[List[str]] = None) -> None:
-    load_dotenv()
+def image_push_command(image: str, tags: Optional[List[str]] = None, workspace: Optional[str] = None) -> None:
+    load_dotenv(dotenv_path=os.path.join(os.getcwd(), ".env"))
     logger = load_cli_logger()
-    vellum_client = create_vellum_client()
+    config = load_vellum_cli_config()
+    workspace_config = next((w for w in config.workspaces if w.name == workspace), DEFAULT_WORKSPACE_CONFIG)
+
+    api_key = os.getenv(workspace_config.api_key, None)
+    if not api_key:
+        raise ValueError(f"API key {workspace_config.api_key} for workspace {workspace} not found")
+
+    vellum_client = create_vellum_client(
+        api_key=api_key,
+        api_url=workspace_config.api_url,
+    )
 
     # Check if we are self hosted by looking at our base url
     api_url = create_vellum_environment().default

vellum_ai-0.14.48/ee/vellum_cli/tests/test_image_push.py

@@ -0,0 +1,165 @@
+import pytest
+import json
+import os
+import shutil
+import subprocess
+import tempfile
+from unittest.mock import MagicMock, patch
+from uuid import uuid4
+from typing import Generator
+
+from click.testing import CliRunner
+from httpx import Response
+
+from vellum_cli import main as cli_main
+
+
+@pytest.fixture
+def mock_temp_dir() -> Generator[str, None, None]:
+    current_dir = os.getcwd()
+    temp_dir = tempfile.mkdtemp()
+    os.chdir(temp_dir)
+
+    yield temp_dir
+
+    os.chdir(current_dir)
+    shutil.rmtree(temp_dir)
+
+
+@patch("subprocess.run")
+@patch("docker.from_env")
+def test_image_push__self_hosted_happy_path(mock_docker_from_env, mock_run, vellum_client, monkeypatch):
+    # GIVEN a self hosted vellum api URL env var
+    monkeypatch.setenv("VELLUM_API_URL", "mycompany.api.com")
+    monkeypatch.setenv("VELLUM_API_KEY", "123456abcdef")
+
+    # Mock Docker client
+    mock_docker_client = MagicMock()
+    mock_docker_from_env.return_value = mock_docker_client
+
+    mock_run.side_effect = [
+        subprocess.CompletedProcess(
+            args="", returncode=0, stdout=b'{"manifests": [{"platform": {"architecture": "amd64"}}]}'
+        ),
+        subprocess.CompletedProcess(args="", returncode=0, stdout=b"manifest"),
+        subprocess.CompletedProcess(args="", returncode=0, stdout=b"sha256:hellosha"),
+    ]
+
+    # WHEN the user runs the image push command
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["image", "push", "myrepo.net/myimage:latest"])
+
+    # THEN the command exits successfully
+    assert result.exit_code == 0, result.output
+
+    # AND gives the success message
+    assert "Image successfully pushed" in result.output
+
+
+@patch("subprocess.run")
+@patch("docker.from_env")
+def test_image_push__self_hosted_happy_path__workspace_option(
+    mock_docker_from_env, mock_run, mock_httpx_transport, mock_temp_dir
+):
+    # GIVEN a workspace config with a new env for url
+    with open(os.path.join(mock_temp_dir, "vellum.lock.json"), "w") as f:
+        f.write(
+            json.dumps(
+                {
+                    "workspaces": [
+                        {
+                            "name": "my_workspace",
+                            "api_url": "MY_WORKSPACE_VELLUM_API_URL",
+                            "api_key": "MY_WORKSPACE_VELLUM_API_KEY",
+                        }
+                    ]
+                }
+            )
+        )
+
+    # AND a .env file with the workspace api key and url
+    with open(os.path.join(mock_temp_dir, ".env"), "w") as f:
+        f.write(
+            "VELLUM_API_KEY=123456abcdef\n"
+            "VELLUM_API_URL=https://api.vellum.ai\n"
+            "MY_WORKSPACE_VELLUM_API_KEY=789012ghijkl\n"
+            "MY_WORKSPACE_VELLUM_API_URL=https://api.vellum.mycompany.ai\n"
+        )
+
+    # AND the Docker client returns the correct response
+    mock_docker_client = MagicMock()
+    mock_docker_from_env.return_value = mock_docker_client
+
+    mock_run.side_effect = [
+        subprocess.CompletedProcess(
+            args="", returncode=0, stdout=b'{"manifests": [{"platform": {"architecture": "amd64"}}]}'
+        ),
+        subprocess.CompletedProcess(args="", returncode=0, stdout=b"sha256:hellosha"),
+    ]
+
+    # AND the vellum client returns the correct response for
+    mock_httpx_transport.handle_request.side_effect = [
+        # First call to get the docker service token
+        Response(
+            status_code=200,
+            text=json.dumps(
+                {
+                    "access_token": "345678mnopqr",
+                    "organization_id": str(uuid4()),
+                    "repository": "myrepo.net",
+                }
+            ),
+        ),
+        # Second call to push the image
+        Response(
+            status_code=200,
+            text=json.dumps(
+                {
+                    "id": str(uuid4()),
+                    "name": "myrepo.net/myimage",
+                    "visibility": "PRIVATE",
+                    "created": "2021-01-01T00:00:00Z",
+                    "modified": "2021-01-01T00:00:00Z",
+                    "repository": "myrepo.net",
+                    "sha": "sha256:hellosha",
+                    "tags": [],
+                }
+            ),
+        ),
+    ]
+
+    # WHEN the user runs the image push command
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["image", "push", "myrepo.net/myimage:latest", "--workspace", "my_workspace"])
+
+    # THEN the command exits successfully
+    assert result.exit_code == 0, (result.output, str(result.exception))
+
+    # AND gives the success message
+    assert "Image successfully pushed" in result.output
+
+    # AND the vellum client was called with the correct api key and url
+    request = mock_httpx_transport.handle_request.call_args[0][0]
+    assert request.headers["X-API-KEY"] == "789012ghijkl", result.stdout
+    assert str(request.url) == "https://api.vellum.mycompany.ai/v1/container-images/push"
+
+
+@patch("subprocess.run")
+@patch("docker.from_env")
+def test_image_push__self_hosted_blocks_repo(mock_docker_from_env, mock_run, vellum_client, monkeypatch):
+    # GIVEN a self hosted vellum api URL env var
+    monkeypatch.setenv("VELLUM_API_URL", "mycompany.api.com")
+
+    # Mock Docker client
+    mock_docker_client = MagicMock()
+    mock_docker_from_env.return_value = mock_docker_client
+
+    # WHEN the user runs the image push command
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["image", "push", "myimage"])
+
+    # THEN the command exits unsuccessfully
+    assert result.exit_code == 1, result.output
+
+    # AND gives the error message for self hosted installs not including the repo
+    assert "For adding images to your self hosted install you must include" in result.output

{vellum_ai-0.14.47 → vellum_ai-0.14.48}/ee/vellum_ee/workflows/display/nodes/base_node_display.py

@@ -260,10 +260,15 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
 
     def get_source_handle_id(self, port_displays: Dict[Port, PortDisplay]) -> UUID:
         unadorned_node = get_unadorned_node(self._node)
-        default_port = unadorned_node.Ports.default
+        default_port = next((port for port in unadorned_node.Ports if port.default), None)
+        if default_port in port_displays:
+            return port_displays[default_port].id
 
-        default_port_display = port_displays[default_port]
-        return default_port_display.id
+        first_port = next((port for port in unadorned_node.Ports), None)
+        if not first_port:
+            raise ValueError(f"Node {self._node.__name__} must have at least one port.")
+
+        return port_displays[first_port].id
 
     def get_trigger_id(self) -> UUID:
         return self.get_target_handle_id()

{vellum_ai-0.14.47 → vellum_ai-0.14.48}/ee/vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py

@@ -32,7 +32,7 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
         output_display = self.output_display[node.Outputs.text]
         array_display = self.output_display[node.Outputs.results]
         json_display = self.output_display[node.Outputs.json]
-        node_blocks = raise_if_descriptor(node.blocks)
+        node_blocks = raise_if_descriptor(node.blocks) or []
         function_definitions = raise_if_descriptor(node.functions)
 
         ml_model = str(raise_if_descriptor(node.ml_model))

{vellum_ai-0.14.47 → vellum_ai-0.14.48}/ee/vellum_ee/workflows/display/nodes/vellum/tests/test_prompt_node.py

@@ -6,6 +6,7 @@ from vellum.client.types.variable_prompt_block import VariablePromptBlock
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.nodes import BaseNode
 from vellum.workflows.nodes.displayable.inline_prompt_node.node import InlinePromptNode
+from vellum.workflows.ports.port import Port
 from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.state.base import BaseState
 from vellum_ee.workflows.display.nodes.vellum.inline_prompt_node import BaseInlinePromptNodeDisplay
@@ -215,3 +216,33 @@ def test_serialize_node__unreferenced_variable_block__still_serializes():
     # warnings = list(workflow_display.errors)
     # assert len(warnings) == 1
     # assert "Missing input variable 'foo' for prompt block 0" in str(warnings[0])
+
+
+def test_serialize_node__port_groups():
+    # GIVEN a prompt node with ports
+    class MyPromptNode(InlinePromptNode):
+        class Ports(InlinePromptNode.Ports):
+            apple = Port.on_if(LazyReference(lambda: MyPromptNode.Outputs.text).equals("apple"))
+            banana = Port.on_if(LazyReference(lambda: MyPromptNode.Outputs.text).equals("banana"))
+
+    # AND a workflow with the prompt node
+    class MyWorkflow(BaseWorkflow):
+        graph = MyPromptNode
+
+    # WHEN the prompt node is serialized
+    workflow_display = get_workflow_display(workflow_class=MyWorkflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the node should have the ports serialized
+    my_prompt_node = next(
+        node for node in serialized_workflow["workflow_raw_data"]["nodes"] if node["id"] == str(MyPromptNode.__id__)
+    )
+    ports = my_prompt_node["ports"]
+    assert len(ports) == 2
+    assert ports[0]["id"] == "149d97a4-3da3-44a9-95f7-ea7b8d38b877"
+    assert ports[1]["id"] == "71f2d2b3-194f-4492-bc1c-a5ca1f60fb0a"
+    assert ports[0]["name"] == "apple"
+    assert ports[1]["name"] == "banana"
+
+    # AND the legacy source_handle_id should be the default port
+    assert my_prompt_node["data"]["source_handle_id"] == "149d97a4-3da3-44a9-95f7-ea7b8d38b877"

{vellum_ai-0.14.47 → vellum_ai-0.14.48}/ee/vellum_ee/workflows/display/utils/expressions.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Dict, cast
 
 from vellum.client.types.logical_operator import LogicalOperator
 from vellum.workflows.descriptors.base import BaseDescriptor
@@ -37,7 +37,7 @@ from vellum.workflows.references.output import OutputReference
 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 JsonObject
+from vellum.workflows.types.core import JsonArray, JsonObject
 from vellum_ee.workflows.display.utils.exceptions import UnsupportedSerializationException
 
 if TYPE_CHECKING:
@@ -235,6 +235,33 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
             "node_id": str(node_class_display.node_id),
         }
 
+    if isinstance(value, list):
+        serialized_items = [serialize_value(display_context, item) for item in value]
+        if all(isinstance(item, dict) and item["type"] == "CONSTANT_VALUE" for item in serialized_items):
+            constant_values = []
+            for item in serialized_items:
+                item_dict = cast(Dict[str, Any], item)
+                value_inner = item_dict["value"]
+
+                if value_inner["type"] == "JSON" and "items" in value_inner:
+                    # Nested JSON list
+                    constant_values.append(value_inner["items"])
+                else:
+                    constant_values.append(value_inner["value"])
+
+            return {
+                "type": "CONSTANT_VALUE",
+                "value": {
+                    "type": "JSON",
+                    "items": constant_values,
+                },
+            }
+        else:
+            return {
+                "type": "ARRAY_REFERENCE",
+                "items": cast(JsonArray, serialized_items),  # list[JsonObject] -> JsonArray
+            }
+
     if isinstance(value, dict) and any(isinstance(v, BaseDescriptor) for v in value.values()):
         raise ValueError("Nested references are not supported.")
 

{vellum_ai-0.14.47 → vellum_ai-0.14.48}/ee/vellum_ee/workflows/display/workflows/tests/test_workflow_display.py

@@ -425,3 +425,165 @@ def test_serialize_workflow__nested_lazy_reference():
         "node_id": str(OuterNode.__id__),
         "node_output_id": str(OuterNode.__output_ids__["bar"]),
     }
+
+
+def test_serialize_workflow__array_values():
+    # GIVEN a node with array and nested array values
+    class MyNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            array_value = ["item1", "item2", "item3"]
+            nested_array_value = [["item1", "item2", "item3"], ["item4", "item5", "item6"]]
+            mixed_array_value = [["item1"], "item2", "item3"]
+
+    # AND a workflow that uses these outputs
+    class MyWorkflow(BaseWorkflow):
+        graph = MyNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            array_output = MyNode.Outputs.array_value
+            nested_array_output = MyNode.Outputs.nested_array_value
+
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=MyWorkflow)
+    data = workflow_display.serialize()
+
+    # THEN it should properly serialize the array and dictionary values
+    assert isinstance(data["workflow_raw_data"], dict)
+    assert isinstance(data["workflow_raw_data"]["nodes"], list)
+    raw_nodes = data["workflow_raw_data"]["nodes"]
+    generic_nodes = [node for node in raw_nodes if isinstance(node, dict) and node["type"] == "GENERIC"]
+    assert len(generic_nodes) > 0
+    my_node = generic_nodes[0]
+
+    outputs = my_node["outputs"]
+    assert isinstance(outputs, list)
+
+    array_outputs = [val for val in outputs if isinstance(val, dict) and val["name"] == "array_value"]
+    assert len(array_outputs) > 0
+    array_output = array_outputs[0]
+
+    assert isinstance(array_output, dict)
+    assert "value" in array_output
+    assert array_output["value"] == {
+        "type": "CONSTANT_VALUE",
+        "value": {"type": "JSON", "items": ["item1", "item2", "item3"]},
+    }
+
+    nested_array_outputs = [val for val in outputs if isinstance(val, dict) and val["name"] == "nested_array_value"]
+    assert len(nested_array_outputs) > 0
+    nested_array_output = nested_array_outputs[0]
+
+    assert isinstance(nested_array_output, dict)
+    assert "value" in nested_array_output
+    assert nested_array_output["value"] == {
+        "type": "CONSTANT_VALUE",
+        "value": {"type": "JSON", "items": [["item1", "item2", "item3"], ["item4", "item5", "item6"]]},
+    }
+
+    mixed_array_outputs = [val for val in outputs if isinstance(val, dict) and val["name"] == "mixed_array_value"]
+    assert len(mixed_array_outputs) > 0
+    mixed_array_output = mixed_array_outputs[0]
+
+    assert isinstance(mixed_array_output, dict)
+    assert "value" in mixed_array_output
+    assert mixed_array_output["value"] == {
+        "type": "CONSTANT_VALUE",
+        "value": {"type": "JSON", "items": [["item1"], "item2", "item3"]},
+    }
+
+
+def test_serialize_workflow__array_reference():
+    # GIVEN a node with array containing non-constant values (node references)
+    class FirstNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            value1: str
+            value2: str
+
+    class SecondNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            # Array containing a mix of constants and node references
+            mixed_array = ["constant1", FirstNode.Outputs.value1, "constant2", FirstNode.Outputs.value2]
+            mixed_nested_array = [["constant1", FirstNode.Outputs.value1], ["constant2", FirstNode.Outputs.value2]]
+
+    # AND a workflow that uses these outputs
+    class MyWorkflow(BaseWorkflow):
+        graph = FirstNode >> SecondNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            mixed_array_output = SecondNode.Outputs.mixed_array
+            mixed_nested_array_output = SecondNode.Outputs.mixed_nested_array
+
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=MyWorkflow)
+    data = workflow_display.serialize()
+
+    # THEN it should serialize as an ARRAY_REFERENCE
+    assert isinstance(data["workflow_raw_data"], dict)
+    assert isinstance(data["workflow_raw_data"]["nodes"], list)
+    assert len(data["workflow_raw_data"]["nodes"]) == 5
+    second_node = data["workflow_raw_data"]["nodes"][2]
+    assert isinstance(second_node, dict)
+
+    assert "outputs" in second_node
+    assert isinstance(second_node["outputs"], list)
+    outputs = second_node["outputs"]
+
+    mixed_array_outputs = [val for val in outputs if isinstance(val, dict) and val["name"] == "mixed_array"]
+    assert len(mixed_array_outputs) > 0
+    mixed_array_output = mixed_array_outputs[0]
+
+    assert isinstance(mixed_array_output, dict)
+    assert "value" in mixed_array_output
+    assert mixed_array_output["value"] == {
+        "type": "ARRAY_REFERENCE",
+        "items": [
+            {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "constant1"}},
+            {
+                "type": "NODE_OUTPUT",
+                "node_id": "702a08b5-61e8-4a7a-a83d-77f49e39c5be",
+                "node_output_id": "419b6afa-fab5-493a-ba1e-4606f4641616",
+            },
+            {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "constant2"}},
+            {
+                "type": "NODE_OUTPUT",
+                "node_id": "702a08b5-61e8-4a7a-a83d-77f49e39c5be",
+                "node_output_id": "d1cacc41-478d-49a3-a6b3-1ba2d51291e2",
+            },
+        ],
+    }
+
+    mixed_nested_array_outputs = [
+        val for val in outputs if isinstance(val, dict) and val["name"] == "mixed_nested_array"
+    ]
+    assert len(mixed_nested_array_outputs) > 0
+    mixed_nested_array_output = mixed_nested_array_outputs[0]
+
+    assert isinstance(mixed_nested_array_output, dict)
+    assert "value" in mixed_nested_array_output
+    assert mixed_nested_array_output["value"] == {
+        "type": "ARRAY_REFERENCE",
+        "items": [
+            {
+                "type": "ARRAY_REFERENCE",
+                "items": [
+                    {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "constant1"}},
+                    {
+                        "type": "NODE_OUTPUT",
+                        "node_id": "702a08b5-61e8-4a7a-a83d-77f49e39c5be",
+                        "node_output_id": "419b6afa-fab5-493a-ba1e-4606f4641616",
+                    },
+                ],
+            },
+            {
+                "type": "ARRAY_REFERENCE",
+                "items": [
+                    {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "constant2"}},
+                    {
+                        "type": "NODE_OUTPUT",
+                        "node_id": "702a08b5-61e8-4a7a-a83d-77f49e39c5be",
+                        "node_output_id": "d1cacc41-478d-49a3-a6b3-1ba2d51291e2",
+                    },
+                ],
+            },
+        ],
+    }

{vellum_ai-0.14.47 → vellum_ai-0.14.48}/pyproject.toml

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

{vellum_ai-0.14.47 → vellum_ai-0.14.48}/src/vellum/client/core/client_wrapper.py

@@ -18,7 +18,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.14.47",
+            "X-Fern-SDK-Version": "0.14.48",
         }
         headers["X-API-KEY"] = self.api_key
         return headers

vellum_ai-0.14.47/ee/vellum_cli/tests/test_image_push.py

@@ -1,56 +0,0 @@
-import subprocess
-from unittest.mock import MagicMock, patch
-
-from click.testing import CliRunner
-
-from vellum_cli import main as cli_main
-
-
-@patch("subprocess.run")
-@patch("docker.from_env")
-def test_image_push__self_hosted_happy_path(mock_docker_from_env, mock_run, vellum_client, monkeypatch):
-    # GIVEN a self hosted vellum api URL env var
-    monkeypatch.setenv("VELLUM_API_URL", "mycompany.api.com")
-
-    # Mock Docker client
-    mock_docker_client = MagicMock()
-    mock_docker_from_env.return_value = mock_docker_client
-
-    mock_run.side_effect = [
-        subprocess.CompletedProcess(
-            args="", returncode=0, stdout=b'{"manifests": [{"platform": {"architecture": "amd64"}}]}'
-        ),
-        subprocess.CompletedProcess(args="", returncode=0, stdout=b"manifest"),
-        subprocess.CompletedProcess(args="", returncode=0, stdout=b"sha256:hellosha"),
-    ]
-
-    # WHEN the user runs the image push command
-    runner = CliRunner()
-    result = runner.invoke(cli_main, ["image", "push", "myrepo.net/myimage:latest"])
-
-    # THEN the command exits successfully
-    assert result.exit_code == 0, result.output
-
-    # AND gives the success message
-    assert "Image successfully pushed" in result.output
-
-
-@patch("subprocess.run")
-@patch("docker.from_env")
-def test_image_push__self_hosted_blocks_repo(mock_docker_from_env, mock_run, vellum_client, monkeypatch):
-    # GIVEN a self hosted vellum api URL env var
-    monkeypatch.setenv("VELLUM_API_URL", "mycompany.api.com")
-
-    # Mock Docker client
-    mock_docker_client = MagicMock()
-    mock_docker_from_env.return_value = mock_docker_client
-
-    # WHEN the user runs the image push command
-    runner = CliRunner()
-    result = runner.invoke(cli_main, ["image", "push", "myimage"])
-
-    # THEN the command exits unsuccessfully
-    assert result.exit_code == 1, result.output
-
-    # AND gives the error message for self hosted installs not including the repo
-    assert "For adding images to your self hosted install you must include" in result.output