vellum-ai 0.12.6__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.6",
+            "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.6.dist-info → vellum_ai-0.12.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 0.12.6
+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.6.dist-info → vellum_ai-0.12.8.dist-info}/RECORD

@@ -1,17 +1,17 @@
 vellum_cli/CONTRIBUTING.md,sha256=FtDC7BGxSeMnwCXAUssFsAIElXtmJE-O5Z7BpolcgvI,2935
 vellum_cli/README.md,sha256=2NudRoLzWxNKqnuVy1JuQ7DerIaxWGYkrH8kMd-asIE,90
-vellum_cli/__init__.py,sha256=A9uo9OE7xQACNEtX4k0c-rxypDqS5V8kA8u4BNN0azM,7402
+vellum_cli/__init__.py,sha256=iims87aL6HbwggCAh8JfLBNf3C7tN3TGDmlg7V5W9Lg,8506
 vellum_cli/aliased_group.py,sha256=ugW498j0yv4ALJ8vS9MsO7ctDW7Jlir9j6nE_uHAP8c,3363
 vellum_cli/config.py,sha256=wJQnv3tCgu1BOugg0AOP94yQ-x1yAg8juX_QoFN9Y7w,5223
 vellum_cli/image_push.py,sha256=SJwhwWJsLjwGNezNVd_oCVpFMfPsAB3dfLWmriZZUtw,4419
 vellum_cli/logger.py,sha256=PuRFa0WCh4sAGFS5aqWB0QIYpS6nBWwPJrIXpWxugV4,1022
-vellum_cli/pull.py,sha256=q68fr1o5H9l8Dvc8BTY1GARJYjAV1i6Fg-Lg4Oo4FDw,6155
+vellum_cli/pull.py,sha256=AfSQLHwTeq_T22iRbGyefnmrPiddIKb_fqPMSoTlN0Y,6832
 vellum_cli/push.py,sha256=gcYhIogeYejZIhNm5Cjp0VBECaXLmVQEvZjrPH0-TSU,5337
 vellum_cli/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_cli/tests/conftest.py,sha256=eFGwBxib3Nki830lIFintB0b6r4x8T_KMnmzhlTY5x0,1337
 vellum_cli/tests/test_config.py,sha256=uvKGDc8BoVyT9_H0Z-g8469zVxomn6Oi3Zj-vK7O_wU,2631
 vellum_cli/tests/test_main.py,sha256=qDZG-aQauPwBwM6A2DIu1494n47v3pL28XakTbLGZ-k,272
-vellum_cli/tests/test_pull.py,sha256=P2JFNHU1hE6iydYl7rW35h7c8_DSrLiAS7gNsFMy1JU,17829
+vellum_cli/tests/test_pull.py,sha256=Bnf21VjfiRb_j495idz5N8afucagtiktNCtVMvU8tGs,18977
 vellum_cli/tests/test_push.py,sha256=V2iGcskh2X3OHj2uV5Vx_BhmtyfmUkyx0lrp8DDOExc,5824
 vellum_ee/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -28,12 +28,12 @@ vellum_ee/workflows/display/nodes/types.py,sha256=St1BB6no528OyELGiyRabWao0GGw6m
 vellum_ee/workflows/display/nodes/utils.py,sha256=sloya5TpXsnot1HURc9L51INwflRqUzHxRVnCS9Cd-4,973
 vellum_ee/workflows/display/nodes/vellum/__init__.py,sha256=nmPLj8vkbVCS46XQqmHq8Xj8Mr36wCK_vWf26A9KIkw,1505
 vellum_ee/workflows/display/nodes/vellum/api_node.py,sha256=4SSQGecKWHuoGy5YIGJeOZVHGKwTs_8Y-gf3GvsHb0M,8506
-vellum_ee/workflows/display/nodes/vellum/code_execution_node.py,sha256=XqizRn5bLwT8LMwgyvfbln8inhCxzTi1EkD22Fx-5-U,4222
+vellum_ee/workflows/display/nodes/vellum/code_execution_node.py,sha256=qrf2Ne8n2aaoa2xgK3ExCEGI9BA-2g1zmvjSHyzCWmQ,4230
 vellum_ee/workflows/display/nodes/vellum/conditional_node.py,sha256=EtdqJfhYw03PuT2iyJ6mSAZK4RsQqDie_2AnJAtMelk,13625
 vellum_ee/workflows/display/nodes/vellum/error_node.py,sha256=ygTjSjYDI4DtkxADWub5rhBnRWItMKWF6fezBrgpOKA,1979
 vellum_ee/workflows/display/nodes/vellum/final_output_node.py,sha256=t5iJQVoRT5g-v2IiUb4kFYdvUVKch0zn27016pzDZoo,2761
 vellum_ee/workflows/display/nodes/vellum/guardrail_node.py,sha256=3TJvHX_Uuf_gr94VkYc_zmNH8I5p71ChIeoAbJZ3ddY,2158
-vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py,sha256=E7U4B05-KSlPvTp0nYQTtGPkNa5563VxrNBQmKwvTqw,7267
+vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py,sha256=DYhxHgFT06CNCpovO4Z-wFPqCjFKxyl89ygFs8AucRQ,7189
 vellum_ee/workflows/display/nodes/vellum/inline_subworkflow_node.py,sha256=x5wiuWbRjxNcPGu8BoBEKHwPeqCpHE-vrGjAdM5TJOs,4721
 vellum_ee/workflows/display/nodes/vellum/map_node.py,sha256=AqUlItgSZij12qRKguKVmDbbaLuDy3Cdom5uOlJPqrc,3640
 vellum_ee/workflows/display/nodes/vellum/merge_node.py,sha256=jzO63B9KiEAncnBqmz2ZTcxjmEHozMEe7WnfpcpsQYg,3195
@@ -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=Djd_7GxqAd6z6spaztPvuwOWM8nCLYHOM1pxOFHfmrc,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.6.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.12.6.dist-info/METADATA,sha256=C1VU1fn4OEzUUW4pv7NTqN6hMP4XCwxUZldj2hAtths,5128
-vellum_ai-0.12.6.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-0.12.6.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.12.6.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,,

vellum_cli/__init__.py

@@ -130,11 +130,18 @@ Should only be used for debugging purposes.""",
     is_flag=True,
     help="""Raises an error immediately if there are any issues with the pulling of the Resource.""",
 )
+@click.option(
+    "--include-sandbox",
+    is_flag=True,
+    help="""Generates a runnable sandbox.py file containing test data from the Resource's sandbox. \
+Helpful for running and debugging workflows locally.""",
+)
 def pull(
     ctx: click.Context,
     include_json: Optional[bool],
     exclude_code: Optional[bool],
     strict: Optional[bool],
+    include_sandbox: Optional[bool],
 ) -> None:
     """Pull Resources from Vellum"""
 
@@ -143,6 +150,7 @@ def pull(
             include_json=include_json,
             exclude_code=exclude_code,
             strict=strict,
+            include_sandbox=include_sandbox,
         )
 
 
@@ -171,6 +179,12 @@ Should only be used for debugging purposes.""",
     is_flag=True,
     help="""Raises an error immediately if there are any issues with the pulling of the Workflow.""",
 )
+@click.option(
+    "--include-sandbox",
+    is_flag=True,
+    help="""Generates a runnable sandbox.py file containing test data from the Resource's sandbox. \
+Helpful for running and debugging workflows locally.""",
+)
 def workflows_pull(
     module: Optional[str],
     include_json: Optional[bool],
@@ -178,6 +192,7 @@ def workflows_pull(
     workflow_deployment: Optional[str],
     exclude_code: Optional[bool],
     strict: Optional[bool],
+    include_sandbox: Optional[bool],
 ) -> None:
     """
     Pull Workflows from Vellum. If a module is provided, only the Workflow for that module will be pulled.
@@ -191,6 +206,7 @@ def workflows_pull(
         workflow_deployment=workflow_deployment,
         exclude_code=exclude_code,
         strict=strict,
+        include_sandbox=include_sandbox,
     )
 
 
@@ -208,10 +224,23 @@ Should only be used for debugging purposes.""",
     help="""Exclude the code definition of the Resource from the pull response. \
 Should only be used for debugging purposes.""",
 )
+@click.option(
+    "--strict",
+    is_flag=True,
+    help="""Raises an error immediately if there are any issues with the pulling of the Resource.""",
+)
+@click.option(
+    "--include-sandbox",
+    is_flag=True,
+    help="""Generates a runnable sandbox.py file containing test data from the Resource's sandbox. \
+Helpful for running and debugging resources locally.""",
+)
 def pull_module(
     ctx: click.Context,
     include_json: Optional[bool],
     exclude_code: Optional[bool],
+    strict: Optional[bool],
+    include_sandbox: Optional[bool],
 ) -> None:
     """Pull a specific module from Vellum"""
 
@@ -220,6 +249,8 @@ def pull_module(
             module=ctx.parent.invoked_subcommand,
             include_json=include_json,
             exclude_code=exclude_code,
+            strict=strict,
+            include_sandbox=include_sandbox,
         )
 
 

vellum_cli/pull.py

@@ -84,6 +84,7 @@ def pull_command(
     include_json: Optional[bool] = None,
     exclude_code: Optional[bool] = None,
     strict: Optional[bool] = None,
+    include_sandbox: Optional[bool] = None,
 ) -> None:
     load_dotenv()
     logger = load_cli_logger()
@@ -114,6 +115,8 @@ def pull_command(
         query_parameters["exclude_code"] = exclude_code
     if strict:
         query_parameters["strict"] = strict
+    if include_sandbox:
+        query_parameters["include_sandbox"] = include_sandbox
 
     response = client.workflows.pull(
         pk,
@@ -166,6 +169,17 @@ def pull_command(
 Its schema should be considered unstable and subject to change at any time."""
         )
 
+    if include_sandbox:
+        if not workflow_config.ignore:
+            workflow_config.ignore = "sandbox.py"
+            save_lock_file = True
+        elif isinstance(workflow_config.ignore, str) and "sandbox.py" != workflow_config.ignore:
+            workflow_config.ignore = [workflow_config.ignore, "sandbox.py"]
+            save_lock_file = True
+        elif isinstance(workflow_config.ignore, list) and "sandbox.py" not in workflow_config.ignore:
+            workflow_config.ignore.append("sandbox.py")
+            save_lock_file = True
+
     if save_lock_file:
         config.save()
 

vellum_cli/tests/test_pull.py

@@ -486,3 +486,32 @@ def test_pull__strict__with_error(vellum_client, mock_module):
     vellum_client.workflows.pull.assert_called_once()
     call_args = vellum_client.workflows.pull.call_args.kwargs
     assert call_args["request_options"]["additional_query_parameters"] == {"strict": True}
+
+
+def test_pull__include_sandbox(vellum_client, mock_module):
+    # GIVEN a module on the user's filesystem
+    module = mock_module.module
+    temp_dir = mock_module.temp_dir
+
+    # AND the workflow pull API call returns a zip file
+    vellum_client.workflows.pull.return_value = iter(
+        [_zip_file_map({"workflow.py": "print('hello')", "sandbox.py": "print('hello')"})]
+    )
+
+    # WHEN the user runs the pull command
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["pull", module, "--include-sandbox"])
+
+    # THEN the command returns successfully
+    assert result.exit_code == 0, result.output
+
+    # AND the pull api is called with include_sandbox=True
+    vellum_client.workflows.pull.assert_called_once()
+    call_args = vellum_client.workflows.pull.call_args.kwargs
+    assert call_args["request_options"]["additional_query_parameters"] == {"include_sandbox": True}
+
+    # AND the sandbox.py should be added to the ignore list
+    lock_json = os.path.join(temp_dir, "vellum.lock.json")
+    with open(lock_json) as f:
+        lock_data = json.load(f)
+        assert lock_data["workflows"][0]["ignore"] == "sandbox.py"

vellum_ee/workflows/display/nodes/vellum/code_execution_node.py

@@ -27,8 +27,8 @@ class BaseCodeExecutionNodeDisplay(BaseNodeVellumDisplay[_CodeExecutionNodeType]
         node = self._node
         node_id = self.node_id
         raw_code = raise_if_descriptor(node.code)
-        code_value = None
 
+        code_value: Optional[str]
         if raw_code:
             code_value = raw_code
         else:

vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py

@@ -104,13 +104,12 @@ class BaseInlinePromptNodeDisplay(BaseNodeVellumDisplay[_InlinePromptNodeType],
             chat_properties: JsonObject = {
                 "chat_role": prompt_block.chat_role,
                 "chat_source": prompt_block.chat_source,
+                "chat_message_unterminated": bool(prompt_block.chat_message_unterminated),
                 "blocks": [
                     self._generate_prompt_block(block, input_variable_id_by_name, path + [i])
                     for i, block in enumerate(prompt_block.blocks)
                 ],
             }
-            if prompt_block.chat_message_unterminated is not None:
-                chat_properties["chat_message_unterminated"] = prompt_block.chat_message_unterminated
 
             block = {
                 "block_type": "CHAT_MESSAGE",