vellum-ai 0.12.7__tar.gz → 0.12.8__tar.gz

{vellum_ai-0.12.7 → vellum_ai-0.12.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 0.12.7
+Version: 0.12.8
 Summary: 
 License: MIT
 Requires-Python: >=3.9,<4.0
@@ -25,6 +25,7 @@ Requires-Dist: cdktf (>=0.20.5,<0.21.0)
 Requires-Dist: click (==8.1.7)
 Requires-Dist: docker (==7.1.0)
 Requires-Dist: httpx (>=0.21.2)
+Requires-Dist: openai (>=1.0.0)
 Requires-Dist: orderly-set (>=5.2.2,<6.0.0)
 Requires-Dist: publication (==0.0.3)
 Requires-Dist: pydantic (>=1.9.2)

{vellum_ai-0.12.7 → vellum_ai-0.12.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vellum-ai"
-version = "0.12.7"
+version = "0.12.8"
 description = ""
 readme = "README.md"
 authors = []
@@ -40,6 +40,7 @@ cdktf = "^0.20.5"
 click = "8.1.7"
 docker = "7.1.0"
 httpx = ">=0.21.2"
+openai = ">= 1.0.0"
 orderly-set = "^5.2.2"
 publication = "0.0.3"
 pydantic = ">= 1.9.2"

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

{vellum_ai-0.12.7 → vellum_ai-0.12.8}/src/vellum/evaluations/resources.py

@@ -12,7 +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,
@@ -24,6 +23,7 @@ from vellum.types import (
     TestSuiteRunMetricOutput,
     TestSuiteRunState,
 )
+from vellum.utils.typing import cast_not_optional
 
 logger = logging.getLogger(__name__)
 

vellum_ai-0.12.8/src/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 ValueError(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 ValueError("Function definitions shouldn't go through compilation process")
+        else:
+            raise ValueError(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 ValueError(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_ai-0.12.8/src/vellum/prompts/blocks/exceptions.py

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

vellum_ai-0.12.8/src/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_ai-0.12.8/src/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_ai-0.12.8/src/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_ai-0.12.7/src/vellum/workflows/nodes/core/templating_node → vellum_ai-0.12.8/src/vellum/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_ai-0.12.7 → vellum_ai-0.12.8}/src/vellum/workflows/nodes/core/templating_node/node.py

@@ -1,42 +1,16 @@
-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.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 +52,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):
         """

vellum_ai-0.12.8/src/vellum/workflows/nodes/experimental/README.md

@@ -0,0 +1,6 @@
+# 🧪 Experimental
+
+This section is a proofing ground for new ideas and concepts. It's not meant to be used in production and is
+subject to breaking changes at any time.
+
+If a concept within is sufficiently interesting and validated, then it may be introduced as a first-class node.

vellum_ai-0.12.8/src/vellum/workflows/nodes/experimental/openai_chat_completion_node/__init__.py

@@ -0,0 +1,5 @@
+from .node import OpenAIChatCompletionNode
+
+__all__ = [
+    "OpenAIChatCompletionNode",
+]