vellum-ai 0.14.71__py3-none-any.whl → 0.14.73__py3-none-any.whl

vellum/workflows/utils/functions.py

@@ -1,12 +1,14 @@
 import dataclasses
 import inspect
-from typing import TYPE_CHECKING, Any, Callable, Optional, Type, Union, get_args, get_origin
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Type, Union, get_args, get_origin
 
 from pydantic import BaseModel
 from pydantic_core import PydanticUndefined
 from pydash import snake_case
 
+from vellum import Vellum
 from vellum.client.types.function_definition import FunctionDefinition
+from vellum.workflows.utils.vellum_variables import vellum_variable_type_to_openapi_type
 
 if TYPE_CHECKING:
     from vellum.workflows.workflows.base import BaseWorkflow
@@ -24,27 +26,27 @@ type_map = {
 }
 
 
-def _compile_annotation(annotation: Optional[Any], defs: dict[str, Any]) -> dict:
+def compile_annotation(annotation: Optional[Any], defs: dict[str, Any]) -> dict:
     if annotation is None:
         return {"type": "null"}
 
     if get_origin(annotation) is Union:
-        return {"anyOf": [_compile_annotation(a, defs) for a in get_args(annotation)]}
+        return {"anyOf": [compile_annotation(a, defs) for a in get_args(annotation)]}
 
     if get_origin(annotation) is dict:
         _, value_type = get_args(annotation)
-        return {"type": "object", "additionalProperties": _compile_annotation(value_type, defs)}
+        return {"type": "object", "additionalProperties": compile_annotation(value_type, defs)}
 
     if get_origin(annotation) is list:
         item_type = get_args(annotation)[0]
-        return {"type": "array", "items": _compile_annotation(item_type, defs)}
+        return {"type": "array", "items": compile_annotation(item_type, defs)}
 
     if dataclasses.is_dataclass(annotation):
         if annotation.__name__ not in defs:
             properties = {}
             required = []
             for field in dataclasses.fields(annotation):
-                properties[field.name] = _compile_annotation(field.type, defs)
+                properties[field.name] = compile_annotation(field.type, defs)
                 if field.default is dataclasses.MISSING:
                     required.append(field.name)
                 else:
@@ -59,7 +61,7 @@ def _compile_annotation(annotation: Optional[Any], defs: dict[str, Any]) -> dict
             for field_name, field in annotation.model_fields.items():
                 # Mypy is incorrect here, the `annotation` attribute is defined on `FieldInfo`
                 field_annotation = field.annotation  # type: ignore[attr-defined]
-                properties[field_name] = _compile_annotation(field_annotation, defs)
+                properties[field_name] = compile_annotation(field_annotation, defs)
                 if field.default is PydanticUndefined:
                     required.append(field_name)
                 else:
@@ -86,6 +88,19 @@ def _compile_default_value(default: Any) -> Any:
     return default
 
 
+def _compile_deployment_workflow_input(input_var: Any) -> dict[str, Any]:
+    """
+    Converts a deployment workflow input variable to a JSON schema type definition.
+    """
+    primitive_type = vellum_variable_type_to_openapi_type(input_var.type)
+    input_schema = {"type": primitive_type}
+
+    if input_var.default is not None:
+        input_schema["default"] = input_var.default.value
+
+    return input_schema
+
+
 def compile_function_definition(function: Callable) -> FunctionDefinition:
     """
     Converts a Python function into our Vellum-native FunctionDefinition type.
@@ -100,7 +115,7 @@ 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)
+        properties[param.name] = compile_annotation(param.annotation, defs)
         if param.default is inspect.Parameter.empty:
             required.append(param.name)
         else:
@@ -117,7 +132,7 @@ def compile_function_definition(function: Callable) -> FunctionDefinition:
     )
 
 
-def compile_workflow_function_definition(workflow_class: Type["BaseWorkflow"]) -> FunctionDefinition:
+def compile_inline_workflow_function_definition(workflow_class: Type["BaseWorkflow"]) -> FunctionDefinition:
     """
     Converts a base workflow class into our Vellum-native FunctionDefinition type.
     """
@@ -133,7 +148,7 @@ def compile_workflow_function_definition(workflow_class: Type["BaseWorkflow"]) -
         if name.startswith("__"):
             continue
 
-        properties[name] = _compile_annotation(field_type, defs)
+        properties[name] = compile_annotation(field_type, defs)
 
         # Check if the field has a default value
         if name not in vars_inputs_class:
@@ -151,3 +166,42 @@ def compile_workflow_function_definition(workflow_class: Type["BaseWorkflow"]) -
         description=workflow_class.__doc__,
         parameters=parameters,
     )
+
+
+def compile_deployment_workflow_function_definition(
+    deployment_config: Dict[str, str],
+    vellum_client: Vellum,
+) -> FunctionDefinition:
+    """
+    Converts a deployment workflow config into our Vellum-native FunctionDefinition type.
+
+    Args:
+        deployment_config: Dict with 'deployment' and 'release_tag' keys
+        vellum_client: Vellum client instance
+    """
+    deployment = deployment_config["deployment"]
+    release_tag = deployment_config["release_tag"]
+
+    workflow_deployment_release = vellum_client.release_reviews.retrieve_workflow_deployment_release(
+        deployment, release_tag
+    )
+
+    input_variables = workflow_deployment_release.workflow_version.input_variables
+    description = workflow_deployment_release.description
+
+    properties = {}
+    required = []
+
+    for input_var in input_variables:
+        properties[input_var.key] = _compile_deployment_workflow_input(input_var)
+
+        if input_var.required and input_var.default is None:
+            required.append(input_var.key)
+
+    parameters = {"type": "object", "properties": properties, "required": required}
+
+    return FunctionDefinition(
+        name=deployment,
+        description=description,
+        parameters=parameters,
+    )

vellum/workflows/utils/pydantic_schema.py

@@ -0,0 +1,38 @@
+import inspect
+from typing import Any, Dict
+
+from pydantic import BaseModel
+
+from vellum.workflows.utils.functions import compile_annotation
+
+
+def normalize_json(schema_input: Any) -> Any:
+    """
+    Recursively normalize JSON data by converting Pydantic models to JSON schema.
+
+    This function processes dictionaries recursively to find and convert any
+    Pydantic model classes or instances to their JSON schema representation.
+
+    Args:
+        schema_input: Can be a Pydantic model class, instance, dict, or any other value
+
+    Returns:
+        Normalized JSON data with Pydantic models converted to JSON schema
+    """
+    if isinstance(schema_input, dict):
+        return {key: normalize_json(value) for key, value in schema_input.items()}
+
+    if inspect.isclass(schema_input) and issubclass(schema_input, BaseModel):
+        defs: Dict[str, Any] = {}
+        result = compile_annotation(schema_input, defs)
+
+        if "$ref" in result and defs:
+            ref_name = result["$ref"].split("/")[-1]
+            if ref_name in defs:
+                return defs[ref_name]
+
+        return result
+    elif isinstance(schema_input, BaseModel):
+        return {key: normalize_json(getattr(schema_input, key)) for key in schema_input.__class__.model_fields.keys()}
+    else:
+        return schema_input

vellum/workflows/utils/tests/test_functions.py

@@ -1,14 +1,21 @@
 from dataclasses import dataclass
+from unittest.mock import Mock
 from typing import Dict, List, Optional, Union
 
 from pydantic import BaseModel
 
 from vellum.client.types.function_definition import FunctionDefinition
+from vellum.client.types.string_vellum_value import StringVellumValue
+from vellum.client.types.vellum_variable import VellumVariable
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.state.base import BaseState
-from vellum.workflows.utils.functions import compile_function_definition, compile_workflow_function_definition
+from vellum.workflows.utils.functions import (
+    compile_deployment_workflow_function_definition,
+    compile_function_definition,
+    compile_inline_workflow_function_definition,
+)
 
 
 def test_compile_function_definition__just_name():
@@ -299,7 +306,7 @@ def test_compile_function_definition__lambda():
     )
 
 
-def test_compile_workflow_function_definition():
+def test_compile_inline_workflow_function_definition():
     class MyNode(BaseNode):
         pass
 
@@ -307,7 +314,7 @@ def test_compile_workflow_function_definition():
         graph = MyNode
 
     # WHEN compiling the function
-    compiled_function = compile_workflow_function_definition(MyWorkflow)
+    compiled_function = compile_inline_workflow_function_definition(MyWorkflow)
 
     # THEN it should return the compiled function definition
     assert compiled_function == FunctionDefinition(
@@ -316,7 +323,7 @@ def test_compile_workflow_function_definition():
     )
 
 
-def test_compile_workflow_function_definition__docstring():
+def test_compile_inline_workflow_function_definition__docstring():
     class MyNode(BaseNode):
         pass
 
@@ -328,7 +335,7 @@ def test_compile_workflow_function_definition__docstring():
         graph = MyNode
 
     # WHEN compiling the function
-    compiled_function = compile_workflow_function_definition(MyWorkflow)
+    compiled_function = compile_inline_workflow_function_definition(MyWorkflow)
 
     # THEN it should return the compiled function definition
     assert compiled_function == FunctionDefinition(
@@ -338,7 +345,7 @@ def test_compile_workflow_function_definition__docstring():
     )
 
 
-def test_compile_workflow_function_definition__all_args():
+def test_compile_inline_workflow_function_definition__all_args():
     class MyInputs(BaseInputs):
         a: str
         b: int
@@ -354,7 +361,7 @@ def test_compile_workflow_function_definition__all_args():
         graph = MyNode
 
     # WHEN compiling the workflow
-    compiled_function = compile_workflow_function_definition(MyWorkflow)
+    compiled_function = compile_inline_workflow_function_definition(MyWorkflow)
 
     # THEN it should return the compiled function definition
     assert compiled_function == FunctionDefinition(
@@ -374,7 +381,7 @@ def test_compile_workflow_function_definition__all_args():
     )
 
 
-def test_compile_workflow_function_definition__unions():
+def test_compile_inline_workflow_function_definition__unions():
     # GIVEN a workflow with a union
     class MyInputs(BaseInputs):
         a: Union[str, int]
@@ -386,7 +393,7 @@ def test_compile_workflow_function_definition__unions():
         graph = MyNode
 
     # WHEN compiling the workflow
-    compiled_function = compile_workflow_function_definition(MyWorkflow)
+    compiled_function = compile_inline_workflow_function_definition(MyWorkflow)
 
     # THEN it should return the compiled function definition
     assert compiled_function == FunctionDefinition(
@@ -399,7 +406,7 @@ def test_compile_workflow_function_definition__unions():
     )
 
 
-def test_compile_workflow_function_definition__optionals():
+def test_compile_inline_workflow_function_definition__optionals():
     class MyInputs(BaseInputs):
         a: str
         b: Optional[str]
@@ -414,7 +421,7 @@ def test_compile_workflow_function_definition__optionals():
         graph = MyNode
 
     # WHEN compiling the workflow
-    compiled_function = compile_workflow_function_definition(MyWorkflow)
+    compiled_function = compile_inline_workflow_function_definition(MyWorkflow)
 
     # THEN it should return the compiled function definition
     assert compiled_function == FunctionDefinition(
@@ -431,3 +438,146 @@ def test_compile_workflow_function_definition__optionals():
             "required": ["a", "b", "c"],
         },
     )
+
+
+def test_compile_deployment_workflow_function_definition__just_name():
+    # GIVEN a mock Vellum client and deployment
+    mock_client = Mock()
+    mock_release = Mock()
+    mock_release.workflow_version.input_variables = []
+    mock_release.description = "This is a test deployment"
+    mock_client.release_reviews.retrieve_workflow_deployment_release.return_value = mock_release
+
+    deployment_config = {"deployment": "my_deployment", "release_tag": "latest"}
+
+    # WHEN compiling the deployment workflow function
+    compiled_function = compile_deployment_workflow_function_definition(deployment_config, mock_client)
+
+    # THEN it should return the compiled function definition (same structure as function test)
+    assert compiled_function == FunctionDefinition(
+        name="my_deployment",
+        description="This is a test deployment",
+        parameters={"type": "object", "properties": {}, "required": []},
+    )
+
+
+def test_compile_deployment_workflow_function_definition__all_args():
+    # GIVEN a mock Vellum client and deployment
+    mock_client = Mock()
+    mock_release = Mock()
+
+    mock_inputs = []
+    for key, vellum_type in [
+        ("a", "STRING"),
+        ("b", "NUMBER"),
+        ("c", "JSON"),
+        ("d", "CHAT_HISTORY"),
+        ("e", "SEARCH_RESULTS"),
+        ("f", "ERROR"),
+        ("g", "ARRAY"),
+        ("h", "FUNCTION_CALL"),
+        ("i", "IMAGE"),
+        ("j", "AUDIO"),
+        ("k", "DOCUMENT"),
+        ("l", "NULL"),
+    ]:
+        mock_input = VellumVariable(
+            id=f"input_{key}",
+            key=key,
+            type=vellum_type,
+            required=True,
+            default=None,
+        )
+        mock_inputs.append(mock_input)
+
+    mock_release.workflow_version.input_variables = mock_inputs
+    mock_release.description = "This is a test deployment"
+    mock_client.release_reviews.retrieve_workflow_deployment_release.return_value = mock_release
+
+    deployment_config = {"deployment": "my_deployment", "release_tag": "latest"}
+
+    # WHEN compiling the deployment workflow function
+    compiled_function = compile_deployment_workflow_function_definition(deployment_config, mock_client)
+
+    # THEN it should return the compiled function definition
+    assert compiled_function == FunctionDefinition(
+        name="my_deployment",
+        description="This is a test deployment",
+        parameters={
+            "type": "object",
+            "properties": {
+                "a": {"type": "string"},
+                "b": {"type": "number"},
+                "c": {"type": "object"},
+                "d": {"type": "array"},
+                "e": {"type": "array"},
+                "f": {"type": "object"},
+                "g": {"type": "array"},
+                "h": {"type": "object"},
+                "i": {"type": "object"},
+                "j": {"type": "object"},
+                "k": {"type": "object"},
+                "l": {"type": "null"},
+            },
+            "required": ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l"],
+        },
+    )
+
+
+def test_compile_deployment_workflow_function_definition__defaults():
+    # GIVEN a mock Vellum client and deployment
+    mock_client = Mock()
+    mock_release = Mock()
+
+    mock_inputs = []
+
+    mock_input_no_default = VellumVariable(
+        id="no_default",
+        key="no_default",
+        type="STRING",
+        required=True,
+        default=None,
+    )
+    mock_inputs.append(mock_input_no_default)
+
+    mock_input_null_default = VellumVariable(
+        id="null_default",
+        key="null_default",
+        type="STRING",
+        required=False,
+        default=StringVellumValue(value=None),
+    )
+    mock_inputs.append(mock_input_null_default)
+
+    mock_input_actual_default = VellumVariable(
+        id="actual_default",
+        key="actual_default",
+        type="STRING",
+        required=False,
+        default=StringVellumValue(value="hello world"),
+    )
+    mock_inputs.append(mock_input_actual_default)
+
+    mock_release.workflow_version.input_variables = mock_inputs
+    mock_release.description = "This is a test deployment"
+    mock_client.release_reviews.retrieve_workflow_deployment_release.return_value = mock_release
+
+    deployment_config = {"deployment": "my_deployment", "release_tag": "latest"}
+
+    # WHEN compiling the deployment workflow function
+    compiled_function = compile_deployment_workflow_function_definition(deployment_config, mock_client)
+
+    # THEN it should return the compiled function definition with proper default handling
+    assert compiled_function == FunctionDefinition(
+        name="my_deployment",
+        description="This is a test deployment",
+        parameters={
+            "type": "object",
+            "properties": {
+                "no_default": {"type": "string"},
+                "null_default": {"type": "string", "default": None},
+                "actual_default": {"type": "string", "default": "hello world"},
+            },
+            "required": ["no_default"],
+        },
+    )

vellum/workflows/utils/tests/test_vellum_variables.py

@@ -3,7 +3,10 @@ from typing import List, Optional
 
 from vellum import ChatMessage, SearchResult, VellumAudio, VellumDocument, VellumImage
 from vellum.workflows.types.core import Json
-from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_variable_type
+from vellum.workflows.utils.vellum_variables import (
+    primitive_type_to_vellum_variable_type,
+    vellum_variable_type_to_openapi_type,
+)
 
 
 @pytest.mark.parametrize(
@@ -31,3 +34,24 @@ from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_var
 )
 def test_primitive_type_to_vellum_variable_type(type_, expected):
     assert primitive_type_to_vellum_variable_type(type_) == expected
+
+
+@pytest.mark.parametrize(
+    "vellum_type, expected",
+    [
+        ("STRING", "string"),
+        ("NUMBER", "number"),
+        ("JSON", "object"),
+        ("CHAT_HISTORY", "array"),
+        ("SEARCH_RESULTS", "array"),
+        ("ERROR", "object"),
+        ("ARRAY", "array"),
+        ("FUNCTION_CALL", "object"),
+        ("IMAGE", "object"),
+        ("AUDIO", "object"),
+        ("DOCUMENT", "object"),
+        ("NULL", "null"),
+    ],
+)
+def test_vellum_variable_type_to_openapi_type(vellum_type, expected):
+    assert vellum_variable_type_to_openapi_type(vellum_type) == expected

vellum/workflows/utils/vellum_variables.py

@@ -78,6 +78,36 @@ def primitive_type_to_vellum_variable_type(type_: Union[Type, BaseDescriptor]) -
     return "JSON"
 
 
+def vellum_variable_type_to_openapi_type(vellum_type: VellumVariableType) -> str:
+    """Converts a VellumVariableType to a JSON schema primitive type string"""
+    if vellum_type == "STRING":
+        return "string"
+    elif vellum_type == "NUMBER":
+        return "number"
+    elif vellum_type == "JSON":
+        return "object"
+    elif vellum_type == "CHAT_HISTORY":
+        return "array"
+    elif vellum_type == "SEARCH_RESULTS":
+        return "array"
+    elif vellum_type == "ERROR":
+        return "object"
+    elif vellum_type == "ARRAY":
+        return "array"
+    elif vellum_type == "FUNCTION_CALL":
+        return "object"
+    elif vellum_type == "IMAGE":
+        return "object"
+    elif vellum_type == "AUDIO":
+        return "object"
+    elif vellum_type == "DOCUMENT":
+        return "object"
+    elif vellum_type == "NULL":
+        return "null"
+    else:
+        return "object"
+
+
 def _is_type_optionally_equal(type_: Type, target_type: Type) -> bool:
     if type_ == target_type:
         return True

vellum/workflows/workflows/base.py

@@ -42,6 +42,7 @@ from vellum.workflows.events.node import (
     NodeExecutionStreamingBody,
     NodeExecutionStreamingEvent,
 )
+from vellum.workflows.events.stream import WorkflowEventGenerator
 from vellum.workflows.events.workflow import (
     GenericWorkflowEvent,
     WorkflowExecutionFulfilledBody,
@@ -167,7 +168,7 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
         WorkflowExecutionPausedEvent,
     ]
 
-    WorkflowEventStream = Generator[WorkflowEvent, None, None]
+    WorkflowEventStream = WorkflowEventGenerator[WorkflowEvent]
 
     def __init__(
         self,
@@ -444,7 +445,7 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
         """
 
         should_yield = event_filter or workflow_event_filter
-        for event in WorkflowRunner(
+        runner_stream = WorkflowRunner(
             self,
             inputs=inputs,
             state=state,
@@ -454,9 +455,14 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
             node_output_mocks=node_output_mocks,
             max_concurrency=max_concurrency,
             init_execution_context=self._execution_context,
-        ).stream():
-            if should_yield(self.__class__, event):
-                yield event
+        ).stream()
+
+        def _generate_filtered_events() -> Generator[BaseWorkflow.WorkflowEvent, None, None]:
+            for event in runner_stream:
+                if should_yield(self.__class__, event):
+                    yield event
+
+        return WorkflowEventGenerator(_generate_filtered_events(), runner_stream.span_id)
 
     def validate(self) -> None:
         """

{vellum_ai-0.14.71.dist-info → vellum_ai-0.14.73.dist-info}/METADATA

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