vellum-ai 1.0.6__py3-none-any.whl → 1.0.7__py3-none-any.whl

vellum/client/core/client_wrapper.py

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

vellum/workflows/nodes/displayable/api_node/tests/test_api_node.py

@@ -16,6 +16,7 @@ def test_run_workflow__secrets(vellum_client):
         json_={"data": [1, 2, 3]},
         headers={"X-Response-Header": "bar"},
     )
+    vellum_client._client_wrapper.get_headers.return_value = {"User-Agent": "vellum-ai/1.0.6"}
 
     class SimpleBaseAPINode(APINode):
         method = APIRequestMethod.POST
@@ -35,7 +36,9 @@ def test_run_workflow__secrets(vellum_client):
     assert vellum_client.execute_api.call_count == 1
     assert vellum_client.execute_api.call_args.kwargs["url"] == "https://example.vellum.ai"
     assert vellum_client.execute_api.call_args.kwargs["body"] == {"key": "value"}
-    assert vellum_client.execute_api.call_args.kwargs["headers"] == {"X-Test-Header": "foo"}
+    headers = vellum_client.execute_api.call_args.kwargs["headers"]
+    assert headers["X-Test-Header"] == "foo"
+    assert "vellum-ai" in headers.get("User-Agent", "")
     bearer_token = vellum_client.execute_api.call_args.kwargs["bearer_token"]
     assert bearer_token == ClientVellumSecret(name="secret")
     assert terminal.headers == {"X-Response-Header": "bar"}
@@ -44,6 +47,7 @@ def test_run_workflow__secrets(vellum_client):
 def test_api_node_raises_error_when_api_call_fails(vellum_client):
     # GIVEN an API call that fails
     vellum_client.execute_api.side_effect = ApiError(status_code=400, body="API Error")
+    vellum_client._client_wrapper.get_headers.return_value = {"User-Agent": "vellum-ai/1.0.6"}
 
     class SimpleAPINode(APINode):
         method = APIRequestMethod.GET
@@ -70,7 +74,9 @@ def test_api_node_raises_error_when_api_call_fails(vellum_client):
     assert vellum_client.execute_api.call_count == 1
     assert vellum_client.execute_api.call_args.kwargs["url"] == "https://example.vellum.ai"
     assert vellum_client.execute_api.call_args.kwargs["body"] == {"key": "value"}
-    assert vellum_client.execute_api.call_args.kwargs["headers"] == {"X-Test-Header": "foo"}
+    headers = vellum_client.execute_api.call_args.kwargs["headers"]
+    assert headers["X-Test-Header"] == "foo"
+    assert "vellum-ai" in headers.get("User-Agent", "")
 
 
 def test_api_node_defaults_to_get_method(vellum_client):

vellum/workflows/nodes/displayable/bases/api_node/node.py

@@ -92,6 +92,10 @@ class BaseAPINode(BaseNode, Generic[StateType]):
             return self._local_execute_api(data, headers, json, normalized_method, url, timeout)
 
     def _local_execute_api(self, data, headers, json, method, url, timeout):
+        headers = headers or {}
+        if "User-Agent" not in headers:
+            client_headers = self._context.vellum_client._client_wrapper.get_headers()
+            headers["User-Agent"] = client_headers.get("User-Agent")
         try:
             if data is not None:
                 prepped = Request(method=method, url=url, data=data, headers=headers).prepare()
@@ -120,6 +124,11 @@ class BaseAPINode(BaseNode, Generic[StateType]):
     def _vellum_execute_api(self, bearer_token, data, headers, method, url, timeout):
         client_vellum_secret = ClientVellumSecret(name=bearer_token.name) if bearer_token else None
 
+        headers = headers or {}
+        if "User-Agent" not in headers:
+            client_headers = self._context.vellum_client._client_wrapper.get_headers()
+            headers["User-Agent"] = client_headers.get("User-Agent")
+
         # Create request_options if timeout is specified
         request_options = None
         if timeout is not None:

vellum/workflows/nodes/displayable/bases/api_node/tests/test_node.py

@@ -45,3 +45,80 @@ def test_api_node_with_invalid_method():
 
     assert exc_info.value.code == WorkflowErrorCode.INVALID_INPUTS
     assert "Invalid HTTP method 'INVALID_METHOD'" == str(exc_info.value)
+
+
+def test_api_node_adds_user_agent_header_when_none_provided(requests_mock):
+    """
+    Tests that the API node adds User-Agent header when no headers are provided.
+    """
+
+    class TestAPINode(BaseAPINode):
+        method = APIRequestMethod.GET
+        url = "https://example.com/test"
+
+    response_mock = requests_mock.get(
+        "https://example.com/test",
+        json={"result": "success"},
+        status_code=200,
+    )
+
+    node = TestAPINode()
+    result = node.run()
+
+    assert response_mock.last_request
+    assert "vellum-ai" in response_mock.last_request.headers.get("User-Agent", "")
+
+    assert result.status_code == 200
+
+
+def test_api_node_adds_user_agent_header_when_headers_provided_without_user_agent(requests_mock):
+    """
+    Tests that the API node adds User-Agent header when headers are provided but don't include User-Agent.
+    """
+
+    class TestAPINode(BaseAPINode):
+        method = APIRequestMethod.POST
+        url = "https://example.com/test"
+        headers = {"Content-Type": "application/json", "Custom-Header": "value"}
+        json = {"test": "data"}
+
+    response_mock = requests_mock.post(
+        "https://example.com/test",
+        json={"result": "success"},
+        status_code=200,
+    )
+
+    node = TestAPINode()
+    result = node.run()
+
+    assert response_mock.last_request
+    assert "vellum-ai" in response_mock.last_request.headers.get("User-Agent", "")
+    assert response_mock.last_request.headers.get("Content-Type") == "application/json"
+    assert response_mock.last_request.headers.get("Custom-Header") == "value"
+
+    assert result.status_code == 200
+
+
+def test_api_node_preserves_custom_user_agent_header(requests_mock):
+    """
+    Tests that the API node preserves a custom User-Agent header if provided.
+    """
+
+    class TestAPINode(BaseAPINode):
+        method = APIRequestMethod.GET
+        url = "https://example.com/test"
+        headers = {"User-Agent": "Custom-Agent/1.0"}
+
+    response_mock = requests_mock.get(
+        "https://example.com/test",
+        json={"result": "success"},
+        status_code=200,
+    )
+
+    node = TestAPINode()
+    result = node.run()
+
+    assert response_mock.last_request
+    assert response_mock.last_request.headers.get("User-Agent") == "Custom-Agent/1.0"
+
+    assert result.status_code == 200

vellum/workflows/nodes/displayable/tool_calling_node/node.py

@@ -1,4 +1,4 @@
-from typing import ClassVar, Iterator, List, Optional, Set
+from typing import Any, ClassVar, Dict, Iterator, List, Optional, Set, Union
 
 from vellum import ChatMessage, PromptBlock
 from vellum.client.types.prompt_parameters import PromptParameters
@@ -36,7 +36,7 @@ class ToolCallingNode(BaseNode):
     """
 
     ml_model: ClassVar[str] = "gpt-4o-mini"
-    blocks: ClassVar[List[PromptBlock]] = []
+    blocks: ClassVar[List[Union[PromptBlock, Dict[str, Any]]]] = []
     functions: ClassVar[List[Tool]] = []
     prompt_inputs: ClassVar[Optional[EntityInputsInterface]] = None
     parameters: PromptParameters = DEFAULT_PROMPT_PARAMETERS

vellum/workflows/nodes/displayable/tool_calling_node/tests/test_utils.py

@@ -1,9 +1,18 @@
 import pytest
-
+from uuid import uuid4
+
+from vellum.client.types.chat_message_prompt_block import ChatMessagePromptBlock
+from vellum.client.types.fulfilled_execute_prompt_event import FulfilledExecutePromptEvent
+from vellum.client.types.initiated_execute_prompt_event import InitiatedExecutePromptEvent
+from vellum.client.types.plain_text_prompt_block import PlainTextPromptBlock
+from vellum.client.types.rich_text_prompt_block import RichTextPromptBlock
+from vellum.client.types.string_vellum_value import StringVellumValue
+from vellum.client.types.variable_prompt_block import VariablePromptBlock
+from vellum.prompts.constants import DEFAULT_PROMPT_PARAMETERS
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
-from vellum.workflows.nodes.displayable.tool_calling_node.utils import get_function_name
+from vellum.workflows.nodes.displayable.tool_calling_node.utils import create_tool_router_node, get_function_name
 from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.types.definition import ComposioToolDefinition, DeploymentDefinition
@@ -76,3 +85,139 @@ def test_get_function_name_composio_tool_definition_various_toolkits(
     result = get_function_name(composio_tool)
 
     assert result == expected_result
+
+
+def test_create_tool_router_node_max_prompt_iterations(vellum_adhoc_prompt_client):
+    # GIVEN a tool router node with max_prompt_iterations set to None
+    tool_router_node = create_tool_router_node(
+        ml_model="gpt-4o-mini",
+        blocks=[],
+        functions=[],
+        prompt_inputs=None,
+        parameters=DEFAULT_PROMPT_PARAMETERS,
+        max_prompt_iterations=None,
+    )
+
+    def generate_prompt_events(*args, **kwargs):
+        execution_id = str(uuid4())
+        events = [
+            InitiatedExecutePromptEvent(execution_id=execution_id),
+            FulfilledExecutePromptEvent(
+                execution_id=execution_id,
+                outputs=[StringVellumValue(value="test output")],
+            ),
+        ]
+        yield from events
+
+    vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.side_effect = generate_prompt_events
+
+    # WHEN we run the tool router node
+    node_instance = tool_router_node()
+    outputs = list(node_instance.run())
+    assert outputs[0].name == "results"
+    assert outputs[0].value == [StringVellumValue(type="STRING", value="test output")]
+    assert outputs[1].name == "text"
+    assert outputs[1].value == "test output"
+
+
+def test_create_tool_router_node_chat_history_block_dict(vellum_adhoc_prompt_client):
+    # GIVEN a list of blocks with a chat history block
+    blocks = [
+        {
+            "block_type": "CHAT_MESSAGE",
+            "chat_role": "SYSTEM",
+            "blocks": [
+                {
+                    "block_type": "RICH_TEXT",
+                    "blocks": [{"block_type": "PLAIN_TEXT", "cache_config": None, "text": "first message"}],
+                }
+            ],
+        },
+        {
+            "block_type": "CHAT_MESSAGE",
+            "chat_role": "USER",
+            "blocks": [
+                {
+                    "block_type": "RICH_TEXT",
+                    "blocks": [
+                        {"block_type": "PLAIN_TEXT", "text": "second message"},
+                        {"block_type": "PLAIN_TEXT", "text": "third message"},
+                    ],
+                }
+            ],
+        },
+    ]
+
+    tool_router_node = create_tool_router_node(
+        ml_model="gpt-4o-mini",
+        blocks=blocks,  # type: ignore
+        functions=[],
+        prompt_inputs=None,
+        parameters=DEFAULT_PROMPT_PARAMETERS,
+    )
+
+    def generate_prompt_events(*args, **kwargs):
+        execution_id = str(uuid4())
+        events = [
+            InitiatedExecutePromptEvent(execution_id=execution_id),
+            FulfilledExecutePromptEvent(
+                execution_id=execution_id,
+                outputs=[StringVellumValue(value="test output")],
+            ),
+        ]
+        yield from events
+
+    vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.side_effect = generate_prompt_events
+
+    # WHEN we run the tool router node
+    node_instance = tool_router_node()
+    list(node_instance.run())
+
+    # THEN the API was called with compiled blocks
+    blocks = vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.call_args[1]["blocks"]
+    assert blocks == [
+        ChatMessagePromptBlock(
+            block_type="CHAT_MESSAGE",
+            state=None,
+            cache_config=None,
+            chat_role="SYSTEM",
+            chat_source=None,
+            chat_message_unterminated=None,
+            blocks=[
+                RichTextPromptBlock(
+                    block_type="RICH_TEXT",
+                    state=None,
+                    cache_config=None,
+                    blocks=[
+                        PlainTextPromptBlock(
+                            block_type="PLAIN_TEXT", state=None, cache_config=None, text="first message"
+                        )
+                    ],
+                )
+            ],
+        ),
+        ChatMessagePromptBlock(
+            block_type="CHAT_MESSAGE",
+            state=None,
+            cache_config=None,
+            chat_role="USER",
+            chat_source=None,
+            chat_message_unterminated=None,
+            blocks=[
+                RichTextPromptBlock(
+                    block_type="RICH_TEXT",
+                    state=None,
+                    cache_config=None,
+                    blocks=[
+                        PlainTextPromptBlock(
+                            block_type="PLAIN_TEXT", state=None, cache_config=None, text="second message"
+                        ),
+                        PlainTextPromptBlock(
+                            block_type="PLAIN_TEXT", state=None, cache_config=None, text="third message"
+                        ),
+                    ],
+                )
+            ],
+        ),
+        VariablePromptBlock(block_type="VARIABLE", state=None, cache_config=None, input_variable="chat_history"),
+    ]

vellum/workflows/nodes/displayable/tool_calling_node/utils.py

@@ -1,6 +1,6 @@
 import json
 import logging
-from typing import Any, Callable, Iterator, List, Optional, Type, Union, cast
+from typing import Any, Callable, Dict, Iterator, List, Optional, Type, Union, cast
 
 from pydash import snake_case
 
@@ -67,7 +67,7 @@ class ToolRouterNode(InlinePromptNode[ToolCallingState]):
         merge_behavior = MergeBehavior.AWAIT_ATTRIBUTES
 
     def run(self) -> Iterator[BaseOutput]:
-        if self.state.prompt_iterations >= self.max_prompt_iterations:
+        if self.max_prompt_iterations is not None and self.state.prompt_iterations >= self.max_prompt_iterations:
             max_iterations_message = f"Maximum number of prompt iterations `{self.max_prompt_iterations}` reached."
             raise NodeException(message=max_iterations_message, code=WorkflowErrorCode.NODE_EXECUTION)
 
@@ -235,7 +235,7 @@ def _hydrate_composio_tool_definition(tool_def: ComposioToolDefinition) -> Compo
 
 def create_tool_router_node(
     ml_model: str,
-    blocks: List[PromptBlock],
+    blocks: List[Union[PromptBlock, Dict[str, Any]]],
     functions: List[Tool],
     prompt_inputs: Optional[EntityInputsInterface],
     parameters: PromptParameters,
@@ -287,7 +287,16 @@ def create_tool_router_node(
 
     # Add a chat history block to blocks only if one doesn't already exist
     has_chat_history_block = any(
-        block.block_type == "VARIABLE" and block.input_variable == CHAT_HISTORY_VARIABLE for block in blocks
+        (
+            (block["block_type"] if isinstance(block, dict) else block.block_type) == "VARIABLE"
+            and (
+                block["input_variable"]
+                if isinstance(block, dict)
+                else block.input_variable if isinstance(block, VariablePromptBlock) else None
+            )
+            == CHAT_HISTORY_VARIABLE
+        )
+        for block in blocks
     )
 
     if not has_chat_history_block:

vellum/workflows/utils/functions.py

@@ -1,6 +1,6 @@
 import dataclasses
 import inspect
-from typing import TYPE_CHECKING, Any, Callable, Dict, Literal, Optional, Type, Union, get_args, get_origin
+from typing import TYPE_CHECKING, Annotated, Any, Callable, Dict, Literal, Optional, Type, Union, get_args, get_origin
 
 from pydantic import BaseModel
 from pydantic_core import PydanticUndefined
@@ -53,6 +53,21 @@ def compile_annotation(annotation: Optional[Any], defs: dict[str, Any]) -> dict:
         item_type = get_args(annotation)[0]
         return {"type": "array", "items": compile_annotation(item_type, defs)}
 
+    if get_origin(annotation) is tuple:
+        args = get_args(annotation)
+        if len(args) == 2 and args[1] is Ellipsis:
+            # Tuple[int, ...] with homogeneous items
+            return {"type": "array", "items": compile_annotation(args[0], defs)}
+        else:
+            # Tuple[int, str] with fixed length items
+            result = {
+                "type": "array",
+                "prefixItems": [compile_annotation(arg, defs) for arg in args],
+                "minItems": len(args),
+                "maxItems": len(args),
+            }
+            return result
+
     if dataclasses.is_dataclass(annotation):
         if annotation.__name__ not in defs:
             properties = {}
@@ -127,7 +142,19 @@ def compile_function_definition(function: Callable) -> FunctionDefinition:
     required = []
     defs: dict[str, Any] = {}
     for param in signature.parameters.values():
-        properties[param.name] = compile_annotation(param.annotation, defs)
+        # Check if parameter uses Annotated type hint
+        if get_origin(param.annotation) is Annotated:
+            args = get_args(param.annotation)
+            actual_type = args[0]
+            # Extract description from metadata
+            description = args[1] if len(args) > 1 and isinstance(args[1], str) else None
+
+            properties[param.name] = compile_annotation(actual_type, defs)
+            if description:
+                properties[param.name]["description"] = description
+        else:
+            properties[param.name] = compile_annotation(param.annotation, defs)
+
         if param.default is inspect.Parameter.empty:
             required.append(param.name)
         else:

vellum/workflows/utils/tests/test_functions.py

@@ -2,7 +2,7 @@ import pytest
 from dataclasses import dataclass
 from enum import Enum
 from unittest.mock import Mock
-from typing import Dict, List, Literal, Optional, Union
+from typing import Annotated, Dict, List, Literal, Optional, Tuple, Union
 
 from pydantic import BaseModel
 
@@ -612,3 +612,117 @@ def test_compile_function_definition__literal_type_not_in_map():
     compiled_function = compile_function_definition(my_function)
     assert isinstance(compiled_function.parameters, dict)
     assert compiled_function.parameters["properties"]["a"] == {"enum": [MyEnum.FOO, MyEnum.BAR]}
+
+
+def test_compile_function_definition__annotated_descriptions():
+    # GIVEN a function with annotated parameters that include descriptions
+    def my_function(
+        bar: Annotated[str, "My bar parameter"],
+        other: Annotated[int, "My other parameter"],
+        regular_param: str,
+        optional_param: Annotated[bool, "Optional boolean parameter"] = True,
+    ):
+        """Test function with annotated parameters."""
+        pass
+
+    # WHEN compiling the function
+    compiled_function = compile_function_definition(my_function)
+
+    # THEN it should return the compiled function definition with descriptions
+    assert compiled_function == FunctionDefinition(
+        name="my_function",
+        description="Test function with annotated parameters.",
+        parameters={
+            "type": "object",
+            "properties": {
+                "bar": {"type": "string", "description": "My bar parameter"},
+                "other": {"type": "integer", "description": "My other parameter"},
+                "regular_param": {"type": "string"},
+                "optional_param": {"type": "boolean", "description": "Optional boolean parameter", "default": True},
+            },
+            "required": ["bar", "other", "regular_param"],
+        },
+    )
+
+
+def test_compile_function_definition__annotated_without_description():
+    # GIVEN a function with annotated parameters but no description metadata
+    def my_function(param: Annotated[str, None]):
+        pass
+
+    # WHEN compiling the function
+    compiled_function = compile_function_definition(my_function)
+
+    # THEN it should return the compiled function definition without description
+    assert compiled_function == FunctionDefinition(
+        name="my_function",
+        parameters={
+            "type": "object",
+            "properties": {
+                "param": {"type": "string"},
+            },
+            "required": ["param"],
+        },
+    )
+
+
+def test_compile_function_definition__annotated_complex_types():
+    # GIVEN a function with annotated types
+    def my_function(
+        location: Annotated[Literal["New York", "Portland"], "The location you found"],
+        items: Annotated[List[str], "List of string items"],
+        config: Annotated[Dict[str, int], "Configuration mapping"],
+    ):
+        pass
+
+    # WHEN compiling the function
+    compiled_function = compile_function_definition(my_function)
+
+    # THEN it should return the compiled function definition with descriptions for complex types
+    assert compiled_function == FunctionDefinition(
+        name="my_function",
+        parameters={
+            "type": "object",
+            "properties": {
+                "location": {
+                    "type": "string",
+                    "enum": ["New York", "Portland"],
+                    "description": "The location you found",
+                },
+                "items": {"type": "array", "items": {"type": "string"}, "description": "List of string items"},
+                "config": {
+                    "type": "object",
+                    "additionalProperties": {"type": "integer"},
+                    "description": "Configuration mapping",
+                },
+            },
+            "required": ["location", "items", "config"],
+        },
+    )
+
+
+@pytest.mark.parametrize(
+    "annotation,expected_schema",
+    [
+        (
+            Tuple[int, ...],
+            {"type": "array", "items": {"type": "integer"}},
+        ),
+        (
+            Tuple[int, str],
+            {
+                "type": "array",
+                "prefixItems": [{"type": "integer"}, {"type": "string"}],
+                "minItems": 2,
+                "maxItems": 2,
+            },
+        ),
+    ],
+)
+def test_compile_function_definition__tuples(annotation, expected_schema):
+    def my_function(a: annotation):  # type: ignore
+        pass
+
+    compiled_function = compile_function_definition(my_function)
+    assert isinstance(compiled_function.parameters, dict)
+    assert compiled_function.parameters["properties"]["a"] == expected_schema

{vellum_ai-1.0.6.dist-info → vellum_ai-1.0.7.dist-info}/METADATA

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

{vellum_ai-1.0.6.dist-info → vellum_ai-1.0.7.dist-info}/RECORD

@@ -96,7 +96,7 @@ vellum_ee/workflows/display/tests/workflow_serialization/test_basic_templating_n
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_terminal_node_serialization.py,sha256=hDWtKXmGI1CKhTwTNqpu_d5RkE5n7SolMLtgd87KqTI,3856
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_composio_serialization.py,sha256=gonapBCyDDt3qc7U02PCuKyPS8f3YiSAZ7QD86CH1Fw,3794
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_inline_workflow_serialization.py,sha256=4t1lkN2nsZF6lFqP6QnskUQWJlhasF8C2_f6atzk8ZY,26298
-vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_serialization.py,sha256=1hoakUkh5kHZYIfY1moJBZYzXgAafkgWsIf4lmZ12vg,9521
+vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_serialization.py,sha256=B0rDsCvO24qPp0gkmj8SdTDY5CxZYkvKwknsKBuAPyA,10017
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_workflow_deployment_serialization.py,sha256=mova0sPD3evHiHIN1O0VynxlCp-uOcEIKve5Pd_oCDg,4069
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_try_node_serialization.py,sha256=pLCyMScV88DTBXRH7jXaXOEA1GBq8NIipCUFwIAWnwI,2771
 vellum_ee/workflows/display/tests/workflow_serialization/test_complex_terminal_node_serialization.py,sha256=J4ouI8KxbMfxQP2Zq_9cWMGYgbjCWmKzjCJEtnSJb0I,5829
@@ -145,7 +145,7 @@ vellum/client/README.md,sha256=Dle5iytCXxP1pNeNd7uZyhFo0rl7tp7vU7s8gmi10OQ,4863
 vellum/client/__init__.py,sha256=KmkyOgReuTsjmXF3WC_dPQ9QqJgYrB3Sr8_LcSUIQyI,125258
 vellum/client/core/__init__.py,sha256=SQ85PF84B9MuKnBwHNHWemSGuy-g_515gFYNFhvEE0I,1438
 vellum/client/core/api_error.py,sha256=RE8LELok2QCjABadECTvtDp7qejA1VmINCh6TbqPwSE,426
-vellum/client/core/client_wrapper.py,sha256=QsKeKLYWV6cj1EDrHG6sVVmh4h2ol3aw7P3Lckn25Wk,2383
+vellum/client/core/client_wrapper.py,sha256=4HIoFVgVHLgCMAKnGSlXru4ZVIHjc4LSqpYHg9GPlAI,2383
 vellum/client/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 vellum/client/core/file.py,sha256=d4NNbX8XvXP32z8KpK2Xovv33nFfruIrpz0QWxlgpZk,2663
 vellum/client/core/http_client.py,sha256=cKs2w0ybDBk1wHQf-fTALm_MmvaMe3cZKcYJxqmCxkE,19539
@@ -1632,12 +1632,12 @@ vellum/workflows/nodes/displayable/__init__.py,sha256=zH7SFotr4i8sO-r5_k53yPipQw
 vellum/workflows/nodes/displayable/api_node/__init__.py,sha256=MoxdQSnidIj1Nf_d-hTxlOxcZXaZnsWFDbE-PkTK24o,56
 vellum/workflows/nodes/displayable/api_node/node.py,sha256=F7ucsuEmrVYlTKMIoi60fFJ_ELYgGuc7jEmJCEyQczw,2956
 vellum/workflows/nodes/displayable/api_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/nodes/displayable/api_node/tests/test_api_node.py,sha256=qp6v-MrgpNVDt16Kp0EOyeQx3LpzflTlaNSL1EYZ1nE,9185
+vellum/workflows/nodes/displayable/api_node/tests/test_api_node.py,sha256=DZQGyq-iI9P9qvM5qtIUzb6fubyLnlJ3WbHwMUFsRs8,9527
 vellum/workflows/nodes/displayable/bases/__init__.py,sha256=0mWIx3qUrzllV7jqt7wN03vWGMuI1WrrLZeMLT2Cl2c,304
 vellum/workflows/nodes/displayable/bases/api_node/__init__.py,sha256=1jwx4WC358CLA1jgzl_UD-rZmdMm2v9Mps39ndwCD7U,64
-vellum/workflows/nodes/displayable/bases/api_node/node.py,sha256=jkv803kEPlK4lrzk2oWU0J3t6vyFeQkI9ap9RCb1qt0,6183
+vellum/workflows/nodes/displayable/bases/api_node/node.py,sha256=iUtdPsbJs1jwo3V5bA6qGab56z3K44_VOpLR5MDXzBQ,6640
 vellum/workflows/nodes/displayable/bases/api_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/nodes/displayable/bases/api_node/tests/test_node.py,sha256=Z39BZn-QgGNCKcwbOwhMpAopwgX6J3v7ulCA6TKyphE,1587
+vellum/workflows/nodes/displayable/bases/api_node/tests/test_node.py,sha256=Pf51DIyhtUxx-pCu0zJYDB4Z5_IW5mRwkJIoPT53_9I,3894
 vellum/workflows/nodes/displayable/bases/base_prompt_node/__init__.py,sha256=Org3xTvgp1pA0uUXFfnJr29D3HzCey2lEdYF4zbIUgo,70
 vellum/workflows/nodes/displayable/bases/base_prompt_node/node.py,sha256=EJsGaz8Umss6-JWGGYbJp93ZHx3IlZQWAySlHAdNYtY,4466
 vellum/workflows/nodes/displayable/bases/inline_prompt_node/__init__.py,sha256=Hl35IAoepRpE-j4cALaXVJIYTYOF3qszyVbxTj4kS1s,82
@@ -1695,13 +1695,13 @@ vellum/workflows/nodes/displayable/tests/test_search_node_error_handling.py,sha2
 vellum/workflows/nodes/displayable/tests/test_search_node_wth_text_output.py,sha256=VepO5z1277c1y5N6LLIC31nnWD1aak2m5oPFplfJHHs,6935
 vellum/workflows/nodes/displayable/tests/test_text_prompt_deployment_node.py,sha256=dc3EEn1sOICpr3GdS8eyeFtExaGwWWcw9eHSdkRhQJU,2584
 vellum/workflows/nodes/displayable/tool_calling_node/__init__.py,sha256=3n0-ysmFKsr40CVxPthc0rfJgqVJeZuUEsCmYudLVRg,117
-vellum/workflows/nodes/displayable/tool_calling_node/node.py,sha256=BRA6YRCEOk0Nw3DCIT13WY7WCZ7Gx30s-egJe_md0FA,6504
+vellum/workflows/nodes/displayable/tool_calling_node/node.py,sha256=KRI1NMgXZTUgQqq9uOA9W_D8k8sy7ZAq6v53-YVno1k,6545
 vellum/workflows/nodes/displayable/tool_calling_node/state.py,sha256=oQg_GAtc349nPB5BL_oeDYYD7q1qSDPAqjj8iA8OoAw,215
 vellum/workflows/nodes/displayable/tool_calling_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/tool_calling_node/tests/test_composio_service.py,sha256=UV0vZpU7-_tHcwnIq36WKwHrJXNurU4bdC3rfaw8eoU,4804
 vellum/workflows/nodes/displayable/tool_calling_node/tests/test_node.py,sha256=raY_E5-EgtYNXEPbO2I-Ythe4YeuFdGsXGZ_BAN98uI,7979
-vellum/workflows/nodes/displayable/tool_calling_node/tests/test_utils.py,sha256=aCK4TDcD4TcgoYbOs712qFiNCVRVffCb5HZCZQGDiUc,2449
-vellum/workflows/nodes/displayable/tool_calling_node/utils.py,sha256=fOoAr_TTZ5Sjuc2GSyKz87vnfx-RZ6B7BxtQmPdxqfE,16191
+vellum/workflows/nodes/displayable/tool_calling_node/tests/test_utils.py,sha256=Ku_fUUoqQFeKLZ6o1DPCi7ax9PdkbaxkEEj6rAwjytM,7858
+vellum/workflows/nodes/displayable/tool_calling_node/utils.py,sha256=uRZGCJA3FBRt1ZPQWOF2R8D49aajrW4Yjxvn3kIcrAQ,16545
 vellum/workflows/nodes/experimental/README.md,sha256=eF6DfIL8t-HbF9-mcofOMymKrraiBHDLKTlnBa51ZiE,284
 vellum/workflows/nodes/experimental/__init__.py,sha256=jCQgvZEknXKfuNhGSOou4XPfrPqZ1_XBj5F0n0fgiWM,106
 vellum/workflows/nodes/experimental/openai_chat_completion_node/__init__.py,sha256=lsyD9laR9p7kx5-BXGH2gUTM242UhKy8SMV0SR6S2iE,90
@@ -1757,11 +1757,11 @@ vellum/workflows/types/tests/test_definition.py,sha256=c3GczPtWxuH3BOULwZacxYTQl
 vellum/workflows/types/tests/test_utils.py,sha256=UnZog59tR577mVwqZRqqWn2fScoOU1H6up0EzS8zYhw,2536
 vellum/workflows/types/utils.py,sha256=mTctHITBybpt4855x32oCKALBEcMNLn-9cCmfEKgJHQ,6498
 vellum/workflows/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/utils/functions.py,sha256=4pHaaaOXwvYTLVThTkLYpESBkzNKuZdiyRBGRpcWxqY,7623
+vellum/workflows/utils/functions.py,sha256=ksvyxPWTbsldlXSlqh20e_1hl9GHipWwggYLfp3NRiE,8735
 vellum/workflows/utils/names.py,sha256=QLUqfJ1tmSEeUwBKTTiv_Qk3QGbInC2RSmlXfGXc8Wo,380
 vellum/workflows/utils/pydantic_schema.py,sha256=eR_bBtY-T0pttJP-ARwagSdCOnwPUtiT3cegm2lzDTQ,1310
 vellum/workflows/utils/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/utils/tests/test_functions.py,sha256=xIk1r0XwbPcbQLHwN5NFUrztfKa3fGtUnfjvhOrYNNg,19449
+vellum/workflows/utils/tests/test_functions.py,sha256=uaxjsIdtTQdz3r0ACbBegDx-5LMAYyVsI83VgxUlE8o,23520
 vellum/workflows/utils/tests/test_names.py,sha256=aOqpyvMsOEK_9mg_-yaNxQDW7QQfwqsYs37PseyLhxw,402
 vellum/workflows/utils/tests/test_uuids.py,sha256=i77ABQ0M3S-aFLzDXHJq_yr5FPkJEWCMBn1HJ3DObrE,437
 vellum/workflows/utils/tests/test_vellum_variables.py,sha256=vbnKgm41aB5OXlO-ZIPbhQ6xDiZkT8KMxCLqz4zocWY,1791
@@ -1774,8 +1774,8 @@ vellum/workflows/workflows/event_filters.py,sha256=GSxIgwrX26a1Smfd-6yss2abGCnad
 vellum/workflows/workflows/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/workflows/tests/test_base_workflow.py,sha256=ptMntHzVyy8ZuzNgeTuk7hREgKQ5UBdgq8VJFSGaW4Y,20832
 vellum/workflows/workflows/tests/test_context.py,sha256=VJBUcyWVtMa_lE5KxdhgMu0WYNYnUQUDvTF7qm89hJ0,2333
-vellum_ai-1.0.6.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-1.0.6.dist-info/METADATA,sha256=EmLX2EVjbQ5g5W-PpqXN-5TPUhFu6L5KXLRLSB0st_s,5554
-vellum_ai-1.0.6.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-1.0.6.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-1.0.6.dist-info/RECORD,,
+vellum_ai-1.0.7.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-1.0.7.dist-info/METADATA,sha256=-x_ul0guh3O6FHWJQn5INiN0RWn4W4IBRFk_JZgcUGQ,5554
+vellum_ai-1.0.7.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-1.0.7.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-1.0.7.dist-info/RECORD,,

vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_serialization.py

@@ -140,13 +140,19 @@ def test_serialize_workflow():
                                     "description": "\n    Get the current weather in a given location.\n    ",
                                     "parameters": {
                                         "type": "object",
-                                        "properties": {"location": {"type": "string"}, "unit": {"type": "string"}},
+                                        "properties": {
+                                            "location": {
+                                                "type": "string",
+                                                "description": "The location to get the weather for",
+                                            },
+                                            "unit": {"type": "string", "description": "The unit of temperature"},
+                                        },
                                         "required": ["location", "unit"],
                                     },
                                     "forced": None,
                                     "strict": None,
                                 },
-                                "src": 'import math\n\n\ndef get_current_weather(location: str, unit: str) -> str:\n    """\n    Get the current weather in a given location.\n    """\n    return f"The current weather in {location} is sunny with a temperature of {get_temperature(70.1)} degrees {unit}."\n\n\ndef get_temperature(temperature: float) -> int:\n    """\n    Get the temperature in a given location.\n    """\n    return math.floor(temperature)\n',  # noqa: E501
+                                "src": 'import math\nfrom typing import Annotated\n\n\ndef get_current_weather(\n    location: Annotated[str, "The location to get the weather for"], unit: Annotated[str, "The unit of temperature"]\n) -> str:\n    """\n    Get the current weather in a given location.\n    """\n    return f"The current weather in {location} is sunny with a temperature of {get_temperature(70.1)} degrees {unit}."\n\n\ndef get_temperature(temperature: float) -> int:\n    """\n    Get the temperature in a given location.\n    """\n    return math.floor(temperature)\n',  # noqa: E501
                             }
                         ],
                     },