vellum-ai 1.3.2__tar.gz → 1.3.3__tar.gz

{vellum_ai-1.3.2 → vellum_ai-1.3.3}/PKG-INFO

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

{vellum_ai-1.3.2 → vellum_ai-1.3.3}/ee/vellum_cli/__init__.py

@@ -5,6 +5,7 @@ import click
 from vellum_cli.aliased_group import ClickAliasedGroup
 from vellum_cli.image_push import image_push_command
 from vellum_cli.init import init_command
+from vellum_cli.move import move_command
 from vellum_cli.ping import ping_command
 from vellum_cli.pull import pull_command
 from vellum_cli.push import push_command
@@ -376,6 +377,26 @@ def image_push(
     image_push_command(image, tag, workspace, source)
 
 
+@workflows.command(name="move")
+@click.argument("old_module", required=True)
+@click.argument("new_module", required=True)
+@click.option("--workspace", type=str, help="The specific Workspace config to use when moving")
+def workflows_move(
+    old_module: str,
+    new_module: str,
+    workspace: Optional[str],
+) -> None:
+    """
+    Move/rename a Workflow module. Updates both the filesystem structure and configuration.
+    """
+
+    move_command(
+        old_module=old_module,
+        new_module=new_module,
+        workspace=workspace,
+    )
+
+
 @workflows.command(name="init")
 @click.argument("template_name", required=False)
 @click.option(

vellum_ai-1.3.3/ee/vellum_cli/move.py

@@ -0,0 +1,56 @@
+import os
+import shutil
+from typing import Optional
+
+from dotenv import load_dotenv
+
+from vellum_cli.config import DEFAULT_WORKSPACE_CONFIG, load_vellum_cli_config
+from vellum_cli.logger import load_cli_logger
+from vellum_cli.push import module_exists
+
+
+def move_command(
+    old_module: str,
+    new_module: str,
+    workspace: Optional[str] = None,
+) -> None:
+    load_dotenv(dotenv_path=os.path.join(os.getcwd(), ".env"))
+    logger = load_cli_logger()
+    config = load_vellum_cli_config()
+
+    if not module_exists(old_module):
+        raise ValueError(f"Module '{old_module}' does not exist in the filesystem.")
+
+    if module_exists(new_module):
+        raise ValueError(f"Module '{new_module}' already exists. Cannot move to existing module.")
+
+    matching_configs = [w for w in config.workflows if w.module == old_module]
+
+    if workspace:
+        matching_configs = [w for w in matching_configs if w.workspace == workspace]
+    else:
+        matching_configs = [w for w in matching_configs if w.workspace == DEFAULT_WORKSPACE_CONFIG.name]
+
+    if not matching_configs:
+        workspace_msg = (
+            f" in workspace '{workspace}'" if workspace else f" in workspace '{DEFAULT_WORKSPACE_CONFIG.name}'"
+        )
+        raise ValueError(f"No workflow configuration found for module '{old_module}'{workspace_msg}.")
+
+    logger.info(f"Moving module from '{old_module}' to '{new_module}'...")
+
+    old_path = os.path.join(os.getcwd(), *old_module.split("."))
+    new_path = os.path.join(os.getcwd(), *new_module.split("."))
+
+    os.makedirs(os.path.dirname(new_path), exist_ok=True)
+
+    shutil.move(old_path, new_path)
+    logger.info(f"Moved filesystem directory from '{old_path}' to '{new_path}'")
+
+    for workflow_config in matching_configs:
+        workflow_config.module = new_module
+        logger.info(f"Updated workflow configuration: {workflow_config.workflow_sandbox_id}")
+
+    config.save()
+    logger.info("Updated vellum.lock.json file.")
+    logger.info(f"Successfully moved module from '{old_module}' to '{new_module}'")

vellum_ai-1.3.3/ee/vellum_cli/tests/test_move.py

@@ -0,0 +1,154 @@
+import os
+
+from click.testing import CliRunner
+
+from vellum_cli import main
+from vellum_cli.config import load_vellum_cli_config
+
+
+def test_move__happy_path(mock_module):
+    """
+    Test that the move command successfully moves a module and updates configuration.
+    """
+
+    temp_dir = mock_module.temp_dir
+    old_module = mock_module.module
+    new_module = "examples.new.workflow"
+
+    old_module_dir = os.path.join(temp_dir, *old_module.split("."))
+    os.makedirs(old_module_dir, exist_ok=True)
+    with open(os.path.join(old_module_dir, "workflow.py"), "w") as f:
+        f.write("# test workflow")
+
+    runner = CliRunner()
+    result = runner.invoke(main, ["workflows", "move", old_module, new_module])
+
+    assert result.exit_code == 0
+
+    assert not os.path.exists(old_module_dir)
+
+    new_module_dir = os.path.join(temp_dir, *new_module.split("."))
+    assert os.path.exists(new_module_dir)
+    assert os.path.exists(os.path.join(new_module_dir, "workflow.py"))
+
+    config = load_vellum_cli_config()
+    workflow_config = next((w for w in config.workflows if w.module == new_module), None)
+    assert workflow_config is not None
+    assert workflow_config.workflow_sandbox_id == mock_module.workflow_sandbox_id
+
+
+def test_move__old_module_not_exists(mock_module):
+    """
+    Test that the move command fails when the old module doesn't exist.
+    """
+
+    old_module = "nonexistent.module"
+    new_module = "examples.new.workflow"
+
+    runner = CliRunner()
+    result = runner.invoke(main, ["workflows", "move", old_module, new_module])
+
+    assert result.exit_code != 0
+    assert "does not exist in the filesystem" in str(result.exception)
+
+
+def test_move__new_module_already_exists(mock_module):
+    """
+    Test that the move command fails when the new module already exists.
+    """
+
+    temp_dir = mock_module.temp_dir
+    old_module = mock_module.module
+    new_module = "examples.existing.workflow"
+
+    old_module_dir = os.path.join(temp_dir, *old_module.split("."))
+    new_module_dir = os.path.join(temp_dir, *new_module.split("."))
+    os.makedirs(old_module_dir, exist_ok=True)
+    os.makedirs(new_module_dir, exist_ok=True)
+
+    runner = CliRunner()
+    result = runner.invoke(main, ["workflows", "move", old_module, new_module])
+
+    assert result.exit_code != 0
+    assert "already exists" in str(result.exception)
+
+
+def test_move__no_workflow_config_found(mock_module):
+    """
+    Test that the move command fails when no workflow config is found.
+    """
+
+    temp_dir = mock_module.temp_dir
+    old_module = "examples.unconfigured.workflow"
+    new_module = "examples.new.workflow"
+
+    old_module_dir = os.path.join(temp_dir, *old_module.split("."))
+    os.makedirs(old_module_dir, exist_ok=True)
+
+    runner = CliRunner()
+    result = runner.invoke(main, ["workflows", "move", old_module, new_module])
+
+    assert result.exit_code != 0
+    assert "No workflow configuration found" in str(result.exception)
+
+
+def test_move__with_workspace_filter(mock_module):
+    """
+    Test that the move command works with workspace filtering.
+    """
+
+    temp_dir = mock_module.temp_dir
+    old_module = mock_module.module
+    new_module = "examples.new.workflow"
+    workspace = "default"
+
+    old_module_dir = os.path.join(temp_dir, *old_module.split("."))
+    os.makedirs(old_module_dir, exist_ok=True)
+    with open(os.path.join(old_module_dir, "workflow.py"), "w") as f:
+        f.write("# test workflow")
+
+    runner = CliRunner()
+    result = runner.invoke(main, ["workflows", "move", old_module, new_module, "--workspace", workspace])
+
+    assert result.exit_code == 0
+
+    config = load_vellum_cli_config()
+    workflow_config = next((w for w in config.workflows if w.module == new_module), None)
+    assert workflow_config is not None
+    assert workflow_config.workspace == workspace
+
+
+def test_move__preserves_workflow_metadata(mock_module):
+    """
+    Test that the move command preserves all workflow metadata except the module name.
+    """
+
+    temp_dir = mock_module.temp_dir
+    old_module = mock_module.module
+    new_module = "examples.new.workflow"
+
+    config = load_vellum_cli_config()
+    original_config = next((w for w in config.workflows if w.module == old_module), None)
+    assert original_config is not None
+    original_config.container_image_name = "test-image"
+    original_config.container_image_tag = "v1.0"
+    original_config.ignore = "sandbox.py"
+    config.save()
+
+    old_module_dir = os.path.join(temp_dir, *old_module.split("."))
+    os.makedirs(old_module_dir, exist_ok=True)
+    with open(os.path.join(old_module_dir, "workflow.py"), "w") as f:
+        f.write("# test workflow")
+
+    runner = CliRunner()
+    result = runner.invoke(main, ["workflows", "move", old_module, new_module])
+
+    assert result.exit_code == 0
+
+    config = load_vellum_cli_config()
+    workflow_config = next((w for w in config.workflows if w.module == new_module), None)
+    assert workflow_config is not None
+    assert workflow_config.workflow_sandbox_id == mock_module.workflow_sandbox_id
+    assert workflow_config.container_image_name == "test-image"
+    assert workflow_config.container_image_tag == "v1.0"
+    assert workflow_config.ignore == "sandbox.py"

{vellum_ai-1.3.2 → vellum_ai-1.3.3}/ee/vellum_ee/workflows/display/base.py

@@ -56,6 +56,7 @@ class StateValueDisplay:
 @dataclass
 class EdgeDisplay:
     id: UUID
+    z_index: Optional[int] = None
 
 
 @dataclass

{vellum_ai-1.3.2 → vellum_ai-1.3.3}/ee/vellum_ee/workflows/display/editor/types.py

@@ -17,6 +17,7 @@ class NodeDisplayComment(UniversalBaseModel):
 
 class NodeDisplayData(UniversalBaseModel):
     position: NodeDisplayPosition = Field(default_factory=NodeDisplayPosition)
+    z_index: Optional[int] = None
     width: Optional[int] = None
     height: Optional[int] = None
     comment: Optional[NodeDisplayComment] = None

{vellum_ai-1.3.2 → vellum_ai-1.3.3}/ee/vellum_ee/workflows/display/nodes/base_node_display.py

@@ -431,6 +431,7 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
             )
             return NodeDisplayData(
                 position=explicit_value.position,
+                z_index=explicit_value.z_index,
                 width=explicit_value.width,
                 height=explicit_value.height,
                 comment=comment,

{vellum_ai-1.3.2 → vellum_ai-1.3.3}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_inline_prompt_node_serialization.py

@@ -47,17 +47,20 @@ def test_serialize_workflow():
 
     # AND its output variables should be what we expect
     output_variables = serialized_workflow["output_variables"]
-    assert len(output_variables) == 1
+    assert len(output_variables) == 2
     assert not DeepDiff(
-        [{"id": "15a0ab89-8ed4-43b9-afa2-3c0b29d4dc3e", "key": "results", "type": "JSON"}],
+        [
+            {"id": "15a0ab89-8ed4-43b9-afa2-3c0b29d4dc3e", "key": "results", "type": "JSON"},
+            {"id": "0ef1608e-1737-41cc-9b90-a8e124138f70", "key": "json", "type": "JSON"},
+        ],
         output_variables,
         ignore_order=True,
     )
 
     # AND its raw data should be what we expect
     workflow_raw_data = serialized_workflow["workflow_raw_data"]
-    assert len(workflow_raw_data["edges"]) == 2
-    assert len(workflow_raw_data["nodes"]) == 3
+    assert len(workflow_raw_data["edges"]) == 3
+    assert len(workflow_raw_data["nodes"]) == 4
 
     # AND each node should be serialized correctly
     entrypoint_node = workflow_raw_data["nodes"][0]
@@ -305,7 +308,7 @@ def test_serialize_workflow():
                     },
                 }
             ],
-            "display_data": {"position": {"x": 400.0, "y": -50.0}},
+            "display_data": {"position": {"x": 400.0, "y": 75.0}},
             "base": {
                 "name": "FinalOutputNode",
                 "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
@@ -336,6 +339,14 @@ def test_serialize_workflow():
                 "target_handle_id": "46c99277-2b4b-477d-851c-ea497aef6b16",
                 "type": "DEFAULT",
             },
+            {
+                "id": "0b1a2960-4cd5-4045-844f-42b6c87487aa",
+                "source_node_id": "8450dd06-975a-41a4-a564-808ee8808fe6",
+                "source_handle_id": "d4a097ab-e22d-42f1-b6bc-2ed96856377a",
+                "target_node_id": "1f4e3b7b-6af1-42c8-ab33-05b0f01e2b62",
+                "target_handle_id": "7d94907f-c840-4ced-b813-ee3b17f2a8a9",
+                "type": "DEFAULT",
+            },
         ],
         serialized_edges,
         ignore_order=True,

{vellum_ai-1.3.2 → vellum_ai-1.3.3}/pyproject.toml

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

{vellum_ai-1.3.2 → vellum_ai-1.3.3}/src/vellum/client/core/client_wrapper.py

@@ -27,10 +27,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "vellum-ai/1.3.2",
+            "User-Agent": "vellum-ai/1.3.3",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.3.2",
+            "X-Fern-SDK-Version": "1.3.3",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

{vellum_ai-1.3.2 → vellum_ai-1.3.3}/src/vellum/workflows/emitters/vellum_emitter.py

@@ -1,5 +1,6 @@
 import logging
-from typing import Optional
+import threading
+from typing import List, Optional
 
 from vellum.core.request_options import RequestOptions
 from vellum.workflows.emitters.base import BaseWorkflowEmitter
@@ -29,6 +30,7 @@ class VellumEmitter(BaseWorkflowEmitter):
         *,
         timeout: Optional[float] = 30.0,
         max_retries: int = 3,
+        debounce_timeout: float = 0.1,
     ):
         """
         Initialize the VellumEmitter.
@@ -36,14 +38,19 @@ class VellumEmitter(BaseWorkflowEmitter):
         Args:
             timeout: Request timeout in seconds.
             max_retries: Maximum number of retry attempts for failed requests.
+            debounce_timeout: Time in seconds to wait before sending batched events.
         """
         super().__init__()
         self._timeout = timeout
         self._max_retries = max_retries
+        self._debounce_timeout = debounce_timeout
+        self._event_queue: List[SDKWorkflowEvent] = []
+        self._queue_lock = threading.Lock()
+        self._debounce_timer: Optional[threading.Timer] = None
 
     def emit_event(self, event: SDKWorkflowEvent) -> None:
         """
-        Emit a workflow event to Vellum's infrastructure.
+        Queue a workflow event for batched emission to Vellum's infrastructure.
 
         Args:
             event: The workflow event to emit.
@@ -55,10 +62,45 @@ class VellumEmitter(BaseWorkflowEmitter):
             return
 
         try:
-            self._send_event(event)
+            with self._queue_lock:
+                self._event_queue.append(event)
 
+                if self._debounce_timer:
+                    self._debounce_timer.cancel()
+
+                self._debounce_timer = threading.Timer(self._debounce_timeout, self._flush_events)
+                self._debounce_timer.start()
+
+        except Exception as e:
+            logger.exception(f"Failed to queue event {event.name}: {e}")
+
+    def _flush_events(self) -> None:
+        """
+        Send all queued events as a batch to Vellum's infrastructure.
+        """
+        with self._queue_lock:
+            if not self._event_queue:
+                return
+
+            events_to_send = self._event_queue.copy()
+            self._event_queue.clear()
+            self._debounce_timer = None
+
+        try:
+            self._send_events(events_to_send)
         except Exception as e:
-            logger.exception(f"Failed to emit event {event.name}: {e}")
+            logger.exception(f"Failed to send batched events: {e}")
+
+    def __del__(self) -> None:
+        """
+        Cleanup: flush any pending events and cancel timer.
+        """
+        try:
+            if self._debounce_timer:
+                self._debounce_timer.cancel()
+            self._flush_events()
+        except Exception:
+            pass
 
     def snapshot_state(self, state: BaseState) -> None:
         """
@@ -69,23 +111,27 @@ class VellumEmitter(BaseWorkflowEmitter):
         """
         pass
 
-    def _send_event(self, event: SDKWorkflowEvent) -> None:
+    def _send_events(self, events: List[SDKWorkflowEvent]) -> None:
         """
-        Send event to Vellum's events endpoint using client.events.create.
+        Send events to Vellum's events endpoint using client.events.create.
 
         Args:
-            event: The WorkflowEvent object to send.
+            events: List of WorkflowEvent objects to send.
         """
         if not self._context:
-            logger.warning("Cannot send event: No workflow context registered")
+            logger.warning("Cannot send events: No workflow context registered")
+            return
+
+        if not events:
             return
 
         client = self._context.vellum_client
         request_options = RequestOptions(timeout_in_seconds=self._timeout, max_retries=self._max_retries)
+
         client.events.create(
             # The API accepts a ClientWorkflowEvent but our SDK emits an SDKWorkflowEvent. These shapes are
             # meant to be identical, just with different helper methods. We may consolidate the two in the future.
             # But for now, the type ignore allows us to avoid an additional Model -> json -> Model conversion.
-            request=event,  # type: ignore[arg-type]
+            request=events,  # type: ignore[arg-type]
             request_options=request_options,
         )

{vellum_ai-1.3.2 → vellum_ai-1.3.3}/src/vellum/workflows/nodes/core/retry_node/tests/test_node.py

@@ -6,7 +6,6 @@ from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.core.retry_node.node import RetryNode
 from vellum.workflows.outputs import BaseOutputs
-from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.state.base import BaseState, StateMeta
 
 
@@ -102,7 +101,7 @@ def test_retry_node__condition_arg_successfully_retries():
     # AND a retry node that retries on a condition
     @RetryNode.wrap(
         max_attempts=5,
-        retry_on_condition=LazyReference(lambda: State.count.less_than(3)),
+        retry_on_condition=State.count.less_than(3),
     )
     class TestNode(BaseNode[State]):
         attempt_number = RetryNode.SubworkflowInputs.attempt_number

{vellum_ai-1.3.2 → vellum_ai-1.3.3}/src/vellum/workflows/nodes/displayable/tool_calling_node/utils.py

@@ -27,7 +27,6 @@ from vellum.workflows.nodes.displayable.subworkflow_deployment_node.node import
 from vellum.workflows.nodes.displayable.tool_calling_node.state import ToolCallingState
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.ports.port import Port
-from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.state import BaseState
 from vellum.workflows.state.encoder import DefaultStateEncoder
 from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior, Tool, ToolBase
@@ -421,19 +420,13 @@ def create_router_node(
         # and if the function_name is changed, the port_condition will also change.
         def create_port_condition(fn_name):
             return Port.on_if(
-                LazyReference(
-                    lambda: (
-                        ToolCallingState.current_prompt_output_index.less_than(
-                            tool_prompt_node.Outputs.results.length()
-                        )
-                        & tool_prompt_node.Outputs.results[ToolCallingState.current_prompt_output_index]["type"].equals(
-                            "FUNCTION_CALL"
-                        )
-                        & tool_prompt_node.Outputs.results[ToolCallingState.current_prompt_output_index]["value"][
-                            "name"
-                        ].equals(fn_name)
-                    )
+                ToolCallingState.current_prompt_output_index.less_than(tool_prompt_node.Outputs.results.length())
+                & tool_prompt_node.Outputs.results[ToolCallingState.current_prompt_output_index]["type"].equals(
+                    "FUNCTION_CALL"
                 )
+                & tool_prompt_node.Outputs.results[ToolCallingState.current_prompt_output_index]["value"][
+                    "name"
+                ].equals(fn_name)
             )
 
         for function in functions:

{vellum_ai-1.3.2 → vellum_ai-1.3.3}/src/vellum/workflows/state/tests/test_state.py

@@ -4,11 +4,13 @@ import json
 from queue import Queue
 from typing import Dict, List, cast
 
+from vellum.workflows.constants import undefined
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.state.delta import SetStateDelta, StateDelta
 from vellum.workflows.state.encoder import DefaultStateEncoder
+from vellum.workflows.types.code_execution_node_wrappers import DictWrapper
 
 
 @pytest.fixture()
@@ -229,3 +231,15 @@ def test_state_snapshot__deepcopy_fails__logs_error(mock_deepcopy, mock_logger):
 
     # AND alert sentry once
     assert mock_logger.exception.call_count == 1
+
+
+def test_state_deepcopy_handles_undefined_values():
+    # GIVEN a state with undefined values in node outputs
+    state = MockState(foo="bar")
+    state.meta.node_outputs[MockNode.Outputs.baz] = DictWrapper({"foo": undefined})
+
+    # WHEN we deepcopy the state
+    deepcopied_state = deepcopy(state)
+
+    # THEN the undefined values are preserved
+    assert deepcopied_state.meta.node_outputs[MockNode.Outputs.baz] == {"foo": undefined}

{vellum_ai-1.3.2 → vellum_ai-1.3.3}/src/vellum/workflows/types/code_execution_node_wrappers.py

@@ -72,6 +72,9 @@ class DictWrapper(dict):
                 # several values as VellumValue objects, we use the "value" key to return itself
                 return self
 
+            if attr.startswith("__") and attr.endswith("__"):
+                return super().__getattribute__(attr)
+
             return undefined
 
         item = super().__getitem__(attr)

{vellum_ai-1.3.2 → vellum_ai-1.3.3}/src/vellum/workflows/utils/vellum_variables.py

@@ -22,6 +22,7 @@ from vellum import (
     VellumVideo,
     VellumVideoRequest,
 )
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.types.core import Json
 
@@ -29,8 +30,16 @@ from vellum.workflows.types.core import Json
 def primitive_type_to_vellum_variable_type(type_: Union[Type, BaseDescriptor]) -> VellumVariableType:
     """Converts a python primitive to a VellumVariableType"""
     if isinstance(type_, BaseDescriptor):
-        # Ignore None because those just make types optional
-        types = [t for t in type_.types if t is not type(None)]
+        # Ignore None and undefined because those just make types optional
+        types = []
+        for t in type_.types:
+            if t is type(None):
+                continue
+            if t is undefined or t is type(undefined):
+                continue
+            if get_origin(t) is type and len(get_args(t)) == 1 and get_args(t)[0] is undefined:
+                continue
+            types.append(t)
 
         # default to JSON for typevars where the types is empty tuple
         if len(types) == 0: