vellum-ai 0.12.7__py3-none-any.whl → 0.12.8__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.8",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

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/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/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/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/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/workflows/nodes/experimental/openai_chat_completion_node/__init__.py

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

vellum/workflows/nodes/experimental/openai_chat_completion_node/node.py

@@ -0,0 +1,260 @@
+import json
+import logging
+import os
+from uuid import uuid4
+from typing import Any, Iterable, Iterator, List, Literal, Union, cast
+
+from openai import OpenAI
+from openai.types.chat import (
+    ChatCompletionAssistantMessageParam,
+    ChatCompletionContentPartImageParam,
+    ChatCompletionContentPartInputAudioParam,
+    ChatCompletionContentPartParam,
+    ChatCompletionContentPartRefusalParam,
+    ChatCompletionContentPartTextParam,
+    ChatCompletionMessageParam,
+    ChatCompletionSystemMessageParam,
+    ChatCompletionUserMessageParam,
+)
+from openai.types.chat.chat_completion_chunk import Choice
+
+from vellum import (
+    AdHocExecutePromptEvent,
+    FulfilledAdHocExecutePromptEvent,
+    InitiatedAdHocExecutePromptEvent,
+    RejectedAdHocExecutePromptEvent,
+    StreamingAdHocExecutePromptEvent,
+    StringVellumValue,
+    VellumAudio,
+    VellumError,
+)
+from vellum.prompts.blocks.compilation import compile_prompt_blocks
+from vellum.prompts.blocks.types import CompiledChatMessagePromptBlock
+from vellum.workflows.errors import WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.nodes import InlinePromptNode
+from vellum.workflows.types.generics import StateType
+
+logger = logging.getLogger(__name__)
+
+
+class OpenAIChatCompletionNode(InlinePromptNode[StateType]):
+    """
+    Used to execute a Prompt using the OpenAI API.
+    """
+
+    # Override
+    def _get_prompt_event_stream(self) -> Iterator[AdHocExecutePromptEvent]:
+        client = self._get_client()
+
+        execution_id = str(uuid4())
+
+        yield InitiatedAdHocExecutePromptEvent(
+            execution_id=execution_id,
+        )
+
+        try:
+            stream = client.chat.completions.create(
+                messages=self._get_messages(),
+                model=self.ml_model,
+                # TODO: Add support for additional parameters
+                stream=True,
+            )
+        except Exception as exc:
+            yield RejectedAdHocExecutePromptEvent(
+                error=VellumError(
+                    code=WorkflowErrorCode.PROVIDER_ERROR,
+                    message=exc.args[0],
+                ),
+                execution_id=execution_id,
+            )
+            return
+
+        combined_delta_content = ""
+        for chunk in stream:
+            choices: List[Choice] = chunk.choices
+            if len(choices) != 1:
+                yield RejectedAdHocExecutePromptEvent(
+                    error=VellumError(
+                        code=WorkflowErrorCode.PROVIDER_ERROR,
+                        message="Expected one choice per chunk, but found more than one.",
+                    ),
+                    execution_id=execution_id,
+                )
+                return
+
+            choice = choices[0]
+            delta = choice.delta
+
+            if delta.tool_calls:
+                # TODO: Add support for tool calls
+                raise NotImplementedError("This node hasn't been extended to support tool calling yet.")
+
+            if delta.content:
+                combined_delta_content += delta.content
+
+            StreamingAdHocExecutePromptEvent(
+                output=StringVellumValue(value=delta.content),
+                # TODO: Add support for multiple outputs
+                output_index=1,
+                execution_id=execution_id,
+            )
+
+        yield FulfilledAdHocExecutePromptEvent(
+            # TODO: Add support for multiple outputs
+            outputs=[
+                StringVellumValue(value=combined_delta_content),
+            ],
+            execution_id=execution_id,
+        )
+
+    def _get_client(self) -> OpenAI:
+        """Used to retrieve an API client for interacting with the OpenAI API.
+
+        Note: This method can be overridden if you'd like to use your own API client that conforms to the same
+            interfaces as that of OpenAI.
+        """
+
+        openai_api_key = os.environ.get("OPENAI_API_KEY")
+
+        if not openai_api_key:
+            raise NodeException(
+                code=WorkflowErrorCode.INTERNAL_ERROR,
+                message="Unable to determine an OpenAI API key.",
+            )
+
+        client = OpenAI(api_key=openai_api_key)
+        return client
+
+    def _get_messages(self) -> Iterable[ChatCompletionMessageParam]:
+        input_variables, input_values = self._compile_prompt_inputs()
+
+        compiled_blocks = compile_prompt_blocks(
+            blocks=self.blocks, inputs=input_values, input_variables=input_variables
+        )
+
+        chat_message_blocks: list[CompiledChatMessagePromptBlock] = [
+            block for block in compiled_blocks if block.block_type == "CHAT_MESSAGE"
+        ]
+        messages = [self._create_message(block) for block in chat_message_blocks]
+
+        return messages
+
+    @classmethod
+    def _create_message(cls, chat_message_block: CompiledChatMessagePromptBlock) -> ChatCompletionMessageParam:
+        name = chat_message_block.source
+        content = cls._create_message_content(chat_message_block)
+
+        if chat_message_block.role == "SYSTEM":
+            relevant_system_content = [
+                cast(ChatCompletionContentPartTextParam, c) for c in content if c["type"] == "text"
+            ]
+            system_message: ChatCompletionSystemMessageParam = {
+                "content": relevant_system_content,
+                "role": "system",
+            }
+            if name:
+                system_message["name"] = name
+
+            return system_message
+        elif chat_message_block.role == "USER":
+            user_message: ChatCompletionUserMessageParam = {
+                "content": content,
+                "role": "user",
+            }
+            if name:
+                user_message["name"] = name
+
+            return user_message
+        elif chat_message_block.role == "ASSISTANT":
+            relevant_assistant_content = [
+                cast(Union[ChatCompletionContentPartTextParam, ChatCompletionContentPartRefusalParam], c)
+                for c in content
+                if c["type"] in ["text", "refusal"]
+            ]
+            assistant_message: ChatCompletionAssistantMessageParam = {
+                "content": relevant_assistant_content,
+                "role": "assistant",
+            }
+            if name:
+                assistant_message["name"] = name
+
+            return assistant_message
+        else:
+            logger.error(f"Unexpected role: {chat_message_block.role}")
+            raise NodeException(
+                code=WorkflowErrorCode.INTERNAL_ERROR, message="Unexpected role found when compiling prompt blocks"
+            )
+
+    @classmethod
+    def _create_message_content(
+        cls,
+        chat_message_block: CompiledChatMessagePromptBlock,
+    ) -> List[ChatCompletionContentPartParam]:
+        content: List[ChatCompletionContentPartParam] = []
+        for block in chat_message_block.blocks:
+            if block.content.type == "STRING":
+                string_value = cast(str, block.content.value)
+                string_content_item: ChatCompletionContentPartTextParam = {"type": "text", "text": string_value}
+                content.append(string_content_item)
+            elif block.content.type == "JSON":
+                json_value = cast(Any, block.content.value)
+                json_content_item: ChatCompletionContentPartTextParam = {"type": "text", "text": json.dumps(json_value)}
+                content.append(json_content_item)
+            elif block.content.type == "IMAGE":
+                image_value = cast(VellumAudio, block.content.value)
+                image_content_item: ChatCompletionContentPartImageParam = {
+                    "type": "image_url",
+                    "image_url": {"url": image_value.src},
+                }
+                if image_value.metadata and image_value.metadata.get("detail"):
+                    detail = image_value.metadata["detail"]
+
+                    if detail not in ["auto", "low", "high"]:
+                        raise NodeException(
+                            code=WorkflowErrorCode.INTERNAL_ERROR,
+                            message="Image detail must be one of 'auto', 'low', or 'high.",
+                        )
+
+                    image_content_item["image_url"]["detail"] = cast(Literal["auto", "low", "high"], detail)
+
+                content.append(image_content_item)
+            elif block.content.type == "AUDIO":
+                audio_value = cast(VellumAudio, block.content.value)
+                audio_value_src_parts = audio_value.src.split(",")
+                if len(audio_value_src_parts) != 2:
+                    raise NodeException(
+                        code=WorkflowErrorCode.INTERNAL_ERROR, message="Audio data is not properly encoded."
+                    )
+                _, cleaned_audio_value = audio_value_src_parts
+                if not audio_value.metadata:
+                    raise NodeException(
+                        code=WorkflowErrorCode.INTERNAL_ERROR, message="Audio metadata is required for audio input."
+                    )
+                audio_format = audio_value.metadata.get("format")
+                if not audio_format:
+                    raise NodeException(
+                        code=WorkflowErrorCode.INTERNAL_ERROR, message="Audio format is required for audio input."
+                    )
+                if audio_format not in {"wav", "mp3"}:
+                    raise NodeException(
+                        code=WorkflowErrorCode.INTERNAL_ERROR,
+                        message="Audio format must be one of 'wav' or 'mp3'.",
+                    )
+
+                audio_content_item: ChatCompletionContentPartInputAudioParam = {
+                    "type": "input_audio",
+                    "input_audio": {
+                        "data": cleaned_audio_value,
+                        "format": cast(Literal["wav", "mp3"], audio_format),
+                    },
+                }
+
+                content.append(audio_content_item)
+            else:
+                raise NodeException(
+                    code=WorkflowErrorCode.INTERNAL_ERROR,
+                    message=f"Failed to parse chat message block {block.content.type}",
+                )
+
+        return content

vellum/workflows/sandbox.py

@@ -49,3 +49,6 @@ class SandboxRunner(Generic[WorkflowType]):
                 self._logger.info(f"Just started Node: {event.node_definition.__name__}")
             elif event.name == "node.execution.fulfilled":
                 self._logger.info(f"Just finished Node: {event.node_definition.__name__}")
+            elif event.name == "node.execution.rejected":
+                self._logger.debug(f"Error: {event.error}")
+                self._logger.error(f"Failed to run Node: {event.node_definition.__name__}")

{vellum_ai-0.12.7.dist-info → vellum_ai-0.12.8.dist-info}/METADATA

@@ -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.dist-info → vellum_ai-0.12.8.dist-info}/RECORD

@@ -76,7 +76,7 @@ vellum/client/README.md,sha256=JkCJjmMZl4jrPj46pkmL9dpK4gSzQQmP5I7z4aME4LY,4749
 vellum/client/__init__.py,sha256=o4m7iRZWEV8rP3GkdaztHAjNmjxjWERlarviFoHzuKI,110927
 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=RUr-cX1j7KxfabSh_XadU_QRvmolEu273OpLtcRINs8,1868
+vellum/client/core/client_wrapper.py,sha256=oWk19_A_3mvqQM_W3wJgQnObX6YIE918NEp9olVAuEo,1868
 vellum/client/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 vellum/client/core/file.py,sha256=X9IbmkZmB2bB_DpmZAO3crWdXagOakAyn6UCOCImCPg,2322
 vellum/client/core/http_client.py,sha256=R0pQpCppnEtxccGvXl4uJ76s7ro_65Fo_erlNNLp_AI,19228
@@ -649,17 +649,23 @@ vellum/errors/not_found_error.py,sha256=gC71YBdPyHR46l3RNTs0v9taVvAY0gWRFrcKpKzb
 vellum/evaluations/__init__.py,sha256=hNsLoHSykqXDJP-MwFvu2lExImxo9KEyEJjt_fdAzpE,77
 vellum/evaluations/constants.py,sha256=Vteml4_csZsMgo_q3-71E3JRCAoN6308TXLu5nfLhmU,116
 vellum/evaluations/exceptions.py,sha256=6Xacoyv43fJvVf6Dt6Io5a-f9vF12Tx51jzsQRNSqhY,56
-vellum/evaluations/resources.py,sha256=8-gqAxLnVtDQrHYy73RAGIzomeD6uX_3b_yhmFR9I3g,12688
+vellum/evaluations/resources.py,sha256=33IDRHOjrRsC20JHs0BtRlaSYCY9Gg-AkA6qkPjBrWo,12676
 vellum/evaluations/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/evaluations/utils/env.py,sha256=Xj_nxsoU5ox06EOTjRopR4lrigQI6Le6qbWGltYoEGU,276
 vellum/evaluations/utils/exceptions.py,sha256=dXMAkzqbHV_AP5FjjbegPlfUE0zQDlpA3qOsoOJUxfg,49
 vellum/evaluations/utils/paginator.py,sha256=rEED_BJAXAM6tM1yMwHePNzszjq_tTq4NbQvi1jWQ_Q,697
-vellum/evaluations/utils/typing.py,sha256=wx_daFqD69cYkuJTVnvNrpjhqC3uuhbnyJ9_bIwC9OU,327
 vellum/evaluations/utils/uuid.py,sha256=Ch6wWRgwICxLxJCTl5iE3EdRlZj2zADR-zUMUtjcMWM,214
 vellum/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/plugins/pydantic.py,sha256=EbI0pJMhUS9rLPSkzmAELfnCHrWCJzOrU06T8ommwdw,2334
 vellum/plugins/utils.py,sha256=U9ZY9KdE3RRvbcG01hXxu9CvfJD6Fo7nJDgcHjQn0FI,606
 vellum/plugins/vellum_mypy.py,sha256=VC15EzjTsXOb9uF1bky4rcxePP-0epMVmCsLB2z4Dh8,24816
+vellum/prompts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vellum/prompts/blocks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vellum/prompts/blocks/compilation.py,sha256=hBN_ajq77tSkVyUIcDlO-Qu77PSeJ1OzVhp70NmQd2k,7458
+vellum/prompts/blocks/exceptions.py,sha256=vmk5PV6Vyw9nKjZYQDUDW0LH8MfQNIgFvFb_mFWdIRI,50
+vellum/prompts/blocks/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vellum/prompts/blocks/tests/test_compilation.py,sha256=0DhMoc4huHR6YnNL-0aBLmWSyUfw2BpRq_gEdKsQmAc,3693
+vellum/prompts/blocks/types.py,sha256=6aSJQco-5kKeadfKVVXF_SrQPlIJgMYVNc-C7so1sY8,975
 vellum/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/resources/__init__.py,sha256=sQWK7g_Z4EM7pa7fy6vy3d_DMdTJ4wVcozBn3Lx4Qpo,141
 vellum/resources/ad_hoc/__init__.py,sha256=UD01D9nS_M7sRKmMbEg4Tv9SlfFj3cWahVxwUEaSLAY,148
@@ -1197,6 +1203,13 @@ vellum/types/workflow_result_event_output_data_search_results.py,sha256=UNfCHLQ0
 vellum/types/workflow_result_event_output_data_string.py,sha256=rHEVbN0nyf-xoDoSIUEKlUKh6DDoguer4w0iN18JQ2I,178
 vellum/types/workflow_stream_event.py,sha256=PjHGgN0eJm5w-5FJ6__ASC1FU94Gsav_ko5JWkpVvK8,159
 vellum/types/workspace_secret_read.py,sha256=Z6QNXHxVHRdrLXSI31KxngePRwJTVoJYMXVbtPQwrxs,159
+vellum/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vellum/utils/templating/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vellum/utils/templating/constants.py,sha256=XTNmDsKa7byjw4GMZmzx2dUeYUTeMLZrPgRHcc80Kvc,613
+vellum/utils/templating/custom_filters.py,sha256=Q0DahYRHP4KfaUXDt9XxN-DFLBrAxlv90yaVqxScoUw,264
+vellum/utils/templating/exceptions.py,sha256=cDp140PP4OnInW4qAvg3KqiSiF70C71UyEAKRBR1Abo,46
+vellum/utils/templating/render.py,sha256=0vgkwhu2A6o64aT4fUdTSLFCEMbeRjAKAuvv2k2LYGY,1772
+vellum/utils/typing.py,sha256=wx_daFqD69cYkuJTVnvNrpjhqC3uuhbnyJ9_bIwC9OU,327
 vellum/version.py,sha256=jq-1PlAYxN9AXuaZqbYk9ak27SgE2lw9Ia5gx1b1gVI,76
 vellum/workflows/README.md,sha256=MLNm-ihc0ao6I8gwwOhXQQBf0jOf-EsA9C519ALYI1o,3610
 vellum/workflows/__init__.py,sha256=CssPsbNvN6rDhoLuqpEv7MMKGa51vE6dvAh6U31Pcio,71
@@ -1278,10 +1291,7 @@ vellum/workflows/nodes/core/retry_node/node.py,sha256=IjNcpzFmHyBUjOHEoULLbKf85B
 vellum/workflows/nodes/core/retry_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/core/retry_node/tests/test_node.py,sha256=QXTnHwmJHISxXjvZMeuuEo0iVugVMJyaJoggI8yKXfI,3132
 vellum/workflows/nodes/core/templating_node/__init__.py,sha256=GmyuYo81_A1_Bz6id69ozVFS6FKiuDsZTiA3I6MaL2U,70
-vellum/workflows/nodes/core/templating_node/custom_filters.py,sha256=Q0DahYRHP4KfaUXDt9XxN-DFLBrAxlv90yaVqxScoUw,264
-vellum/workflows/nodes/core/templating_node/exceptions.py,sha256=cDp140PP4OnInW4qAvg3KqiSiF70C71UyEAKRBR1Abo,46
-vellum/workflows/nodes/core/templating_node/node.py,sha256=Q5U5lAW1nhGFJPc94Gxnq1s5RWrbOo7G_AY4n-ABmGg,4504
-vellum/workflows/nodes/core/templating_node/render.py,sha256=OpJp0NAH6qcEL6K9lxR0qjpFb75TYNttJR5iCos8tmg,1792
+vellum/workflows/nodes/core/templating_node/node.py,sha256=mWNzsa6TLosrD3higKIsiqEv54OIfNY7YzFDkuQgm6k,3964
 vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py,sha256=0BtXeSix7KGIuKzlPFTMLATpNnFPhut1UV_srGptkt0,1120
 vellum/workflows/nodes/core/try_node/__init__.py,sha256=JVD4DrldTIqFQQFrubs9KtWCCc0YCAc7Fzol5ZWIWeM,56
 vellum/workflows/nodes/core/try_node/node.py,sha256=_xkpUNIfHXuwjivMBxdU5DegsNge2ITW5nBifWmBPTY,6670
@@ -1331,6 +1341,10 @@ vellum/workflows/nodes/displayable/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5
 vellum/workflows/nodes/displayable/tests/test_inline_text_prompt_node.py,sha256=UI_RMmXn9qwB-StnFPvkDd9FctBQAg43wrfouqvPepk,4701
 vellum/workflows/nodes/displayable/tests/test_search_node_wth_text_output.py,sha256=4CMwDtXwTaEvFfDpA6j2iLqc7S6IICSkvVZOobEpeps,6954
 vellum/workflows/nodes/displayable/tests/test_text_prompt_deployment_node.py,sha256=KqKJtJ0vuNoPuUPMdILmBTt4a2fBBxxun-nmOI7T8jo,2585
+vellum/workflows/nodes/experimental/README.md,sha256=eF6DfIL8t-HbF9-mcofOMymKrraiBHDLKTlnBa51ZiE,284
+vellum/workflows/nodes/experimental/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vellum/workflows/nodes/experimental/openai_chat_completion_node/__init__.py,sha256=lsyD9laR9p7kx5-BXGH2gUTM242UhKy8SMV0SR6S2iE,90
+vellum/workflows/nodes/experimental/openai_chat_completion_node/node.py,sha256=1EGeiaT-Zoo6pttQFKKBcdf3dmhAbjKGaErYD5FFwlc,10185
 vellum/workflows/nodes/utils.py,sha256=EZt7CzJmgQBR_GWFpZr8d-oaoti3tolTd2Cv9wm7dKo,1087
 vellum/workflows/outputs/__init__.py,sha256=AyZ4pRh_ACQIGvkf0byJO46EDnSix1ZCAXfvh-ms1QE,94
 vellum/workflows/outputs/base.py,sha256=a7W6rNSDSawwGAXYjNTF2iHb9lnZu7WFSOagZIyy__k,7976
@@ -1353,7 +1367,7 @@ vellum/workflows/resolvers/__init__.py,sha256=eH6hTvZO4IciDaf_cf7aM2vs-DkBDyJPyc
 vellum/workflows/resolvers/base.py,sha256=WHra9LRtlTuB1jmuNqkfVE2JUgB61Cyntn8f0b0WZg4,411
 vellum/workflows/runner/__init__.py,sha256=i1iG5sAhtpdsrlvwgH6B-m49JsINkiWyPWs8vyT-bqM,72
 vellum/workflows/runner/runner.py,sha256=RXnLEmSJFbp0u4vKF7rvD2fscuYfcRYkspIJINnvFAI,27607
-vellum/workflows/sandbox.py,sha256=wNyOfd3gb6-O85EQcBIHNCnSYPH7Oufh2z4hQnR2HFU,2059
+vellum/workflows/sandbox.py,sha256=1aL5BoUgJX6dbIN3pqui20Wk3VyzXV16BUaZz-clmFs,2269
 vellum/workflows/state/__init__.py,sha256=yUUdR-_Vl7UiixNDYQZ-GEM_kJI9dnOia75TtuNEsnE,60
 vellum/workflows/state/base.py,sha256=jpSzF1OQd3-fqi6dMGlNsQl-7JnJxCdzWIigmX8Wz-I,14425
 vellum/workflows/state/context.py,sha256=oXiEdNsWJi1coRB85IreTgUeR6_CrWWBXndtLff9S7M,1272
@@ -1384,8 +1398,8 @@ vellum/workflows/vellum_client.py,sha256=ODrq_TSl-drX2aezXegf7pizpWDVJuTXH-j6528
 vellum/workflows/workflows/__init__.py,sha256=KY45TqvavCCvXIkyCFMEc0dc6jTMOUci93U2DUrlZYc,66
 vellum/workflows/workflows/base.py,sha256=zpspOEdO5Ye_0ZvN-Wkzv9iQSiF1sD201ba8lhbnPbs,17086
 vellum/workflows/workflows/event_filters.py,sha256=GSxIgwrX26a1Smfd-6yss2abGCnadGsrSZGa7t7LpJA,2008
-vellum_ai-0.12.7.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.12.7.dist-info/METADATA,sha256=czpJHlepxy2KrSpZireMIgDjpv_QdMBAK-g33oxoI3U,5128
-vellum_ai-0.12.7.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-0.12.7.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.12.7.dist-info/RECORD,,
+vellum_ai-0.12.8.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-0.12.8.dist-info/METADATA,sha256=FI7BG5Gx3Dd3exq5uqBWnHu8kuqFrVpE_9tcdUuYwdk,5160
+vellum_ai-0.12.8.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-0.12.8.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-0.12.8.dist-info/RECORD,,