vellum-ai 0.12.7__py3-none-any.whl → 0.12.9__py3-none-any.whl

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.12.7",
+            "X-Fern-SDK-Version": "0.12.9",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

vellum/evaluations/resources.py

@@ -12,8 +12,6 @@ from vellum.evaluations.constants import DEFAULT_MAX_POLLING_DURATION_MS, DEFAUL
 from vellum.evaluations.exceptions import TestSuiteRunResultsException
 from vellum.evaluations.utils.env import get_api_key
 from vellum.evaluations.utils.paginator import PaginatedResults, get_all_results
-from vellum.evaluations.utils.typing import cast_not_optional
-from vellum.evaluations.utils.uuid import is_valid_uuid
 from vellum.types import (
     ExternalTestCaseExecutionRequest,
     NamedTestCaseVariableValueRequest,
@@ -24,6 +22,8 @@ from vellum.types import (
     TestSuiteRunMetricOutput,
     TestSuiteRunState,
 )
+from vellum.utils.typing import cast_not_optional
+from vellum.utils.uuid import is_valid_uuid
 
 logger = logging.getLogger(__name__)
 

vellum/prompts/blocks/compilation.py

@@ -0,0 +1,190 @@
+import json
+from typing import Optional, cast
+
+from vellum import (
+    ChatMessage,
+    JsonVellumValue,
+    PromptBlock,
+    PromptRequestInput,
+    RichTextPromptBlock,
+    StringVellumValue,
+    VellumVariable,
+)
+from vellum.prompts.blocks.exceptions import PromptCompilationError
+from vellum.prompts.blocks.types import CompiledChatMessagePromptBlock, CompiledPromptBlock, CompiledValuePromptBlock
+from vellum.utils.templating.constants import DEFAULT_JINJA_CUSTOM_FILTERS
+from vellum.utils.templating.render import render_sandboxed_jinja_template
+from vellum.utils.typing import cast_not_optional
+
+
+def compile_prompt_blocks(
+    blocks: list[PromptBlock],
+    inputs: list[PromptRequestInput],
+    input_variables: list[VellumVariable],
+) -> list[CompiledPromptBlock]:
+    """Compiles a list of Prompt Blocks, performing all variable substitutions and Jinja templating needed."""
+
+    sanitized_inputs = _sanitize_inputs(inputs)
+
+    compiled_blocks: list[CompiledPromptBlock] = []
+    for block in blocks:
+        if block.state == "DISABLED":
+            continue
+
+        if block.block_type == "CHAT_MESSAGE":
+            chat_role = cast_not_optional(block.chat_role)
+            inner_blocks = cast_not_optional(block.blocks)
+            unterminated = block.chat_message_unterminated or False
+
+            inner_prompt_blocks = compile_prompt_blocks(
+                inner_blocks,
+                sanitized_inputs,
+                input_variables,
+            )
+            if not inner_prompt_blocks:
+                continue
+
+            compiled_blocks.append(
+                CompiledChatMessagePromptBlock(
+                    role=chat_role,
+                    unterminated=unterminated,
+                    source=block.chat_source,
+                    blocks=[inner for inner in inner_prompt_blocks if inner.block_type == "VALUE"],
+                    cache_config=block.cache_config,
+                )
+            )
+
+        elif block.block_type == "JINJA":
+            if block.template is None:
+                continue
+
+            rendered_template = render_sandboxed_jinja_template(
+                template=block.template,
+                input_values={input_.key: input_.value for input_ in sanitized_inputs},
+                jinja_custom_filters=DEFAULT_JINJA_CUSTOM_FILTERS,
+                jinja_globals=DEFAULT_JINJA_CUSTOM_FILTERS,
+            )
+            jinja_content = StringVellumValue(value=rendered_template)
+
+            compiled_blocks.append(
+                CompiledValuePromptBlock(
+                    content=jinja_content,
+                    cache_config=block.cache_config,
+                )
+            )
+
+        elif block.block_type == "VARIABLE":
+            compiled_input: Optional[PromptRequestInput] = next(
+                (input_ for input_ in sanitized_inputs if input_.key == str(block.input_variable)), None
+            )
+            if compiled_input is None:
+                raise PromptCompilationError(f"Input variable '{block.input_variable}' not found")
+
+            if compiled_input.type == "CHAT_HISTORY":
+                history = cast(list[ChatMessage], compiled_input.value)
+                chat_message_blocks = _compile_chat_messages_as_prompt_blocks(history)
+                compiled_blocks.extend(chat_message_blocks)
+                continue
+
+            if compiled_input.type == "STRING":
+                compiled_blocks.append(
+                    CompiledValuePromptBlock(
+                        content=StringVellumValue(value=compiled_input.value),
+                        cache_config=block.cache_config,
+                    )
+                )
+            elif compiled_input == "JSON":
+                compiled_blocks.append(
+                    CompiledValuePromptBlock(
+                        content=JsonVellumValue(value=compiled_input.value),
+                        cache_config=block.cache_config,
+                    )
+                )
+            elif compiled_input.type == "CHAT_HISTORY":
+                chat_message_blocks = _compile_chat_messages_as_prompt_blocks(compiled_input.value)
+                compiled_blocks.extend(chat_message_blocks)
+            else:
+                raise PromptCompilationError(f"Invalid input type for variable block: {compiled_input.type}")
+
+        elif block.block_type == "RICH_TEXT":
+            value_block = _compile_rich_text_block_as_value_block(block=block, inputs=sanitized_inputs)
+            compiled_blocks.append(value_block)
+
+        elif block.block_type == "FUNCTION_DEFINITION":
+            raise PromptCompilationError("Function definitions shouldn't go through compilation process")
+        else:
+            raise PromptCompilationError(f"Unknown block_type: {block.block_type}")
+
+    return compiled_blocks
+
+
+def _compile_chat_messages_as_prompt_blocks(chat_messages: list[ChatMessage]) -> list[CompiledChatMessagePromptBlock]:
+    blocks: list[CompiledChatMessagePromptBlock] = []
+    for chat_message in chat_messages:
+        if chat_message.content is None:
+            continue
+
+        chat_message_blocks = (
+            [
+                CompiledValuePromptBlock(
+                    content=item,
+                )
+                for item in chat_message.content.value
+            ]
+            if chat_message.content.type == "ARRAY"
+            else [
+                CompiledValuePromptBlock(
+                    content=chat_message.content,
+                )
+            ]
+        )
+
+        blocks.append(
+            CompiledChatMessagePromptBlock(
+                role=chat_message.role,
+                unterminated=False,
+                blocks=chat_message_blocks,
+                source=chat_message.source,
+            )
+        )
+
+    return blocks
+
+
+def _compile_rich_text_block_as_value_block(
+    block: RichTextPromptBlock,
+    inputs: list[PromptRequestInput],
+) -> CompiledValuePromptBlock:
+    value: str = ""
+    for child_block in block.blocks:
+        if child_block.block_type == "PLAIN_TEXT":
+            value += child_block.text
+        elif child_block.block_type == "VARIABLE":
+            variable = next((input_ for input_ in inputs if input_.key == str(child_block.input_variable)), None)
+            if variable is None:
+                raise PromptCompilationError(f"Input variable '{child_block.input_variable}' not found")
+            elif variable.type == "STRING":
+                value += str(variable.value)
+            elif variable.type == "JSON":
+                value += json.dumps(variable.value, indent=4)
+            else:
+                raise PromptCompilationError(
+                    f"Input variable '{child_block.input_variable}' must be of type STRING or JSON"
+                )
+        else:
+            raise PromptCompilationError(f"Invalid child block_type for RICH_TEXT: {child_block.block_type}")
+
+    return CompiledValuePromptBlock(content=StringVellumValue(value=value), cache_config=block.cache_config)
+
+
+def _sanitize_inputs(inputs: list[PromptRequestInput]) -> list[PromptRequestInput]:
+    sanitized_inputs: list[PromptRequestInput] = []
+    for input_ in inputs:
+        if input_.type == "CHAT_HISTORY" and input_.value is None:
+            sanitized_inputs.append(input_.model_copy(update={"value": cast(list[ChatMessage], [])}))
+        elif input_.type == "STRING" and input_.value is None:
+            sanitized_inputs.append(input_.model_copy(update={"value": ""}))
+        else:
+            sanitized_inputs.append(input_)
+
+    return sanitized_inputs

vellum/prompts/blocks/exceptions.py

@@ -0,0 +1,2 @@
+class PromptCompilationError(Exception):
+    pass

vellum/prompts/blocks/tests/test_compilation.py

@@ -0,0 +1,110 @@
+import pytest
+
+from vellum import (
+    ChatMessagePromptBlock,
+    JinjaPromptBlock,
+    PlainTextPromptBlock,
+    PromptRequestStringInput,
+    RichTextPromptBlock,
+    StringVellumValue,
+    VariablePromptBlock,
+    VellumVariable,
+)
+from vellum.prompts.blocks.compilation import compile_prompt_blocks
+from vellum.prompts.blocks.types import CompiledChatMessagePromptBlock, CompiledValuePromptBlock
+
+
+@pytest.mark.parametrize(
+    ["blocks", "inputs", "input_variables", "expected"],
+    [
+        # Empty
+        ([], [], [], []),
+        # Jinja
+        (
+            [JinjaPromptBlock(template="Hello, world!")],
+            [],
+            [],
+            [
+                CompiledValuePromptBlock(content=StringVellumValue(value="Hello, world!")),
+            ],
+        ),
+        (
+            [JinjaPromptBlock(template="Repeat back to me {{ echo }}")],
+            [PromptRequestStringInput(key="echo", value="Hello, world!")],
+            [VellumVariable(id="1", type="STRING", key="echo")],
+            [
+                CompiledValuePromptBlock(content=StringVellumValue(value="Repeat back to me Hello, world!")),
+            ],
+        ),
+        # Rich Text
+        (
+            [
+                RichTextPromptBlock(
+                    blocks=[
+                        PlainTextPromptBlock(text="Hello, world!"),
+                    ]
+                )
+            ],
+            [],
+            [],
+            [
+                CompiledValuePromptBlock(content=StringVellumValue(value="Hello, world!")),
+            ],
+        ),
+        (
+            [
+                RichTextPromptBlock(
+                    blocks=[
+                        PlainTextPromptBlock(text='Repeat back to me "'),
+                        VariablePromptBlock(input_variable="echo"),
+                        PlainTextPromptBlock(text='".'),
+                    ]
+                )
+            ],
+            [PromptRequestStringInput(key="echo", value="Hello, world!")],
+            [VellumVariable(id="901ec2d6-430c-4341-b963-ca689006f5cc", type="STRING", key="echo")],
+            [
+                CompiledValuePromptBlock(content=StringVellumValue(value='Repeat back to me "Hello, world!".')),
+            ],
+        ),
+        # Chat Message
+        (
+            [
+                ChatMessagePromptBlock(
+                    chat_role="USER",
+                    blocks=[
+                        RichTextPromptBlock(
+                            blocks=[
+                                PlainTextPromptBlock(text='Repeat back to me "'),
+                                VariablePromptBlock(input_variable="echo"),
+                                PlainTextPromptBlock(text='".'),
+                            ]
+                        )
+                    ],
+                )
+            ],
+            [PromptRequestStringInput(key="echo", value="Hello, world!")],
+            [VellumVariable(id="901ec2d6-430c-4341-b963-ca689006f5cc", type="STRING", key="echo")],
+            [
+                CompiledChatMessagePromptBlock(
+                    role="USER",
+                    blocks=[
+                        CompiledValuePromptBlock(content=StringVellumValue(value='Repeat back to me "Hello, world!".'))
+                    ],
+                ),
+            ],
+        ),
+    ],
+    ids=[
+        "empty",
+        "jinja-no-variables",
+        "jinja-with-variables",
+        "rich-text-no-variables",
+        "rich-text-with-variables",
+        "chat-message",
+    ],
+)
+def test_compile_prompt_blocks__happy(blocks, inputs, input_variables, expected):
+    actual = compile_prompt_blocks(blocks=blocks, inputs=inputs, input_variables=input_variables)
+
+    assert actual == expected

vellum/prompts/blocks/types.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from typing import Annotated, Literal, Optional, Union
+
+from vellum import ArrayVellumValue, ChatMessageRole, EphemeralPromptCacheConfig, VellumValue
+from vellum.client.core import UniversalBaseModel
+
+
+class BaseCompiledPromptBlock(UniversalBaseModel):
+    cache_config: Optional[EphemeralPromptCacheConfig] = None
+
+
+class CompiledValuePromptBlock(BaseCompiledPromptBlock):
+    block_type: Literal["VALUE"] = "VALUE"
+    content: VellumValue
+
+
+class CompiledChatMessagePromptBlock(BaseCompiledPromptBlock):
+    block_type: Literal["CHAT_MESSAGE"] = "CHAT_MESSAGE"
+    role: ChatMessageRole = "ASSISTANT"
+    unterminated: bool = False
+    blocks: list[CompiledValuePromptBlock] = []
+    source: Optional[str] = None
+
+
+CompiledPromptBlock = Annotated[
+    Union[
+        CompiledValuePromptBlock,
+        CompiledChatMessagePromptBlock,
+    ],
+    "block_type",
+]
+
+ArrayVellumValue.model_rebuild()
+
+CompiledValuePromptBlock.model_rebuild()

vellum/utils/templating/constants.py

@@ -0,0 +1,28 @@
+import datetime
+import itertools
+import json
+import random
+import re
+from typing import Any, Callable, Dict, Union
+
+import dateutil
+import pydash
+import pytz
+import yaml
+
+from vellum.utils.templating.custom_filters import is_valid_json_string
+
+DEFAULT_JINJA_GLOBALS: Dict[str, Any] = {
+    "datetime": datetime,
+    "dateutil": dateutil,
+    "itertools": itertools,
+    "json": json,
+    "pydash": pydash,
+    "pytz": pytz,
+    "random": random,
+    "re": re,
+    "yaml": yaml,
+}
+DEFAULT_JINJA_CUSTOM_FILTERS: Dict[str, Callable[[Union[str, bytes]], bool]] = {
+    "is_valid_json_string": is_valid_json_string,
+}

vellum/{workflows/nodes/core/templating_node → utils/templating}/render.py

@@ -3,7 +3,7 @@ from typing import Any, Callable, Dict, Optional, Union
 
 from jinja2.sandbox import SandboxedEnvironment
 
-from vellum.workflows.nodes.core.templating_node.exceptions import JinjaTemplateError
+from vellum.utils.templating.exceptions import JinjaTemplateError
 from vellum.workflows.state.encoder import DefaultStateEncoder
 
 

vellum/workflows/nodes/bases/__init__.py

@@ -1,7 +1,5 @@
 from .base import BaseNode
-from .base_subworkflow_node import BaseSubworkflowNode
 
 __all__ = [
     "BaseNode",
-    "BaseSubworkflowNode",
 ]

vellum/workflows/nodes/bases/base.py

@@ -344,8 +344,8 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
         all_inputs = {}
         for key, value in inputs.items():
             path_parts = key.split(".")
-            node_attribute_discriptor = getattr(self.__class__, path_parts[0])
-            inputs_key = reduce(lambda acc, part: acc[part], path_parts[1:], node_attribute_discriptor)
+            node_attribute_descriptor = getattr(self.__class__, path_parts[0])
+            inputs_key = reduce(lambda acc, part: acc[part], path_parts[1:], node_attribute_descriptor)
             all_inputs[inputs_key] = value
 
         self._inputs = MappingProxyType(all_inputs)
@@ -355,7 +355,3 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
 
     def __repr__(self) -> str:
         return str(self.__class__)
-
-
-class MyNode2(BaseNode):
-    pass

vellum/workflows/nodes/core/inline_subworkflow_node/node.py

@@ -1,12 +1,14 @@
-from typing import TYPE_CHECKING, Generic, Iterator, Optional, Set, Type, TypeVar
+from typing import TYPE_CHECKING, ClassVar, Generic, Iterator, Optional, Set, Type, TypeVar, Union
 
 from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
-from vellum.workflows.nodes.bases.base_subworkflow_node import BaseSubworkflowNode
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.state.context import WorkflowContext
+from vellum.workflows.types.core import EntityInputsInterface
 from vellum.workflows.types.generics import StateType, WorkflowInputsType
 
 if TYPE_CHECKING:
@@ -15,7 +17,7 @@ if TYPE_CHECKING:
 InnerStateType = TypeVar("InnerStateType", bound=BaseState)
 
 
-class InlineSubworkflowNode(BaseSubworkflowNode[StateType], Generic[StateType, WorkflowInputsType, InnerStateType]):
+class InlineSubworkflowNode(BaseNode[StateType], Generic[StateType, WorkflowInputsType, InnerStateType]):
     """
     Used to execute a Subworkflow defined inline.
 
@@ -24,14 +26,13 @@ class InlineSubworkflowNode(BaseSubworkflowNode[StateType], Generic[StateType, W
     """
 
     subworkflow: Type["BaseWorkflow[WorkflowInputsType, InnerStateType]"]
+    subworkflow_inputs: ClassVar[Union[EntityInputsInterface, BaseInputs]] = {}
 
     def run(self) -> Iterator[BaseOutput]:
         with execution_context(parent_context=get_parent_context() or self._context.parent_context):
             subworkflow = self.subworkflow(
                 parent_state=self.state,
-                context=WorkflowContext(
-                    _vellum_client=self._context._vellum_client,
-                ),
+                context=WorkflowContext(vellum_client=self._context.vellum_client),
             )
             subworkflow_stream = subworkflow.stream(
                 inputs=self._compile_subworkflow_inputs(),
@@ -68,4 +69,9 @@ class InlineSubworkflowNode(BaseSubworkflowNode[StateType], Generic[StateType, W
 
     def _compile_subworkflow_inputs(self) -> WorkflowInputsType:
         inputs_class = self.subworkflow.get_inputs_class()
-        return inputs_class(**self.subworkflow_inputs)
+        if 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)}")

vellum/workflows/nodes/core/inline_subworkflow_node/tests/test_node.py

@@ -0,0 +1,41 @@
+import pytest
+
+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
+from vellum.workflows.outputs.base import BaseOutput
+from vellum.workflows.state.base import BaseState
+from vellum.workflows.workflows.base import BaseWorkflow
+
+
+class Inputs(BaseInputs):
+    foo: str
+
+
+class MyInnerNode(BaseNode):
+    class Outputs(BaseNode.Outputs):
+        out = Inputs.foo
+
+
+class MySubworkflow(BaseWorkflow[Inputs, BaseState]):
+    graph = MyInnerNode
+
+    class Outputs(BaseWorkflow.Outputs):
+        out = MyInnerNode.Outputs.out
+
+
+@pytest.mark.parametrize("inputs", [{"foo": "bar"}, Inputs(foo="bar")])
+def test_inline_subworkflow_node__inputs(inputs):
+    # GIVEN a node setup with subworkflow inputs
+    class MyNode(InlineSubworkflowNode):
+        subworkflow = MySubworkflow
+        subworkflow_inputs = inputs
+
+    # WHEN the node is run
+    node = MyNode()
+    events = list(node.run())
+
+    # THEN the output is as expected
+    assert events == [
+        BaseOutput(name="out", value="bar"),
+    ]

vellum/workflows/nodes/core/map_node/node.py

@@ -108,7 +108,7 @@ class MapNode(BaseNode, Generic[StateType, MapNodeItemType]):
             self._run_subworkflow(item=item, index=index)
 
     def _run_subworkflow(self, *, item: MapNodeItemType, index: int) -> None:
-        context = WorkflowContext(_vellum_client=self._context._vellum_client)
+        context = WorkflowContext(vellum_client=self._context.vellum_client)
         subworkflow = self.subworkflow(parent_state=self.state, context=context)
         events = subworkflow.stream(
             inputs=self.SubworkflowInputs(index=index, item=item, all_items=self.items),

vellum/workflows/nodes/core/templating_node/node.py

@@ -1,42 +1,17 @@
-import datetime
-import itertools
 import json
-import random
-import re
 from typing import Any, Callable, ClassVar, Dict, Generic, Mapping, Tuple, Type, TypeVar, Union, get_args
 
-import dateutil.parser
-import pydash
-import pytz
-import yaml
-
+from vellum.utils.templating.constants import DEFAULT_JINJA_CUSTOM_FILTERS, DEFAULT_JINJA_GLOBALS
+from vellum.utils.templating.exceptions import JinjaTemplateError
+from vellum.utils.templating.render import render_sandboxed_jinja_template
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.bases.base import BaseNodeMeta
-from vellum.workflows.nodes.core.templating_node.custom_filters import is_valid_json_string
-from vellum.workflows.nodes.core.templating_node.exceptions import JinjaTemplateError
-from vellum.workflows.nodes.core.templating_node.render import render_sandboxed_jinja_template
-from vellum.workflows.types.core import EntityInputsInterface
+from vellum.workflows.types.core import EntityInputsInterface, Json
 from vellum.workflows.types.generics import StateType
 from vellum.workflows.types.utils import get_original_base
 
-_DEFAULT_JINJA_GLOBALS: Dict[str, Any] = {
-    "datetime": datetime,
-    "dateutil": dateutil,
-    "itertools": itertools,
-    "json": json,
-    "pydash": pydash,
-    "pytz": pytz,
-    "random": random,
-    "re": re,
-    "yaml": yaml,
-}
-
-_DEFAULT_JINJA_CUSTOM_FILTERS: Dict[str, Callable[[Union[str, bytes]], bool]] = {
-    "is_valid_json_string": is_valid_json_string,
-}
-
 _OutputType = TypeVar("_OutputType")
 
 
@@ -78,8 +53,8 @@ class TemplatingNode(BaseNode[StateType], Generic[StateType, _OutputType], metac
     # The inputs to render the template with.
     inputs: ClassVar[EntityInputsInterface]
 
-    jinja_globals: Dict[str, Any] = _DEFAULT_JINJA_GLOBALS
-    jinja_custom_filters: Mapping[str, Callable[[Union[str, bytes]], bool]] = _DEFAULT_JINJA_CUSTOM_FILTERS
+    jinja_globals: Dict[str, Any] = DEFAULT_JINJA_GLOBALS
+    jinja_custom_filters: Mapping[str, Callable[[Union[str, bytes]], bool]] = DEFAULT_JINJA_CUSTOM_FILTERS
 
     class Outputs(BaseNode.Outputs):
         """
@@ -113,6 +88,12 @@ class TemplatingNode(BaseNode[StateType], Generic[StateType, _OutputType], metac
         if output_type is bool:
             return bool(rendered_template)
 
+        if output_type is Json:
+            try:
+                return json.loads(rendered_template)
+            except json.JSONDecodeError:
+                raise ValueError("Invalid JSON format for rendered_template")
+
         raise ValueError(f"Unsupported output type: {output_type}")
 
     def run(self) -> Outputs: