vellum-ai 0.14.63__py3-none-any.whl → 1.13.5__py3-none-any.whl

vellum_ee/workflows/tests/test_virtual_files.py

@@ -80,3 +80,51 @@ def test_base_class_dynamic_import(files):
         assert instance.id
     except Exception as e:
         pytest.fail(f"Failed to create an instance of BaseClass: {e}")
+
+
+def test_display_directory_not_auto_generated():
+    """
+    Test that the top-level display directory is NOT auto-generated with empty __init__.py.
+    Display directories typically have specific __init__.py content (e.g., "from .workflow import *")
+    that should not be replaced with empty auto-generated files.
+    """
+    # GIVEN a workflow with display/workflow.py but NO display/__init__.py
+    files = {
+        "__init__.py": "",
+        "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.nodes.bases import BaseNode
+
+class StartNode(BaseNode):
+    pass
+
+class Workflow(BaseWorkflow):
+    graph = StartNode
+""",
+        "display/workflow.py": """\
+from vellum_ee.workflows.display.workflows import BaseWorkflowDisplay
+
+class WorkflowDisplay(BaseWorkflowDisplay):
+    pass
+""",
+        # Note: NO "display/__init__.py" in files dict
+    }
+
+    namespace = str(uuid4())
+
+    # AND the virtual file loader is registered
+    sys.meta_path.append(VirtualFileFinder(files, namespace))
+
+    try:
+        # WHEN we try to resolve display/__init__.py
+        import importlib.util
+
+        spec = importlib.util.find_spec(f"{namespace}.display")
+
+        # THEN the spec should be found because we now support dynamic display module imports
+        assert spec
+        assert spec.origin == "display/__init__.py"
+
+    finally:
+        # Clean up
+        sys.meta_path = [finder for finder in sys.meta_path if not isinstance(finder, VirtualFileFinder)]

vellum/client/resources/release_reviews/client.py

@@ -1,137 +0,0 @@
-# This file was auto-generated by Fern from our API Definition.
-
-from ...core.client_wrapper import SyncClientWrapper
-import typing
-from ...core.request_options import RequestOptions
-from ...types.workflow_deployment_release import WorkflowDeploymentRelease
-from ...core.jsonable_encoder import jsonable_encoder
-from ...core.pydantic_utilities import parse_obj_as
-from json.decoder import JSONDecodeError
-from ...core.api_error import ApiError
-from ...core.client_wrapper import AsyncClientWrapper
-
-
-class ReleaseReviewsClient:
-    def __init__(self, *, client_wrapper: SyncClientWrapper):
-        self._client_wrapper = client_wrapper
-
-    def retrieve_workflow_deployment_release(
-        self, id: str, release_id_or_release_tag: str, *, request_options: typing.Optional[RequestOptions] = None
-    ) -> WorkflowDeploymentRelease:
-        """
-        Retrieve a specific Workflow Deployment Release by either its UUID or the name of a Release Tag that points to it.
-
-        Parameters
-        ----------
-        id : str
-            Either the Workflow Deployment's ID or its unique name
-
-        release_id_or_release_tag : str
-            Either the UUID of Workflow Deployment Release you'd like to retrieve, or the name of a Release Tag that's pointing to the Workflow Deployment Release you'd like to retrieve.
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        WorkflowDeploymentRelease
-
-
-        Examples
-        --------
-        from vellum import Vellum
-
-        client = Vellum(
-            api_key="YOUR_API_KEY",
-        )
-        client.release_reviews.retrieve_workflow_deployment_release(
-            id="id",
-            release_id_or_release_tag="release_id_or_release_tag",
-        )
-        """
-        _response = self._client_wrapper.httpx_client.request(
-            f"v1/workflow-deployments/{jsonable_encoder(id)}/releases/{jsonable_encoder(release_id_or_release_tag)}",
-            base_url=self._client_wrapper.get_environment().default,
-            method="GET",
-            request_options=request_options,
-        )
-        try:
-            if 200 <= _response.status_code < 300:
-                return typing.cast(
-                    WorkflowDeploymentRelease,
-                    parse_obj_as(
-                        type_=WorkflowDeploymentRelease,  # type: ignore
-                        object_=_response.json(),
-                    ),
-                )
-            _response_json = _response.json()
-        except JSONDecodeError:
-            raise ApiError(status_code=_response.status_code, body=_response.text)
-        raise ApiError(status_code=_response.status_code, body=_response_json)
-
-
-class AsyncReleaseReviewsClient:
-    def __init__(self, *, client_wrapper: AsyncClientWrapper):
-        self._client_wrapper = client_wrapper
-
-    async def retrieve_workflow_deployment_release(
-        self, id: str, release_id_or_release_tag: str, *, request_options: typing.Optional[RequestOptions] = None
-    ) -> WorkflowDeploymentRelease:
-        """
-        Retrieve a specific Workflow Deployment Release by either its UUID or the name of a Release Tag that points to it.
-
-        Parameters
-        ----------
-        id : str
-            Either the Workflow Deployment's ID or its unique name
-
-        release_id_or_release_tag : str
-            Either the UUID of Workflow Deployment Release you'd like to retrieve, or the name of a Release Tag that's pointing to the Workflow Deployment Release you'd like to retrieve.
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        WorkflowDeploymentRelease
-
-
-        Examples
-        --------
-        import asyncio
-
-        from vellum import AsyncVellum
-
-        client = AsyncVellum(
-            api_key="YOUR_API_KEY",
-        )
-
-
-        async def main() -> None:
-            await client.release_reviews.retrieve_workflow_deployment_release(
-                id="id",
-                release_id_or_release_tag="release_id_or_release_tag",
-            )
-
-
-        asyncio.run(main())
-        """
-        _response = await self._client_wrapper.httpx_client.request(
-            f"v1/workflow-deployments/{jsonable_encoder(id)}/releases/{jsonable_encoder(release_id_or_release_tag)}",
-            base_url=self._client_wrapper.get_environment().default,
-            method="GET",
-            request_options=request_options,
-        )
-        try:
-            if 200 <= _response.status_code < 300:
-                return typing.cast(
-                    WorkflowDeploymentRelease,
-                    parse_obj_as(
-                        type_=WorkflowDeploymentRelease,  # type: ignore
-                        object_=_response.json(),
-                    ),
-                )
-            _response_json = _response.json()
-        except JSONDecodeError:
-            raise ApiError(status_code=_response.status_code, body=_response.text)
-        raise ApiError(status_code=_response.status_code, body=_response_json)

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

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

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

@@ -1,266 +0,0 @@
-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,
-    VellumImage,
-)
-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(VellumImage, 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)
-            elif block.content.type == "DOCUMENT":
-                raise NodeException(
-                    code=WorkflowErrorCode.PROVIDER_ERROR,
-                    message="Document chat message content type is not currently supported",
-                )
-            else:
-                raise NodeException(
-                    code=WorkflowErrorCode.INTERNAL_ERROR,
-                    message=f"Failed to parse chat message block {block.content.type}",
-                )
-
-        return content

vellum/workflows/nodes/experimental/tool_calling_node/__init__.py

@@ -1,3 +0,0 @@
-from vellum.workflows.nodes.experimental.tool_calling_node.node import ToolCallingNode
-
-__all__ = ["ToolCallingNode"]

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

@@ -1,135 +0,0 @@
-from collections.abc import Callable
-from typing import Any, ClassVar, Dict, List, Optional, cast
-
-from pydash import snake_case
-
-from vellum import ChatMessage, PromptBlock
-from vellum.client.types.code_execution_package import CodeExecutionPackage
-from vellum.workflows.context import execution_context, get_parent_context
-from vellum.workflows.errors.types import WorkflowErrorCode
-from vellum.workflows.exceptions import NodeException
-from vellum.workflows.graph.graph import Graph
-from vellum.workflows.inputs.base import BaseInputs
-from vellum.workflows.nodes.bases import BaseNode
-from vellum.workflows.nodes.experimental.tool_calling_node.utils import create_function_node, create_tool_router_node
-from vellum.workflows.outputs.base import BaseOutputs
-from vellum.workflows.state.base import BaseState
-from vellum.workflows.state.context import WorkflowContext
-from vellum.workflows.types.core import EntityInputsInterface
-from vellum.workflows.workflows.base import BaseWorkflow
-
-
-class ToolCallingNode(BaseNode):
-    """
-    A Node that dynamically invokes the provided functions to the underlying Prompt
-
-    Attributes:
-        ml_model: str - The model to use for tool calling (e.g., "gpt-4o-mini")
-        blocks: List[PromptBlock] - The prompt blocks to use (same format as InlinePromptNode)
-        functions: List[FunctionDefinition] - The functions that can be called
-        function_callables: List[Callable] - The callables that can be called
-        prompt_inputs: Optional[EntityInputsInterface] - Mapping of input variable names to values
-        function_packages: Optional[Dict[Callable, List[CodeExecutionPackage]]] - Mapping of functions to their packages
-        runtime: str - The runtime to use for code execution (default: "PYTHON_3_11_6")
-    """
-
-    ml_model: ClassVar[str] = "gpt-4o-mini"
-    blocks: ClassVar[List[PromptBlock]] = []
-    functions: ClassVar[List[Callable[..., Any]]] = []
-    prompt_inputs: ClassVar[Optional[EntityInputsInterface]] = None
-    function_packages: ClassVar[Optional[Dict[Callable[..., Any], List[CodeExecutionPackage]]]] = None
-    runtime: ClassVar[str] = "PYTHON_3_11_6"
-
-    class Outputs(BaseOutputs):
-        """
-        The outputs of the ToolCallingNode.
-
-        text: The final text response after tool calling
-        chat_history: The complete chat history including tool calls
-        """
-
-        text: str
-        chat_history: List[ChatMessage]
-
-    def run(self) -> Outputs:
-        """
-        Run the tool calling workflow.
-
-        This dynamically builds a graph with router and function nodes,
-        then executes the workflow.
-        """
-
-        self._build_graph()
-
-        with execution_context(parent_context=get_parent_context()):
-
-            class ToolCallingState(BaseState):
-                chat_history: List[ChatMessage] = []
-
-            class ToolCallingWorkflow(BaseWorkflow[BaseInputs, ToolCallingState]):
-                graph = self._graph
-
-                class Outputs(BaseWorkflow.Outputs):
-                    text: str = self.tool_router_node.Outputs.text
-                    chat_history: List[ChatMessage] = ToolCallingState.chat_history
-
-            subworkflow = ToolCallingWorkflow(
-                parent_state=self.state,
-                context=WorkflowContext.create_from(self._context),
-            )
-
-            terminal_event = subworkflow.run()
-
-            if terminal_event.name == "workflow.execution.paused":
-                raise NodeException(
-                    code=WorkflowErrorCode.INVALID_OUTPUTS,
-                    message="Subworkflow unexpectedly paused",
-                )
-            elif terminal_event.name == "workflow.execution.fulfilled":
-                node_outputs = self.Outputs(
-                    text=terminal_event.outputs.text,
-                    chat_history=terminal_event.outputs.chat_history,
-                )
-
-                return node_outputs
-            elif terminal_event.name == "workflow.execution.rejected":
-                raise Exception(f"Workflow execution rejected: {terminal_event.error}")
-
-            raise Exception(f"Unexpected workflow event: {terminal_event.name}")
-
-    def _build_graph(self) -> None:
-        self.tool_router_node = create_tool_router_node(
-            ml_model=self.ml_model,
-            blocks=self.blocks,
-            functions=self.functions,
-            prompt_inputs=self.prompt_inputs,
-        )
-
-        self._function_nodes = {}
-        for function in self.functions:
-            function_name = snake_case(function.__name__)
-            # Get packages for this function if specified
-            packages = None
-            if self.function_packages and function in self.function_packages:
-                # Cast to tell mypy this is a plain list, not a descriptor
-                packages = cast(List[CodeExecutionPackage], self.function_packages[function])
-
-            self._function_nodes[function_name] = create_function_node(
-                function=function,
-                tool_router_node=self.tool_router_node,
-                packages=packages,
-                runtime=self.runtime,
-            )
-
-        graph_set = set()
-
-        # Add connections from ports of router to function nodes and back to router
-        for function_name, FunctionNodeClass in self._function_nodes.items():
-            router_port = getattr(self.tool_router_node.Ports, function_name)
-            edge_graph = router_port >> FunctionNodeClass >> self.tool_router_node
-            graph_set.add(edge_graph)
-
-        default_port = getattr(self.tool_router_node.Ports, "default")
-        graph_set.add(default_port)
-
-        self._graph = Graph.from_set(graph_set)

vellum/workflows/nodes/experimental/tool_calling_node/tests/test_node.py

@@ -1,53 +0,0 @@
-from vellum.client.types.function_call import FunctionCall
-from vellum.client.types.function_call_vellum_value import FunctionCallVellumValue
-from vellum.workflows.nodes.experimental.tool_calling_node.utils import create_tool_router_node
-from vellum.workflows.state.base import BaseState, StateMeta
-
-
-def first_function() -> str:
-    return "first_function"
-
-
-def second_function() -> str:
-    return "second_function"
-
-
-def test_port_condition_match_function_name():
-    """
-    Test that the port condition correctly matches the function name.
-    """
-    # GIVEN a tool router node
-    router_node = create_tool_router_node(
-        ml_model="test-model",
-        blocks=[],
-        functions=[first_function, second_function],
-        prompt_inputs=None,
-    )
-
-    # AND a state with a function call to the first function
-    state = BaseState(
-        meta=StateMeta(
-            node_outputs={
-                router_node.Outputs.results: [
-                    FunctionCallVellumValue(
-                        value=FunctionCall(
-                            arguments={}, id="call_zp7pBQjGAOBCr7lo0AbR1HXT", name="first_function", state="FULFILLED"
-                        ),
-                    )
-                ],
-            },
-        )
-    )
-
-    # WHEN the port condition is resolved
-    # THEN the first function port should be true
-    first_function_port = getattr(router_node.Ports, "first_function")
-    assert first_function_port.resolve_condition(state) is True
-
-    # AND the second function port should be false
-    second_function_port = getattr(router_node.Ports, "second_function")
-    assert second_function_port.resolve_condition(state) is False
-
-    # AND the default port should be false
-    default_port = getattr(router_node.Ports, "default")
-    assert default_port.resolve_condition(state) is False