vellum-ai 0.14.27__tar.gz → 0.14.29__tar.gz

{vellum_ai-0.14.27 → vellum_ai-0.14.29}/PKG-INFO

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

{vellum_ai-0.14.27 → vellum_ai-0.14.29}/ee/vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py

@@ -94,7 +94,8 @@ class BaseInlinePromptNodeDisplay(BaseNodeVellumDisplay[_InlinePromptNodeType],
                 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"{InlinePromptNode.prompt_inputs.name}.{variable_name}")
+                or self.node_input_ids_by_name.get(variable_name),
             )
             vellum_variable_type = infer_vellum_variable_type(variable_value)
             node_inputs.append(node_input)

vellum_ai-0.14.29/ee/vellum_ee/workflows/display/nodes/vellum/tests/test_prompt_node.py

@@ -0,0 +1,131 @@
+import pytest
+from uuid import UUID
+from typing import Type
+
+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.references.lazy import LazyReference
+from vellum_ee.workflows.display.nodes.vellum.inline_prompt_node import BaseInlinePromptNodeDisplay
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+from vellum_ee.workflows.display.workflows.vellum_workflow_display import VellumWorkflowDisplay
+
+
+def test_serialize_node__lazy_reference_in_prompt_inputs():
+    # GIVEN a prompt node with a lazy reference in the prompt inputs
+    class LazyReferencePromptNode(InlinePromptNode):
+        prompt_inputs = {"attr": LazyReference[str]("OtherNode.Outputs.result")}
+        blocks = []
+        ml_model = "gpt-4o"
+
+    class OtherNode(BaseNode):
+        class Outputs:
+            result: str
+
+    # AND a workflow with both nodes
+    class Workflow(BaseWorkflow):
+        graph = LazyReferencePromptNode >> OtherNode
+
+    # WHEN the workflow is serialized
+    workflow_display = get_workflow_display(base_display_class=VellumWorkflowDisplay, workflow_class=Workflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the node should properly serialize the attribute reference
+    lazy_reference_node = next(
+        node
+        for node in serialized_workflow["workflow_raw_data"]["nodes"]
+        if node["id"] == str(LazyReferencePromptNode.__id__)
+    )
+
+    assert lazy_reference_node["inputs"] == [
+        {
+            "id": "aa81c1bc-d5d8-4ae8-8946-e9f4d0c1ab5f",
+            "key": "attr",
+            "value": {
+                "combinator": "OR",
+                "rules": [
+                    {
+                        "type": "NODE_OUTPUT",
+                        "data": {
+                            "node_id": str(OtherNode.__id__),
+                            "output_id": "7f377cb8-4eca-4f1c-9239-9925f9495d84",
+                        },
+                    }
+                ],
+            },
+        }
+    ]
+
+
+def _no_display_class(Node: Type[InlinePromptNode]):
+    return None
+
+
+def _display_class_with_node_input_ids_by_name(Node: Type[InlinePromptNode]):
+    class PromptNodeDisplay(BaseInlinePromptNodeDisplay[Node]):  # type: ignore[valid-type]
+        node_input_ids_by_name = {"foo": UUID("fba6a4d5-835a-4e99-afb7-f6a4aed15110")}
+
+    return PromptNodeDisplay
+
+
+def _display_class_with_node_input_ids_by_name_with_inputs_prefix(Node: Type[InlinePromptNode]):
+    class PromptNodeDisplay(BaseInlinePromptNodeDisplay[Node]):  # type: ignore[valid-type]
+        node_input_ids_by_name = {"prompt_inputs.foo": UUID("fba6a4d5-835a-4e99-afb7-f6a4aed15110")}
+
+    return PromptNodeDisplay
+
+
+@pytest.mark.parametrize(
+    ["GetDisplayClass", "expected_input_id"],
+    [
+        (_no_display_class, "8aa4ce7f-5eb8-41b7-abd0-ea2b40c8fb88"),
+        (_display_class_with_node_input_ids_by_name, "fba6a4d5-835a-4e99-afb7-f6a4aed15110"),
+        (_display_class_with_node_input_ids_by_name_with_inputs_prefix, "fba6a4d5-835a-4e99-afb7-f6a4aed15110"),
+    ],
+    ids=[
+        "no_display_class",
+        "display_class_with_node_input_ids_by_name",
+        "display_class_with_node_input_ids_by_name_with_inputs_prefix",
+    ],
+)
+def test_serialize_node__prompt_inputs(GetDisplayClass, expected_input_id):
+    # GIVEN a prompt node with inputs
+    class MyPromptNode(InlinePromptNode):
+        prompt_inputs = {"foo": "bar"}
+        blocks = []
+        ml_model = "gpt-4o"
+
+    # AND a workflow with the prompt node
+    class Workflow(BaseWorkflow):
+        graph = MyPromptNode
+
+    # AND a display class
+    GetDisplayClass(MyPromptNode)
+
+    # WHEN the workflow is serialized
+    workflow_display = get_workflow_display(base_display_class=VellumWorkflowDisplay, workflow_class=Workflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the node should properly serialize the inputs
+    my_prompt_node = next(
+        node for node in serialized_workflow["workflow_raw_data"]["nodes"] if node["id"] == str(MyPromptNode.__id__)
+    )
+
+    assert my_prompt_node["inputs"] == [
+        {
+            "id": expected_input_id,
+            "key": "foo",
+            "value": {
+                "rules": [
+                    {
+                        "type": "CONSTANT_VALUE",
+                        "data": {
+                            "type": "STRING",
+                            "value": "bar",
+                        },
+                    }
+                ],
+                "combinator": "OR",
+            },
+        }
+    ]

{vellum_ai-0.14.27 → vellum_ai-0.14.29}/ee/vellum_ee/workflows/server/virtual_file_loader.py

@@ -1,5 +1,7 @@
 import importlib
+from importlib.machinery import ModuleSpec
 import re
+import sys
 from typing import Optional
 
 
@@ -8,11 +10,20 @@ class VirtualFileLoader(importlib.abc.Loader):
         self.files = files
         self.namespace = namespace
 
-    def create_module(self, spec):
-        return None  # use default module creation
+    def create_module(self, spec: ModuleSpec):
+        """
+        We started with cpython/Lib/importlib/_bootstrap.py::FrozenImporter::create_module here
+
+        https://github.com/python/cpython/blob/053c285f6b41f92fbdd1d4ff0c959cceefacd7cd/Lib/importlib/_bootstrap.py#L1160C1-L1169C22
+
+        and reduced our needs to just updating the __file__ attribute directly.
+        """
+        module = type(sys)(spec.name)
+        module.__file__ = spec.origin
+        return module
 
     def exec_module(self, module):
-        module_info = self._resolve_module(module.__spec__.origin)
+        module_info = self._resolve_module(module.__spec__.name)
 
         if module_info:
             file_path, code = module_info
@@ -66,7 +77,8 @@ class VirtualFileFinder(importlib.abc.MetaPathFinder, importlib.abc.Loader):
             return importlib.machinery.ModuleSpec(
                 fullname,
                 self.loader,
-                origin=fullname,
+                origin=file_path,
                 is_package=is_package,
             )
+
         return None

{vellum_ai-0.14.27 → vellum_ai-0.14.29}/ee/vellum_ee/workflows/tests/test_server.py

@@ -4,11 +4,18 @@ from uuid import uuid4
 from typing import Type, cast
 
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
+from vellum.client.types.code_executor_response import CodeExecutorResponse
+from vellum.client.types.number_vellum_value import NumberVellumValue
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.nodes import BaseNode
 from vellum_ee.workflows.server.virtual_file_loader import VirtualFileFinder
 
 
+@pytest.fixture
+def mock_open(mocker):
+    return mocker.patch("vellum.workflows.nodes.displayable.code_execution_node.utils.open")
+
+
 def test_load_workflow_event_display_context():
     # DEPRECATED: Use `vellum.workflows.events.workflow.WorkflowEventDisplayContext` instead. Will be removed in 0.15.0
     from vellum_ee.workflows.display.types import WorkflowEventDisplayContext
@@ -72,9 +79,16 @@ class StartNode(BaseNode):
     assert start_node.foo.instance.name == "StartNode.Outputs.bar"
 
 
-@pytest.mark.skip(reason="Code execution inspect and get read file from path needs to be fixed")
-def test_load_from_module__ts_code_in_file_loader():
-    # GIVEN a workflow module with only a code execution node
+def test_load_from_module__ts_code_in_file_loader(
+    mock_open,
+    vellum_client,
+):
+    # GIVEN typescript code
+    ts_code = """async function main(): any {
+  return 5;
+}"""
+
+    # AND a workflow module with only a code execution node
     files = {
         "__init__.py": "",
         "workflow.py": """\
@@ -95,18 +109,13 @@ from typing import Any
 from vellum.workflows.nodes.displayable import CodeExecutionNode as BaseCodeExecutionNode
 from vellum.workflows.state import BaseState
 
-class CodeExecutionNode(BaseCodeExecutionNode[BaseState, Any]):
+class CodeExecutionNode(BaseCodeExecutionNode[BaseState, int]):
     filepath = "./script.ts"
     code_inputs = {}
     runtime = "TYPESCRIPT_5_3_3"
     packages = []
 """,
-        "nodes/code_execution_node/script.ts": """async function main(inputs: {
-  text: string,
-}): any {
-  const matches = inputs.text.match(/\\((.+?)\\)/gs);
-  return matches;
-}""",
+        "nodes/code_execution_node/script.ts": ts_code,
     }
 
     namespace = str(uuid4())
@@ -114,6 +123,16 @@ class CodeExecutionNode(BaseCodeExecutionNode[BaseState, Any]):
     # AND the virtual file loader is registered
     sys.meta_path.append(VirtualFileFinder(files, namespace))
 
+    # AND the open function returns our file content
+    mock_open.return_value.__enter__.return_value.read.return_value = ts_code
+
+    # AND we know what the Code Execution Node will respond with
+    mock_code_execution = CodeExecutorResponse(
+        log="hello",
+        output=NumberVellumValue(value=5),
+    )
+    vellum_client.execute_code.return_value = mock_code_execution
+
     # WHEN the workflow is loaded
     Workflow = BaseWorkflow.load_from_module(namespace)
     workflow = Workflow()
@@ -122,4 +141,10 @@ class CodeExecutionNode(BaseCodeExecutionNode[BaseState, Any]):
     assert workflow
 
     event = workflow.run()
-    assert event.name == "workflow.execution.fulfilled"
+    assert event.name == "workflow.execution.fulfilled", event.model_dump_json()
+
+    # AND we pass in the correct file path to the open function
+    assert mock_open.call_args[0][0] == f"{namespace}/nodes/./script.ts"
+
+    # AND we invoke the Code Execution Node with the correct code
+    assert vellum_client.execute_code.call_args.kwargs["code"] == ts_code

{vellum_ai-0.14.27 → vellum_ai-0.14.29}/pyproject.toml

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

{vellum_ai-0.14.27 → vellum_ai-0.14.29}/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.27",
+            "X-Fern-SDK-Version": "0.14.29",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

{vellum_ai-0.14.27 → vellum_ai-0.14.29}/src/vellum/client/core/jsonable_encoder.py

@@ -45,7 +45,7 @@ def jsonable_encoder(obj: Any, custom_encoder: Optional[Dict[Any, Callable[[Any]
             encoder = getattr(obj.__config__, "json_encoders", {})  # type: ignore # Pydantic v1
         if custom_encoder:
             encoder.update(custom_encoder)
-        obj_dict = obj.model_dump(mode="json")
+        obj_dict = obj.dict(by_alias=True)
         if "__root__" in obj_dict:
             obj_dict = obj_dict["__root__"]
         if "root" in obj_dict:

{vellum_ai-0.14.27 → vellum_ai-0.14.29}/src/vellum/client/resources/documents/client.py

@@ -277,13 +277,6 @@ class DocumentsClient:
 
         **Note:** Uses a base url of `https://documents.vellum.ai`.
 
-        This is a multipart/form-data request. The `contents` field should be a file upload. It also expects a JSON body with the following fields:
-        - `add_to_index_names: list[str]` - Optionally include the names of all indexes that you'd like this document to be included in
-        - `external_id: str | None` - Optionally include an external ID for this document. This is useful if you want to re-upload the same document later when its contents change and would like it to be re-indexed.
-        - `label: str` - A human-friendly name for this document. Typically the filename.
-        - `keywords: list[str] | None` - Optionally include a list of keywords that'll be associated with this document. Used when performing keyword searches.
-        - `metadata: dict[str, Any]` - A stringified JSON object containing any metadata associated with the document that you'd like to filter upon later.
-
         Parameters
         ----------
         label : str
@@ -673,13 +666,6 @@ class AsyncDocumentsClient:
 
         **Note:** Uses a base url of `https://documents.vellum.ai`.
 
-        This is a multipart/form-data request. The `contents` field should be a file upload. It also expects a JSON body with the following fields:
-        - `add_to_index_names: list[str]` - Optionally include the names of all indexes that you'd like this document to be included in
-        - `external_id: str | None` - Optionally include an external ID for this document. This is useful if you want to re-upload the same document later when its contents change and would like it to be re-indexed.
-        - `label: str` - A human-friendly name for this document. Typically the filename.
-        - `keywords: list[str] | None` - Optionally include a list of keywords that'll be associated with this document. Used when performing keyword searches.
-        - `metadata: dict[str, Any]` - A stringified JSON object containing any metadata associated with the document that you'd like to filter upon later.
-
         Parameters
         ----------
         label : str

{vellum_ai-0.14.27 → vellum_ai-0.14.29}/src/vellum/workflows/context.py

@@ -1,4 +1,5 @@
 from contextlib import contextmanager
+from dataclasses import field
 import threading
 from uuid import UUID
 from typing import Iterator, Optional, cast
@@ -8,8 +9,8 @@ from vellum.workflows.events.types import ParentContext
 
 
 class ExecutionContext(UniversalBaseModel):
+    trace_id: UUID = field(default_factory=lambda: UUID("00000000-0000-0000-0000-000000000000"))
     parent_context: Optional[ParentContext] = None
-    trace_id: Optional[UUID] = None
 
 
 _CONTEXT_KEY = "_execution_context"
@@ -37,7 +38,11 @@ def execution_context(
 ) -> Iterator[None]:
     """Context manager for handling execution context."""
     prev_context = get_execution_context()
-    set_trace_id = prev_context.trace_id or trace_id
+    set_trace_id = (
+        prev_context.trace_id
+        if int(prev_context.trace_id)
+        else trace_id or UUID("00000000-0000-0000-0000-000000000000")
+    )
     set_parent_context = parent_context or prev_context.parent_context
     set_context = ExecutionContext(parent_context=set_parent_context, trace_id=set_trace_id)
     try:

{vellum_ai-0.14.27 → vellum_ai-0.14.29}/src/vellum/workflows/events/tests/test_event.py

@@ -4,6 +4,7 @@ from uuid import UUID
 
 from deepdiff import DeepDiff
 
+from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.constants import undefined
 from vellum.workflows.errors.types import WorkflowError, WorkflowErrorCode
 from vellum.workflows.events.node import (
@@ -14,7 +15,7 @@ from vellum.workflows.events.node import (
     NodeExecutionStreamingBody,
     NodeExecutionStreamingEvent,
 )
-from vellum.workflows.events.types import NodeParentContext, WorkflowParentContext
+from vellum.workflows.events.types import NodeParentContext, ParentContext, WorkflowParentContext
 from vellum.workflows.events.workflow import (
     WorkflowExecutionFulfilledBody,
     WorkflowExecutionFulfilledEvent,
@@ -419,3 +420,30 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
 )
 def test_event_serialization(event, expected_json):
     assert not DeepDiff(event.model_dump(mode="json"), expected_json)
+
+
+def test_parent_context__deserialize_from_json__invalid_parent_context():
+    # GIVEN an event with a parent context that Vellum is introducing in the future
+    data = {
+        "foo": "bar",
+        "parent": {
+            "type": "SOME_FUTURE_ENTITY",
+            "span_id": "123e4567-e89b-12d3-a456-426614174000",
+            "some_randome_field": "some_random_value",
+            "parent": None,
+        },
+    }
+
+    # AND a dataclass that references the parent context
+    class MyData(UniversalBaseModel):
+        foo: str
+        parent: ParentContext
+
+    # WHEN the data is deserialized
+    event = MyData.model_validate(data)
+
+    # THEN the event is deserialized correctly
+    assert event.parent
+    assert event.parent.type == "UNKNOWN"
+    assert event.parent.span_id == UUID("123e4567-e89b-12d3-a456-426614174000")
+    assert event.parent.parent is None

{vellum_ai-0.14.27 → vellum_ai-0.14.29}/src/vellum/workflows/events/types.py

@@ -1,9 +1,10 @@
 from datetime import datetime
 import json
 from uuid import UUID, uuid4
-from typing import Annotated, Any, Dict, List, Literal, Optional, Union
+from typing import Annotated, Any, Dict, List, Literal, Optional, Union, get_args
 
-from pydantic import BeforeValidator, Field
+from pydantic import BeforeValidator, Field, GetCoreSchemaHandler, Tag, ValidationInfo
+from pydantic_core import CoreSchema, core_schema
 
 from vellum.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.state.encoder import DefaultStateEncoder
@@ -112,6 +113,59 @@ class APIRequestParentContext(BaseParentContext):
     type: Literal["API_REQUEST"] = "API_REQUEST"
 
 
+class UnknownParentContext(BaseParentContext):
+    type: Literal["UNKNOWN"] = "UNKNOWN"
+
+
+def _cast_parent_context_discriminator(v: Any) -> Any:
+    if v in PARENT_CONTEXT_TYPES:
+        return v
+
+    return "UNKNOWN"
+
+
+def _get_parent_context_discriminator(v: Any) -> Any:
+    if isinstance(v, dict) and "type" in v:
+        return _cast_parent_context_discriminator(v["type"])
+
+    if isinstance(v, PARENT_CONTEXT_CHOICES):
+        return v.type
+
+    return _cast_parent_context_discriminator(v)
+
+
+def _tag_parent_context_discriminator(v: Any) -> Any:
+    return Tag(_get_parent_context_discriminator(v))
+
+
+def _validate_parent_context_discriminator(v: Any, info: ValidationInfo) -> Any:
+    if isinstance(v, str):
+        return _get_parent_context_discriminator(v)
+
+    if isinstance(v, dict) and "type" in v:
+        v["type"] = _get_parent_context_discriminator(v["type"])
+
+    return v
+
+
+class ParentContextDiscriminator:
+    def __get_pydantic_core_schema__(self, source_type: Any, handler: GetCoreSchemaHandler) -> CoreSchema:
+        original_schema = handler(source_type)
+        tagged_union_choices = {}
+        for index, choice in enumerate(original_schema["choices"]):
+            tagged_union_choices[Tag(PARENT_CONTEXT_TYPES[index])] = choice
+
+        tagged_union_schema = core_schema.tagged_union_schema(
+            tagged_union_choices,
+            _tag_parent_context_discriminator,
+        )
+        return core_schema.with_info_before_validator_function(
+            function=_validate_parent_context_discriminator,
+            schema=tagged_union_schema,
+            field_name="type",
+        )
+
+
 # Define the discriminated union
 ParentContext = Annotated[
     Union[
@@ -121,8 +175,13 @@ ParentContext = Annotated[
         PromptDeploymentParentContext,
         WorkflowSandboxParentContext,
         APIRequestParentContext,
+        UnknownParentContext,
     ],
-    Field(discriminator="type"),
+    ParentContextDiscriminator(),
+]
+PARENT_CONTEXT_CHOICES = get_args(get_args(ParentContext)[0])
+PARENT_CONTEXT_TYPES = [
+    pc.model_fields["type"].default for pc in PARENT_CONTEXT_CHOICES if issubclass(pc, UniversalBaseModel)
 ]
 
 # Update the forward references

{vellum_ai-0.14.27 → vellum_ai-0.14.29}/src/vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py

@@ -140,8 +140,10 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
                         value=input_value,
                     )
                 )
-            elif isinstance(input_value, list) and all(
-                isinstance(message, (ChatMessage, ChatMessageRequest)) for message in input_value
+            elif (
+                input_value
+                and isinstance(input_value, list)
+                and all(isinstance(message, (ChatMessage, ChatMessageRequest)) for message in input_value)
             ):
                 chat_history = [
                     message if isinstance(message, ChatMessage) else ChatMessage.model_validate(message.model_dump())

{vellum_ai-0.14.27 → vellum_ai-0.14.29}/src/vellum/workflows/nodes/displayable/bases/prompt_deployment_node.py

@@ -91,8 +91,10 @@ class BasePromptDeploymentNode(BasePromptNode, Generic[StateType]):
                         value=input_value,
                     )
                 )
-            elif isinstance(input_value, list) and all(
-                isinstance(message, (ChatMessage, ChatMessageRequest)) for message in input_value
+            elif (
+                input_value
+                and isinstance(input_value, list)
+                and all(isinstance(message, (ChatMessage, ChatMessageRequest)) for message in input_value)
             ):
                 chat_history = [
                     (

{vellum_ai-0.14.27 → vellum_ai-0.14.29}/src/vellum/workflows/nodes/displayable/code_execution_node/utils.py

@@ -14,10 +14,11 @@ def read_file_from_path(node_filepath: str, script_filepath: str) -> Union[str,
     node_filepath_dir = os.path.dirname(node_filepath)
     full_filepath = os.path.join(node_filepath_dir, script_filepath)
 
-    if os.path.isfile(full_filepath):
+    try:
         with open(full_filepath) as file:
             return file.read()
-    return None
+    except (FileNotFoundError, IsADirectoryError):
+        return None
 
 
 class ListWrapper(list):

{vellum_ai-0.14.27 → vellum_ai-0.14.29}/src/vellum/workflows/nodes/displayable/inline_prompt_node/tests/test_node.py

@@ -9,6 +9,7 @@ from httpx import Response
 from vellum.client.core.api_error import ApiError
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.client.types.chat_message import ChatMessage
+from vellum.client.types.chat_message_prompt_block import ChatMessagePromptBlock
 from vellum.client.types.chat_message_request import ChatMessageRequest
 from vellum.client.types.execute_prompt_event import ExecutePromptEvent
 from vellum.client.types.fulfilled_execute_prompt_event import FulfilledExecutePromptEvent
@@ -43,6 +44,7 @@ def test_inline_prompt_node__json_inputs(vellum_adhoc_prompt_client):
             "a_list": [1, 2, 3],
             "a_dataclass": MyDataClass(hello="world"),
             "a_pydantic": MyPydantic(example="example"),
+            "an_empty_list": [],
         }
 
     # AND a known response from invoking an inline prompt
@@ -74,8 +76,9 @@ def test_inline_prompt_node__json_inputs(vellum_adhoc_prompt_client):
         PromptRequestJsonInput(key="a_list", type="JSON", value=[1, 2, 3]),
         PromptRequestJsonInput(key="a_dataclass", type="JSON", value={"hello": "world"}),
         PromptRequestJsonInput(key="a_pydantic", type="JSON", value={"example": "example"}),
+        PromptRequestJsonInput(key="an_empty_list", type="JSON", value=[]),
     ]
-    assert len(mock_api.call_args.kwargs["input_variables"]) == 4
+    assert len(mock_api.call_args.kwargs["input_variables"]) == 5
 
 
 def test_inline_prompt_node__function_definitions(vellum_adhoc_prompt_client):
@@ -241,7 +244,7 @@ def test_inline_prompt_node__parent_context(mock_httpx_transport, mock_complex_p
     # GIVEN a prompt node
     class MyNode(InlinePromptNode):
         ml_model = "gpt-4o"
-        blocks = []
+        blocks = [ChatMessagePromptBlock(chat_role="USER", blocks=[])]
         prompt_inputs = {}
 
     # AND a known response from the httpx client
@@ -276,6 +279,16 @@ def test_inline_prompt_node__parent_context(mock_httpx_transport, mock_complex_p
 
     # AND the prompt is executed with the correct execution context
     call_request_args = mock_httpx_transport.handle_request.call_args_list[0][0][0]
-    request_execution_context = json.loads(call_request_args.read().decode("utf-8"))["execution_context"]
+    call_request = json.loads(call_request_args.read().decode("utf-8"))
+    request_execution_context = call_request["execution_context"]
     assert request_execution_context["trace_id"] == str(trace_id)
     assert request_execution_context["parent_context"]
+
+    # AND the blocks are serialized as expected
+    assert call_request["blocks"] == [
+        {
+            "block_type": "CHAT_MESSAGE",
+            "chat_role": "USER",
+            "blocks": [],
+        }
+    ]

{vellum_ai-0.14.27 → vellum_ai-0.14.29}/src/vellum/workflows/nodes/displayable/prompt_deployment_node/tests/test_node.py

@@ -61,14 +61,22 @@ def test_run_node__chat_history_input(vellum_client, ChatMessageClass):
     ]
 
 
-def test_run_node__any_array_input(vellum_client):
+@pytest.mark.parametrize(
+    "input_value",
+    [
+        ["apple", "banana", "cherry"],
+        [],
+    ],
+    ids=["non_empty_array", "empty_array"],
+)
+def test_run_node__any_array_input(vellum_client, input_value):
     """Confirm that we can successfully invoke a Prompt Deployment Node that uses any array input"""
 
     # GIVEN a Prompt Deployment Node
     class ExamplePromptDeploymentNode(PromptDeploymentNode):
         deployment = "example_prompt_deployment"
         prompt_inputs = {
-            "fruits": ["apple", "banana", "cherry"],
+            "fruits": input_value,
         }
 
     # AND we know what the Prompt Deployment will respond with
@@ -97,7 +105,7 @@ def test_run_node__any_array_input(vellum_client):
     # AND we should have invoked the Prompt Deployment with the expected inputs
     call_kwargs = vellum_client.execute_prompt_stream.call_args.kwargs
     assert call_kwargs["inputs"] == [
-        JsonInputRequest(name="fruits", value=["apple", "banana", "cherry"]),
+        JsonInputRequest(name="fruits", value=input_value),
     ]
 
 

{vellum_ai-0.14.27 → vellum_ai-0.14.29}/src/vellum/workflows/nodes/displayable/tests/test_text_prompt_deployment_node.py

@@ -1,3 +1,4 @@
+from unittest import mock
 from uuid import uuid4
 from typing import Any, Iterator, List
 
@@ -75,6 +76,6 @@ def test_text_prompt_deployment_node__basic(vellum_client):
         raw_overrides=OMIT,
         release_tag="LATEST",
         request_options={
-            "additional_body_parameters": {"execution_context": {"parent_context": None, "trace_id": None}}
+            "additional_body_parameters": {"execution_context": {"parent_context": None, "trace_id": mock.ANY}}
         },
     )