vellum-ai 0.14.18__tar.gz → 0.14.19__tar.gz

{vellum_ai-0.14.18 → vellum_ai-0.14.19}/PKG-INFO

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

{vellum_ai-0.14.18 → vellum_ai-0.14.19}/ee/vellum_ee/workflows/display/nodes/base_node_display.py

@@ -129,13 +129,16 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
                 continue
 
             id = str(uuid4_from_hash(f"{node_id}|{attribute.name}"))
-            attributes.append(
-                {
-                    "id": id,
-                    "name": attribute.name,
-                    "value": self.serialize_value(display_context, cast(BaseDescriptor, attribute.instance)),
-                }
-            )
+            try:
+                attributes.append(
+                    {
+                        "id": id,
+                        "name": attribute.name,
+                        "value": self.serialize_value(display_context, attribute.instance),
+                    }
+                )
+            except ValueError as e:
+                raise ValueError(f"Failed to serialize attribute '{attribute.name}': {e}")
 
         adornments = kwargs.get("adornments", None)
         wrapped_node = get_wrapped_node(node)
@@ -369,7 +372,7 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
                 "rhs": rhs,
             }
 
-    def serialize_value(self, display_context: "WorkflowDisplayContext", value: BaseDescriptor) -> JsonObject:
+    def serialize_value(self, display_context: "WorkflowDisplayContext", value: Any) -> JsonObject:
         if isinstance(value, ConstantValueReference):
             return self.serialize_value(display_context, value._value)
 
@@ -415,6 +418,9 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
                 "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 {

{vellum_ai-0.14.18 → vellum_ai-0.14.19}/ee/vellum_ee/workflows/display/nodes/vellum/code_execution_node.py

@@ -15,9 +15,6 @@ _CodeExecutionNodeType = TypeVar("_CodeExecutionNodeType", bound=CodeExecutionNo
 
 
 class BaseCodeExecutionNodeDisplay(BaseNodeVellumDisplay[_CodeExecutionNodeType], Generic[_CodeExecutionNodeType]):
-    code_input_id: ClassVar[Optional[UUID]] = None
-    runtime_input_id: ClassVar[Optional[UUID]] = None
-
     output_id: ClassVar[Optional[UUID]] = None
     log_output_id: ClassVar[Optional[UUID]] = None
 
@@ -52,19 +49,22 @@ class BaseCodeExecutionNodeDisplay(BaseNodeVellumDisplay[_CodeExecutionNodeType]
             for variable_name, variable_value in code_inputs.items()
         ]
 
+        code_input_id = self.node_input_ids_by_name.get(CodeExecutionNode.code.name)
         code_node_input = create_node_input(
             node_id=node_id,
             input_name="code",
             value=code_value,
             display_context=display_context,
-            input_id=self.code_input_id,
+            input_id=code_input_id,
         )
+
+        runtime_input_id = self.node_input_ids_by_name.get(CodeExecutionNode.runtime.name)
         runtime_node_input = create_node_input(
             node_id=node_id,
             input_name="runtime",
             value=node.runtime,
             display_context=display_context,
-            input_id=self.runtime_input_id,
+            input_id=runtime_input_id,
         )
         inputs.extend([code_node_input, runtime_node_input])
 
@@ -84,8 +84,8 @@ class BaseCodeExecutionNodeDisplay(BaseNodeVellumDisplay[_CodeExecutionNodeType]
                 "error_output_id": str(error_output_id) if error_output_id else None,
                 "source_handle_id": str(self.get_source_handle_id(display_context.port_displays)),
                 "target_handle_id": str(self.get_target_handle_id()),
-                "code_input_id": str(self.code_input_id) if self.code_input_id else code_node_input.id,
-                "runtime_input_id": str(self.runtime_input_id) if self.runtime_input_id else runtime_node_input.id,
+                "code_input_id": code_node_input.id,
+                "runtime_input_id": runtime_node_input.id,
                 "output_type": output_type,
                 "packages": [package.dict() for package in packages] if packages is not None else [],
                 "output_id": str(self.output_id) if self.output_id else str(output_display.id),

{vellum_ai-0.14.18 → vellum_ai-0.14.19}/ee/vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_attributes_serialization.py

@@ -1,12 +1,16 @@
+import pytest
 from uuid import uuid4
+from typing import List
 
 from deepdiff import DeepDiff
 
+from vellum.client.types.chat_message import ChatMessage
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.references.constant import ConstantValueReference
 from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.references.vellum_secret import VellumSecretReference
+from vellum.workflows.state.base import BaseState
 from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_ee.workflows.display.base import WorkflowInputsDisplay
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
@@ -237,6 +241,33 @@ def test_serialize_node__workflow_input(serialize_node):
     )
 
 
+def test_serialize_node__workflow_input_as_nested_chat_history():
+    # GIVEN workflow inputs as chat history
+    class Inputs(BaseInputs):
+        chat_history: List[ChatMessage]
+
+    # AND a node referencing the workflow input
+    class GenericNode(BaseNode):
+        attr = {
+            "hello": Inputs.chat_history,
+        }
+
+    # AND a workflow with the node
+    class Workflow(BaseWorkflow[Inputs, BaseState]):
+        graph = GenericNode
+
+    # WHEN the workflow is serialized
+    workflow_display = get_workflow_display(
+        base_display_class=VellumWorkflowDisplay,
+        workflow_class=Workflow,
+    )
+    with pytest.raises(Exception) as exc_info:
+        workflow_display.serialize()
+
+    # THEN we should raise a user facing error
+    assert str(exc_info.value) == "Failed to serialize attribute 'attr': Nested references are not supported."
+
+
 def test_serialize_node__node_output(serialize_node):
     class NodeWithOutput(BaseNode):
         class Outputs(BaseNode.Outputs):

{vellum_ai-0.14.18 → vellum_ai-0.14.19}/pyproject.toml

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

{vellum_ai-0.14.18 → vellum_ai-0.14.19}/src/vellum/__init__.py

@@ -229,6 +229,7 @@ from .types import (
     NodeInputCompiledJsonValue,
     NodeInputCompiledNumberValue,
     NodeInputCompiledSearchResultsValue,
+    NodeInputCompiledSecretValue,
     NodeInputCompiledStringValue,
     NodeInputVariableCompiledValue,
     NodeOutputCompiledArrayValue,
@@ -777,6 +778,7 @@ __all__ = [
     "NodeInputCompiledJsonValue",
     "NodeInputCompiledNumberValue",
     "NodeInputCompiledSearchResultsValue",
+    "NodeInputCompiledSecretValue",
     "NodeInputCompiledStringValue",
     "NodeInputVariableCompiledValue",
     "NodeOutputCompiledArrayValue",

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

{vellum_ai-0.14.18 → vellum_ai-0.14.19}/src/vellum/client/types/__init__.py

@@ -237,6 +237,7 @@ from .node_input_compiled_function_call_value import NodeInputCompiledFunctionCa
 from .node_input_compiled_json_value import NodeInputCompiledJsonValue
 from .node_input_compiled_number_value import NodeInputCompiledNumberValue
 from .node_input_compiled_search_results_value import NodeInputCompiledSearchResultsValue
+from .node_input_compiled_secret_value import NodeInputCompiledSecretValue
 from .node_input_compiled_string_value import NodeInputCompiledStringValue
 from .node_input_variable_compiled_value import NodeInputVariableCompiledValue
 from .node_output_compiled_array_value import NodeOutputCompiledArrayValue
@@ -759,6 +760,7 @@ __all__ = [
     "NodeInputCompiledJsonValue",
     "NodeInputCompiledNumberValue",
     "NodeInputCompiledSearchResultsValue",
+    "NodeInputCompiledSecretValue",
     "NodeInputCompiledStringValue",
     "NodeInputVariableCompiledValue",
     "NodeOutputCompiledArrayValue",

vellum_ai-0.14.19/src/vellum/client/types/node_input_compiled_secret_value.py

@@ -0,0 +1,23 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+from .vellum_secret import VellumSecret
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
+
+
+class NodeInputCompiledSecretValue(UniversalBaseModel):
+    node_input_id: str
+    key: str
+    type: typing.Literal["SECRET"] = "SECRET"
+    value: VellumSecret
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

{vellum_ai-0.14.18 → vellum_ai-0.14.19}/src/vellum/client/types/node_input_variable_compiled_value.py

@@ -9,6 +9,7 @@ from .node_input_compiled_search_results_value import NodeInputCompiledSearchRes
 from .node_input_compiled_error_value import NodeInputCompiledErrorValue
 from .node_input_compiled_array_value import NodeInputCompiledArrayValue
 from .node_input_compiled_function_call_value import NodeInputCompiledFunctionCallValue
+from .node_input_compiled_secret_value import NodeInputCompiledSecretValue
 
 NodeInputVariableCompiledValue = typing.Union[
     NodeInputCompiledStringValue,
@@ -19,4 +20,5 @@ NodeInputVariableCompiledValue = typing.Union[
     NodeInputCompiledErrorValue,
     NodeInputCompiledArrayValue,
     NodeInputCompiledFunctionCallValue,
+    NodeInputCompiledSecretValue,
 ]

vellum_ai-0.14.19/src/vellum/types/node_input_compiled_secret_value.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.node_input_compiled_secret_value import *

{vellum_ai-0.14.18 → vellum_ai-0.14.19}/src/vellum/workflows/nodes/core/inline_subworkflow_node/node.py

@@ -4,7 +4,7 @@ from vellum.workflows.constants import undefined
 from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.events.workflow import is_workflow_event
-from vellum.workflows.exceptions import NodeException
+from vellum.workflows.exceptions import NodeException, WorkflowInitializationException
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode, BaseNodeMeta
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
@@ -119,19 +119,21 @@ class InlineSubworkflowNode(
 
     def _compile_subworkflow_inputs(self) -> InputsType:
         inputs_class = self.subworkflow.get_inputs_class()
-        if self.subworkflow_inputs is undefined:
-            inputs_dict = {}
-            for descriptor in inputs_class:
-                if hasattr(self, descriptor.name):
-                    inputs_dict[descriptor.name] = getattr(self, descriptor.name)
-
-            return inputs_class(**inputs_dict)
-        elif isinstance(self.subworkflow_inputs, dict):
-            return inputs_class(**self.subworkflow_inputs)
-        elif isinstance(self.subworkflow_inputs, inputs_class):
-            return self.subworkflow_inputs
-        else:
-            raise ValueError(f"Invalid subworkflow inputs type: {type(self.subworkflow_inputs)}")
+        try:
+            if self.subworkflow_inputs is undefined:
+                inputs_dict = {}
+                for descriptor in inputs_class:
+                    if hasattr(self, descriptor.name):
+                        inputs_dict[descriptor.name] = getattr(self, descriptor.name)
+                return inputs_class(**inputs_dict)
+            elif isinstance(self.subworkflow_inputs, dict):
+                return inputs_class(**self.subworkflow_inputs)
+            elif isinstance(self.subworkflow_inputs, inputs_class):
+                return self.subworkflow_inputs
+            else:
+                raise ValueError(f"Invalid subworkflow inputs type: {type(self.subworkflow_inputs)}")
+        except WorkflowInitializationException as e:
+            raise NodeException(message=str(e), code=e.code)
 
     @classmethod
     def __annotate_outputs_class__(cls, outputs_class: Type[BaseOutputs], reference: OutputReference) -> None:

{vellum_ai-0.14.18 → vellum_ai-0.14.19}/src/vellum/workflows/nodes/core/inline_subworkflow_node/tests/test_node.py

@@ -1,5 +1,7 @@
 import pytest
 
+from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.core.inline_subworkflow_node.node import InlineSubworkflowNode
@@ -87,3 +89,30 @@ def test_inline_subworkflow_node__nested_try():
     # THEN we only have the outer node's outputs
     valid_events = [e for e in events if e.name == "bar"]
     assert len(valid_events) == len(events)
+
+
+def test_inline_subworkflow_node__base_inputs_validation():
+    """Test that InlineSubworkflowNode properly validates required inputs"""
+
+    # GIVEN a real subworkflow class with a required input
+    class SubworkflowInputs(BaseInputs):
+        required_input: str  # This is a required field without a default
+
+    class TestSubworkflow(BaseWorkflow[SubworkflowInputs, BaseState]):
+        pass
+
+    # AND a node that uses this subworkflow
+    class TestNode(InlineSubworkflowNode):
+        subworkflow = TestSubworkflow
+        subworkflow_inputs = {"required_input": None}
+
+    # WHEN we try to run the node
+    node = TestNode()
+
+    # THEN it should raise a NodeException
+    with pytest.raises(NodeException) as e:
+        list(node.run())
+
+    # AND the error message should indicate the missing required input
+    assert e.value.code == WorkflowErrorCode.INVALID_INPUTS
+    assert "Required input variables required_input should have defined value" == str(e.value)