vellum-ai 0.14.50__tar.gz → 0.14.51__tar.gz

{vellum_ai-0.14.50 → vellum_ai-0.14.51}/PKG-INFO

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

{vellum_ai-0.14.50 → vellum_ai-0.14.51}/ee/vellum_ee/workflows/display/nodes/base_node_display.py

@@ -133,6 +133,10 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
     # Used by each class extending BaseNodeDisplay to specify which attributes are meant to be serialized
     # as the former `"inputs"` field
     __serializable_inputs__: Set[NodeReference] = set()
+    # Used by each class extending BaseNodeDisplay to specify which attributes are meant to be opted out
+    # of serialization. It's possible that we keep this one as a user facing api in the future, but
+    # don't want to commit to that decision just yet
+    __unserializable_attributes__: Set[NodeReference] = set()
     # END: Attributes for backwards compatible serialization
 
     def serialize(self, display_context: "WorkflowDisplayContext", **kwargs: Any) -> JsonObject:
@@ -145,9 +149,12 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
                 # We don't need to serialize generic node attributes containing a subworkflow
                 continue
 
+            if attribute in self.__unserializable_attributes__:
+                continue
+
             id = (
                 str(self.attribute_ids_by_name[attribute.name])
-                if self.attribute_ids_by_name
+                if self.attribute_ids_by_name.get(attribute.name)
                 else str(uuid4_from_hash(f"{node_id}|{attribute.name}"))
             )
             try:

{vellum_ai-0.14.50 → vellum_ai-0.14.51}/ee/vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py

@@ -19,6 +19,14 @@ _InlinePromptNodeType = TypeVar("_InlinePromptNodeType", bound=InlinePromptNode)
 
 class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generic[_InlinePromptNodeType]):
     __serializable_inputs__ = {InlinePromptNode.prompt_inputs}
+    __unserializable_attributes__ = {
+        InlinePromptNode.blocks,
+        InlinePromptNode.functions,
+        InlinePromptNode.parameters,
+        InlinePromptNode.settings,
+        InlinePromptNode.expand_meta,
+        InlinePromptNode.request_options,
+    }
 
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
@@ -219,16 +227,25 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
         return block
 
     def _serialize_attributes(self, display_context: "WorkflowDisplayContext"):
-        attribute_instances_by_name = {}
+        attributes = []
         for attribute in self._node:
-            if attribute.name in self.attribute_ids_by_name:
-                attribute_instances_by_name[attribute.name] = attribute.instance
-
-        return [
-            {
-                "id": str(attr_id),
-                "name": attr_name,
-                "value": serialize_value(display_context, attribute_instances_by_name[attr_name]),
-            }
-            for attr_name, attr_id in self.attribute_ids_by_name.items()
-        ]
+            if attribute in self.__unserializable_attributes__:
+                continue
+
+            id = (
+                str(self.attribute_ids_by_name[attribute.name])
+                if self.attribute_ids_by_name.get(attribute.name)
+                else str(uuid4_from_hash(f"{self.node_id}|{attribute.name}"))
+            )
+            try:
+                attributes.append(
+                    {
+                        "id": id,
+                        "name": attribute.name,
+                        "value": serialize_value(display_context, attribute.instance),
+                    }
+                )
+            except ValueError as e:
+                raise ValueError(f"Failed to serialize attribute '{attribute.name}': {e}")
+
+        return attributes

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

@@ -4,6 +4,7 @@ from typing import Type
 
 from vellum.client.types.variable_prompt_block import VariablePromptBlock
 from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs import BaseInputs
 from vellum.workflows.nodes import BaseNode
 from vellum.workflows.nodes.displayable.inline_prompt_node.node import InlinePromptNode
 from vellum.workflows.ports.port import Port
@@ -145,7 +146,7 @@ def test_serialize_node__prompt_inputs__state_reference():
         ml_model = "gpt-4o"
 
     # AND a workflow with the prompt node
-    class Workflow(BaseWorkflow):
+    class Workflow(BaseWorkflow[BaseInputs, MyState]):
         graph = MyPromptNode
 
     # WHEN the workflow is serialized
@@ -184,6 +185,37 @@ def test_serialize_node__prompt_inputs__state_reference():
         },
     ]
 
+    # AND the prompt attributes should include a dictionary reference with the state reference
+    prompt_inputs_attribute = next(
+        attribute for attribute in my_prompt_node["attributes"] if attribute["name"] == "prompt_inputs"
+    )
+    assert prompt_inputs_attribute == {
+        "id": "3b6e1363-e41b-458e-ad28-95a61fdedac1",
+        "name": "prompt_inputs",
+        "value": {
+            "type": "DICTIONARY_REFERENCE",
+            "entries": [
+                {
+                    "key": "foo",
+                    "value": {
+                        "type": "STATE_VALUE",
+                        "state_variable_id": "45649791-c642-4405-aff9-a1fafd780ea1",
+                    },
+                },
+                {
+                    "key": "bar",
+                    "value": {
+                        "type": "CONSTANT_VALUE",
+                        "value": {
+                            "type": "STRING",
+                            "value": "baz",
+                        },
+                    },
+                },
+            ],
+        },
+    }
+
 
 def test_serialize_node__unreferenced_variable_block__still_serializes():
     # GIVEN a prompt node with an unreferenced variable block

{vellum_ai-0.14.50 → vellum_ai-0.14.51}/pyproject.toml

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

{vellum_ai-0.14.50 → vellum_ai-0.14.51}/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.50",
+            "X-Fern-SDK-Version": "0.14.51",
         }
         headers["X-API-KEY"] = self.api_key
         return headers

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

@@ -20,7 +20,6 @@ from vellum.client import ApiError, RequestOptions
 from vellum.client.types.chat_message_request import ChatMessageRequest
 from vellum.client.types.prompt_settings import PromptSettings
 from vellum.client.types.rich_text_child_block import RichTextChildBlock
-from vellum.workflows.constants import OMIT
 from vellum.workflows.context import get_execution_context
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.errors.types import vellum_error_to_workflow_error
@@ -56,7 +55,7 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
     functions: Optional[List[Union[FunctionDefinition, Callable]]] = None
 
     parameters: PromptParameters = DEFAULT_PROMPT_PARAMETERS
-    expand_meta: Optional[AdHocExpandMeta] = OMIT
+    expand_meta: Optional[AdHocExpandMeta] = None
 
     settings: Optional[PromptSettings] = None
 

{vellum_ai-0.14.50 → vellum_ai-0.14.51}/src/vellum/workflows/nodes/displayable/bases/inline_prompt_node/tests/test_inline_prompt_node.py

@@ -270,7 +270,7 @@ def test_inline_prompt_node__json_output(vellum_adhoc_prompt_client):
     # AND we should have made the expected call to Vellum search
     vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.assert_called_once_with(
         blocks=[],
-        expand_meta=Ellipsis,
+        expand_meta=None,
         functions=None,
         input_values=[],
         input_variables=[],
@@ -350,7 +350,7 @@ def test_inline_prompt_node__streaming_disabled(vellum_adhoc_prompt_client):
     # AND we should have made the expected call to Vellum search
     vellum_adhoc_prompt_client.adhoc_execute_prompt.assert_called_once_with(
         blocks=[],
-        expand_meta=Ellipsis,
+        expand_meta=None,
         functions=None,
         input_values=[],
         input_variables=[],
@@ -444,7 +444,7 @@ def test_inline_prompt_node__json_output_with_streaming_disabled(vellum_adhoc_pr
     # AND we should have made the expected call to Vellum search
     vellum_adhoc_prompt_client.adhoc_execute_prompt.assert_called_once_with(
         blocks=[],
-        expand_meta=Ellipsis,
+        expand_meta=None,
         functions=None,
         input_values=[],
         input_variables=[],

{vellum_ai-0.14.50 → vellum_ai-0.14.51}/src/vellum/workflows/nodes/displayable/tests/test_inline_text_prompt_node.py

@@ -74,7 +74,7 @@ def test_inline_text_prompt_node__basic(vellum_adhoc_prompt_client):
     # AND we should have made the expected call to Vellum search
     vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.assert_called_once_with(
         blocks=[],
-        expand_meta=Ellipsis,
+        expand_meta=None,
         functions=None,
         input_values=[],
         input_variables=[],

vellum_ai-0.14.51/src/vellum/workflows/nodes/experimental/__init__.py

@@ -0,0 +1,3 @@
+from .tool_calling_node import ToolCallingNode
+
+__all__ = ["ToolCallingNode"]

vellum_ai-0.14.51/src/vellum/workflows/nodes/experimental/tool_calling_node/tests/test_tool_calling_node.py

@@ -0,0 +1,53 @@
+from vellum.client.types.function_call import FunctionCall
+from vellum.client.types.function_call_vellum_value import FunctionCallVellumValue
+from vellum.workflows.nodes.experimental.tool_calling_node.utils import create_tool_router_node
+from vellum.workflows.state.base import BaseState, StateMeta
+
+
+def first_function() -> str:
+    return "first_function"
+
+
+def second_function() -> str:
+    return "second_function"
+
+
+def test_port_condition_match_function_name():
+    """
+    Test that the port condition correctly matches the function name.
+    """
+    # GIVEN a tool router node
+    router_node = create_tool_router_node(
+        ml_model="test-model",
+        blocks=[],
+        functions=[first_function, second_function],
+        prompt_inputs=None,
+    )
+
+    # AND a state with a function call to the first function
+    state = BaseState(
+        meta=StateMeta(
+            node_outputs={
+                router_node.Outputs.results: [
+                    FunctionCallVellumValue(
+                        value=FunctionCall(
+                            arguments={}, id="call_zp7pBQjGAOBCr7lo0AbR1HXT", name="first_function", state="FULFILLED"
+                        ),
+                    )
+                ],
+            },
+        )
+    )
+
+    # WHEN the port condition is resolved
+    # THEN the first function port should be true
+    first_function_port = getattr(router_node.Ports, "first_function")
+    assert first_function_port.resolve_condition(state) is True
+
+    # AND the second function port should be false
+    second_function_port = getattr(router_node.Ports, "second_function")
+    assert second_function_port.resolve_condition(state) is False
+
+    # AND the default port should be false
+    default_port = getattr(router_node.Ports, "default")
+    assert default_port.resolve_condition(state) is False

{vellum_ai-0.14.50 → vellum_ai-0.14.51}/src/vellum/workflows/nodes/experimental/tool_calling_node/utils.py

@@ -57,12 +57,19 @@ def create_tool_router_node(
     Ports = type("Ports", (), {})
     for function in functions:
         function_name = function.__name__
-        port_condition = LazyReference(
-            lambda: (
-                node.Outputs.results[0]["type"].equals("FUNCTION_CALL")
-                & node.Outputs.results[0]["value"]["name"].equals(function_name)
+
+        # Avoid using lambda to capture function_name
+        # lambda will capture the function_name by reference,
+        # and if the function_name is changed, the port_condition will also change.
+        def create_port_condition(fn_name):
+            return LazyReference(
+                lambda: (
+                    node.Outputs.results[0]["type"].equals("FUNCTION_CALL")
+                    & node.Outputs.results[0]["value"]["name"].equals(fn_name)
+                )
             )
-        )
+
+        port_condition = create_port_condition(function_name)
         port = Port.on_if(port_condition)
         setattr(Ports, function_name, port)