vellum-ai 0.9.16__py3-none-any.whl → 0.9.16rc4__py3-none-any.whl

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

@@ -0,0 +1,110 @@
+from typing import TYPE_CHECKING, Any, Callable, Dict, Generic, Optional, Tuple, Type, TypeVar
+
+from vellum.workflows.errors.types import VellumError, VellumErrorCode
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.nodes.bases import BaseNode
+from vellum.workflows.nodes.bases.base import BaseNodeMeta
+from vellum.workflows.outputs.base import BaseOutputs
+from vellum.workflows.types.generics import StateType
+
+if TYPE_CHECKING:
+    from vellum.workflows import BaseWorkflow
+
+Subworkflow = Type["BaseWorkflow"]
+_T = TypeVar("_T", bound=BaseOutputs)
+
+
+class _TryNodeMeta(BaseNodeMeta):
+    def __new__(cls, name: str, bases: Tuple[Type, ...], dct: Dict[str, Any]) -> Any:
+        node_class = super().__new__(cls, name, bases, dct)
+
+        subworkflow_attribute = dct.get("subworkflow")
+        if not subworkflow_attribute:
+            return node_class
+
+        subworkflow_outputs = getattr(subworkflow_attribute, "Outputs")
+        if not issubclass(subworkflow_outputs, BaseOutputs):
+            raise ValueError("subworkflow.Outputs must be a subclass of BaseOutputs")
+
+        outputs_class = dct.get("Outputs")
+        if not outputs_class:
+            raise ValueError("Outputs class not found in base classes")
+
+        if not issubclass(outputs_class, BaseNode.Outputs):
+            raise ValueError("Outputs class must be a subclass of BaseNode.Outputs")
+
+        for descriptor in subworkflow_outputs:
+            if descriptor.name == "error":
+                raise ValueError("`error` is a reserved name for TryNode.Outputs")
+
+            setattr(outputs_class, descriptor.name, descriptor)
+
+        return node_class
+
+
+class TryNode(BaseNode[StateType], Generic[StateType], metaclass=_TryNodeMeta):
+    """
+    Used to execute a Subworkflow and handle errors.
+
+    on_error_code: Optional[VellumErrorCode] = None - The error code to handle
+    subworkflow: Type["BaseWorkflow"] - The Subworkflow to execute
+    """
+
+    on_error_code: Optional[VellumErrorCode] = None
+    subworkflow: Type["BaseWorkflow"]
+
+    class Outputs(BaseNode.Outputs):
+        error: Optional[VellumError] = None
+
+    def run(self) -> Outputs:
+        subworkflow = self.subworkflow(
+            parent_state=self.state,
+        )
+        terminal_event = subworkflow.run()
+
+        if terminal_event.name == "workflow.execution.fulfilled":
+            outputs = self.Outputs()
+            for descriptor, value in terminal_event.outputs:
+                setattr(outputs, descriptor.name, value)
+            return outputs
+        elif terminal_event.name == "workflow.execution.paused":
+            raise NodeException(
+                code=VellumErrorCode.INVALID_OUTPUTS,
+                message="Subworkflow unexpectedly paused within Try Node",
+            )
+        elif self.on_error_code and self.on_error_code != terminal_event.error.code:
+            raise NodeException(
+                code=VellumErrorCode.INVALID_OUTPUTS,
+                message=f"""Unexpected rejection: {terminal_event.error.code.value}.
+Message: {terminal_event.error.message}""",
+            )
+        else:
+            return self.Outputs(
+                error=terminal_event.error,
+            )
+
+    @classmethod
+    def wrap(cls, on_error_code: Optional[VellumErrorCode] = None) -> Callable[..., Type["TryNode"]]:
+        _on_error_code = on_error_code
+
+        def decorator(inner_cls: Type[BaseNode]) -> Type["TryNode"]:
+            # Investigate how to use dependency injection to avoid circular imports
+            # https://app.shortcut.com/vellum/story/4116
+            from vellum.workflows import BaseWorkflow
+
+            class Subworkflow(BaseWorkflow):
+                inner_cls._is_wrapped_node = True
+                graph = inner_cls
+
+                # mypy is wrong here, this works and is defined
+                class Outputs(inner_cls.Outputs):  # type: ignore[name-defined]
+                    pass
+
+            class WrappedNode(TryNode[StateType]):
+                on_error_code = _on_error_code
+
+                subworkflow = Subworkflow
+
+            return WrappedNode
+
+        return decorator

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

@@ -0,0 +1,82 @@
+import pytest
+
+from vellum.workflows.errors.types import VellumError, VellumErrorCode
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases import BaseNode
+from vellum.workflows.nodes.core.try_node.node import TryNode
+from vellum.workflows.outputs import BaseOutputs
+from vellum.workflows.state.base import BaseState, StateMeta
+
+
+def test_try_node__on_error_code__successfully_caught():
+    # GIVEN a try node that is configured to catch PROVIDER_ERROR
+    @TryNode.wrap(on_error_code=VellumErrorCode.PROVIDER_ERROR)
+    class TestNode(BaseNode):
+        class Outputs(BaseOutputs):
+            value: int
+
+        def run(self) -> Outputs:
+            raise NodeException(message="This will be caught", code=VellumErrorCode.PROVIDER_ERROR)
+
+    # WHEN the node is run and throws a PROVIDER_ERROR
+    node = TestNode(state=BaseState())
+    outputs = node.run()
+
+    # THEN the exception is retried
+    assert outputs == {
+        "error": VellumError(message="This will be caught", code=VellumErrorCode.PROVIDER_ERROR),
+    }
+
+
+def test_try_node__retry_on_error_code__missed():
+    # GIVEN a try node that is configured to catch PROVIDER_ERROR
+    @TryNode.wrap(on_error_code=VellumErrorCode.PROVIDER_ERROR)
+    class TestNode(BaseNode):
+        class Outputs(BaseOutputs):
+            value: int
+
+        def run(self) -> Outputs:
+            raise NodeException(message="This will be missed", code=VellumErrorCode.INTERNAL_ERROR)
+
+    # WHEN the node is run and throws a different exception
+    node = TestNode(state=BaseState())
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    # THEN the exception is not caught
+    assert exc_info.value.message == "Unexpected rejection: INTERNAL_ERROR.\nMessage: This will be missed"
+    assert exc_info.value.code == VellumErrorCode.INVALID_OUTPUTS
+
+
+def test_try_node__use_parent_inputs_and_state():
+    # GIVEN a parent workflow Inputs and State
+    class Inputs(BaseInputs):
+        foo: str
+
+    class State(BaseState):
+        bar: str
+
+    # AND a try node that uses the parent's inputs and state
+    @TryNode.wrap()
+    class TestNode(BaseNode):
+        foo = Inputs.foo
+        bar = State.bar
+
+        class Outputs(BaseOutputs):
+            value: str
+
+        def run(self) -> Outputs:
+            return self.Outputs(value=f"{self.foo} {self.bar}")
+
+    # WHEN the node is run
+    node = TestNode(
+        state=State(
+            bar="bar",
+            meta=StateMeta(workflow_inputs=Inputs(foo="foo")),
+        ),
+    )
+    outputs = node.run()
+
+    # THEN the data is used successfully
+    assert outputs == {"value": "foo bar"}

vellum/workflows/nodes/displayable/__init__.py

@@ -0,0 +1,31 @@
+from ..core.error_node import ErrorNode
+from ..core.inline_subworkflow_node import InlineSubworkflowNode
+from ..core.map_node import MapNode
+from ..core.templating_node import TemplatingNode
+from .api_node import APINode
+from .code_execution_node import CodeExecutionNode
+from .conditional_node import ConditionalNode
+from .final_output_node import FinalOutputNode
+from .guardrail_node import GuardrailNode
+from .inline_prompt_node import InlinePromptNode
+from .merge_node import MergeNode
+from .prompt_deployment_node import PromptDeploymentNode
+from .search_node import SearchNode
+from .subworkflow_deployment_node import SubworkflowDeploymentNode
+
+__all__ = [
+    "APINode",
+    "CodeExecutionNode",
+    "ConditionalNode",
+    "ErrorNode",
+    "InlinePromptNode",
+    "InlineSubworkflowNode",
+    "GuardrailNode",
+    "MapNode",
+    "MergeNode",
+    "SubworkflowDeploymentNode",
+    "PromptDeploymentNode",
+    "SearchNode",
+    "TemplatingNode",
+    "FinalOutputNode",
+]

vellum/workflows/nodes/displayable/api_node/__init__.py

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

vellum/workflows/nodes/displayable/api_node/node.py

@@ -0,0 +1,44 @@
+from typing import Optional, Union
+
+from vellum.workflows.constants import AuthorizationType
+from vellum.workflows.nodes.displayable.bases.api_node import BaseAPINode
+from vellum.workflows.references.vellum_secret import VellumSecretReference
+
+
+class APINode(BaseAPINode):
+    """
+    Used to execute an API call. This node exists to be backwards compatible with Vellum's API Node, and for most cases,
+    you should extend from `APINode` directly.
+
+    url: str - The URL to send the request to.
+    method: APIRequestMethod - The HTTP method to use for the request.
+    data: Optional[str] - The data to send in the request body.
+    json: Optional["JsonObject"] - The JSON data to send in the request body.
+    headers: Optional[Dict[str, Union[str, VellumSecret]]] - The headers to send in the request.
+
+    authorization_type: Optional[AuthorizationType] = None - The type of authorization to use for the API call.
+    api_key_header_key: Optional[str] = None - The header key to use for the API key authorization.
+    bearer_token_value: Optional[str] = None - The bearer token value to use for the bearer token authorization.
+    """
+
+    authorization_type: Optional[AuthorizationType] = None
+    api_key_header_key: Optional[str] = None
+    api_key_header_value: Optional[Union[str, VellumSecretReference]] = None
+    bearer_token_value: Optional[str] = None
+
+    def run(self) -> BaseAPINode.Outputs:
+        headers = self.headers or {}
+        header_overrides = {}
+
+        if (
+            self.authorization_type == AuthorizationType.API_KEY
+            and self.api_key_header_key
+            and self.api_key_header_value
+        ):
+            header_overrides[self.api_key_header_key] = self.api_key_header_value
+        elif self.authorization_type == AuthorizationType.BEARER_TOKEN:
+            header_overrides["Authorization"] = f"Bearer {self.bearer_token_value}"
+
+        return self._run(
+            method=self.method, url=self.url, data=self.data, json=self.json, headers={**headers, **header_overrides}
+        )

vellum/workflows/nodes/displayable/bases/__init__.py

@@ -0,0 +1,11 @@
+from .api_node import BaseAPINode
+from .inline_prompt_node import BaseInlinePromptNode
+from .prompt_deployment_node import BasePromptDeploymentNode
+from .search_node import BaseSearchNode
+
+__all__ = [
+    "BaseAPINode",
+    "BaseInlinePromptNode",
+    "BasePromptDeploymentNode",
+    "BaseSearchNode",
+]

vellum/workflows/nodes/displayable/bases/api_node/__init__.py

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

vellum/workflows/nodes/displayable/bases/api_node/node.py

@@ -0,0 +1,70 @@
+from typing import Any, Dict, Generic, Optional, Union
+
+from requests import Request, RequestException, Session
+from requests.exceptions import JSONDecodeError
+
+from vellum.workflows.constants import APIRequestMethod
+from vellum.workflows.errors.types import VellumErrorCode
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.nodes.bases import BaseNode
+from vellum.workflows.outputs import BaseOutputs
+from vellum.workflows.types.core import JsonObject, VellumSecret
+from vellum.workflows.types.generics import StateType
+
+
+class BaseAPINode(BaseNode, Generic[StateType]):
+    """
+    Used to execute an API call.
+
+    url: str - The URL to send the request to.
+    method: APIRequestMethod - The HTTP method to use for the request.
+    data: Optional[str] - The data to send in the request body.
+    json: Optional["JsonObject"] - The JSON data to send in the request body.
+    headers: Optional[Dict[str, Union[str, VellumSecret]]] - The headers to send in the request.
+    """
+
+    url: str
+    method: APIRequestMethod
+    data: Optional[str] = None
+    json: Optional["JsonObject"] = None
+    headers: Optional[Dict[str, Union[str, VellumSecret]]] = None
+
+    class Outputs(BaseOutputs):
+        json: Optional["JsonObject"]
+        headers: Dict[str, str]
+        status_code: int
+        text: str
+
+    def run(self) -> Outputs:
+        return self._run(method=self.method, url=self.url, data=self.data, json=self.json, headers=self.headers)
+
+    def _run(
+        self,
+        method: APIRequestMethod,
+        url: str,
+        data: Optional[str] = None,
+        json: Any = None,
+        headers: Any = None,
+    ) -> Outputs:
+        try:
+            prepped = Request(method=method.value, url=url, data=data, json=json, headers=headers).prepare()
+        except Exception as e:
+            raise NodeException(f"Failed to prepare HTTP request: {e}", code=VellumErrorCode.PROVIDER_ERROR)
+
+        try:
+            with Session() as session:
+                response = session.send(prepped)
+        except RequestException as e:
+            raise NodeException(f"HTTP request failed: {e}", code=VellumErrorCode.PROVIDER_ERROR)
+
+        try:
+            json = response.json()
+        except JSONDecodeError:
+            json = None
+
+        return self.Outputs(
+            json=json,
+            headers={header: value for header, value in response.headers.items()},
+            status_code=response.status_code,
+            text=response.text,
+        )

vellum/workflows/nodes/displayable/bases/base_prompt_node/__init__.py

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

vellum/workflows/nodes/displayable/bases/base_prompt_node/node.py

@@ -0,0 +1,60 @@
+from abc import abstractmethod
+from typing import ClassVar, Generator, Generic, Iterator, List, Optional, Union
+
+from vellum import AdHocExecutePromptEvent, ExecutePromptEvent, PromptOutput
+from vellum.core import RequestOptions
+
+from vellum.workflows.errors.types import VellumErrorCode
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.nodes.bases import BaseNode
+from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
+from vellum.workflows.types.core import EntityInputsInterface
+from vellum.workflows.types.generics import StateType
+
+
+class BasePromptNode(BaseNode, Generic[StateType]):
+    # Inputs that are passed to the Prompt
+    prompt_inputs: ClassVar[EntityInputsInterface]
+
+    request_options: Optional[RequestOptions] = None
+
+    class Outputs(BaseOutputs):
+        results: List[PromptOutput]
+
+    @abstractmethod
+    def _get_prompt_event_stream(self) -> Union[Iterator[AdHocExecutePromptEvent], Iterator[ExecutePromptEvent]]:
+        pass
+
+    def run(self) -> Iterator[BaseOutput]:
+        outputs = yield from self._process_prompt_event_stream()
+        if outputs is None:
+            raise NodeException(
+                message="Expected to receive outputs from Prompt",
+                code=VellumErrorCode.INTERNAL_ERROR,
+            )
+
+    def _process_prompt_event_stream(self) -> Generator[BaseOutput, None, Optional[List[PromptOutput]]]:
+        prompt_event_stream = self._get_prompt_event_stream()
+
+        outputs: Optional[List[PromptOutput]] = None
+        for event in prompt_event_stream:
+            if event.state == "INITIATED":
+                continue
+            elif event.state == "STREAMING":
+                yield BaseOutput(name="results", delta=event.output.value)
+            elif event.state == "FULFILLED":
+                outputs = event.outputs
+                yield BaseOutput(name="results", value=event.outputs)
+            elif event.state == "REJECTED":
+                if event.error.code in VellumErrorCode._value2member_map_:
+                    raise NodeException(
+                        message=event.error.message,
+                        code=VellumErrorCode(event.error.code),
+                    )
+                else:
+                    raise NodeException(
+                        message=event.error.message,
+                        code=VellumErrorCode.INTERNAL_ERROR,
+                    )
+
+        return outputs

vellum/workflows/nodes/displayable/bases/inline_prompt_node/__init__.py

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

vellum/workflows/nodes/displayable/bases/inline_prompt_node/constants.py

@@ -0,0 +1,13 @@
+from vellum import PromptParameters
+
+DEFAULT_PROMPT_PARAMETERS = PromptParameters(
+    stop=[],
+    temperature=0.0,
+    max_tokens=4096,
+    top_p=1.0,
+    top_k=0,
+    frequency_penalty=0.0,
+    presence_penalty=0.0,
+    logit_bias=None,
+    custom_parameters=None,
+)

vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py

@@ -0,0 +1,118 @@
+from uuid import uuid4
+from typing import ClassVar, Generic, Iterator, List, Optional, Tuple, cast
+
+from vellum import (
+    AdHocExecutePromptEvent,
+    AdHocExpandMeta,
+    ChatMessage,
+    FunctionDefinition,
+    PromptBlock,
+    PromptParameters,
+    PromptRequestChatHistoryInput,
+    PromptRequestInput,
+    PromptRequestJsonInput,
+    PromptRequestStringInput,
+    VellumVariable,
+)
+
+from vellum.workflows.constants import OMIT
+from vellum.workflows.errors import VellumErrorCode
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.nodes.displayable.bases.base_prompt_node import BasePromptNode
+from vellum.workflows.nodes.displayable.bases.inline_prompt_node.constants import DEFAULT_PROMPT_PARAMETERS
+from vellum.workflows.types.generics import StateType
+
+
+class BaseInlinePromptNode(BasePromptNode, Generic[StateType]):
+    """
+    Used to execute a Prompt defined inline.
+
+    prompt_inputs: EntityInputsInterface - The inputs for the Prompt
+    ml_model: str - Either the ML Model's UUID or its name.
+    blocks: List[PromptBlock] - The blocks that make up the Prompt
+    functions: Optional[List[FunctionDefinition]] - The functions to include in the Prompt
+    parameters: PromptParameters - The parameters for the Prompt
+    expand_meta: Optional[AdHocExpandMeta] - Expandable execution fields to include in the response
+    request_options: Optional[RequestOptions] - The request options to use for the Prompt Execution
+    """
+
+    ml_model: ClassVar[str]
+
+    # The blocks that make up the Prompt
+    blocks: ClassVar[List[PromptBlock]]
+
+    # The functions/tools that a Prompt has access to
+    functions: Optional[List[FunctionDefinition]] = OMIT
+
+    parameters: PromptParameters = DEFAULT_PROMPT_PARAMETERS
+    expand_meta: Optional[AdHocExpandMeta] = OMIT
+
+    def _get_prompt_event_stream(self) -> Iterator[AdHocExecutePromptEvent]:
+        input_variables, input_values = self._compile_prompt_inputs()
+
+        return self._context.vellum_client.ad_hoc.adhoc_execute_prompt_stream(
+            ml_model=self.ml_model,
+            input_values=input_values,
+            input_variables=input_variables,
+            parameters=self.parameters,
+            blocks=self.blocks,
+            functions=self.functions,
+            expand_meta=self.expand_meta,
+            request_options=self.request_options,
+        )
+
+    def _compile_prompt_inputs(self) -> Tuple[List[VellumVariable], List[PromptRequestInput]]:
+        input_variables: List[VellumVariable] = []
+        input_values: List[PromptRequestInput] = []
+
+        for input_name, input_value in self.prompt_inputs.items():
+            if isinstance(input_value, str):
+                input_variables.append(
+                    VellumVariable(
+                        # TODO: Determine whether or not we actually need an id here and if we do,
+                        #   figure out how to maintain stable id references.
+                        #   https://app.shortcut.com/vellum/story/4080
+                        id=str(uuid4()),
+                        key=input_name,
+                        type="STRING",
+                    )
+                )
+                input_values.append(
+                    PromptRequestStringInput(
+                        key=input_name,
+                        value=input_value,
+                    )
+                )
+            elif isinstance(input_value, list) and all(isinstance(message, ChatMessage) for message in input_value):
+                input_variables.append(
+                    VellumVariable(
+                        # TODO: Determine whether or not we actually need an id here and if we do,
+                        #   figure out how to maintain stable id references.
+                        #   https://app.shortcut.com/vellum/story/4080
+                        id=str(uuid4()),
+                        key=input_name,
+                        type="CHAT_HISTORY",
+                    )
+                )
+                input_values.append(
+                    PromptRequestChatHistoryInput(
+                        key=input_name,
+                        value=cast(List[ChatMessage], input_value),
+                    )
+                )
+            elif isinstance(input_value, dict):
+                # Note: We may want to fail early here if we know that input_value is not
+                #   JSON serializable.
+                input_values.append(
+                    PromptRequestJsonInput(
+                        key=input_name,
+                        value=input_value,
+                    )
+                )
+            else:
+                raise NodeException(
+                    message=f"Unrecognized input type for input '{input_name}': {input_value.__class__}",
+                    code=VellumErrorCode.INVALID_INPUTS,
+                )
+
+        return input_variables, input_values

vellum/workflows/nodes/displayable/bases/prompt_deployment_node.py

@@ -0,0 +1,98 @@
+from uuid import UUID
+from typing import Any, ClassVar, Dict, Generic, Iterator, List, Optional, Sequence, Union, cast
+
+from vellum import (
+    ChatHistoryInputRequest,
+    ChatMessage,
+    ExecutePromptEvent,
+    JsonInputRequest,
+    PromptDeploymentExpandMetaRequest,
+    PromptDeploymentInputRequest,
+    RawPromptExecutionOverridesRequest,
+    StringInputRequest,
+)
+
+from vellum.workflows.constants import LATEST_RELEASE_TAG, OMIT
+from vellum.workflows.errors import VellumErrorCode
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.nodes.displayable.bases.base_prompt_node import BasePromptNode
+from vellum.workflows.types.generics import StateType
+
+
+class BasePromptDeploymentNode(BasePromptNode, Generic[StateType]):
+    """
+    Used to execute a Prompt Deployment.
+
+    prompt_inputs: EntityInputsInterface - The inputs for the Prompt
+    deployment: Union[UUID, str] - Either the Prompt Deployment's UUID or its name.
+    release_tag: str - The release tag to use for the Prompt Execution
+    external_id: Optional[str] - The external ID to use for the Prompt Execution
+    expand_meta: Optional[PromptDeploymentExpandMetaRequest] - Expandable execution fields to include in the response
+    raw_overrides: Optional[RawPromptExecutionOverridesRequest] - The raw overrides to use for the Prompt Execution
+    expand_raw: Optional[Sequence[str]] - Expandable raw fields to include in the response
+    metadata: Optional[Dict[str, Optional[Any]]] - The metadata to use for the Prompt Execution
+    request_options: Optional[RequestOptions] - The request options to use for the Prompt Execution
+    """
+
+    # Either the Prompt Deployment's UUID or its name.
+    deployment: ClassVar[Union[UUID, str]]
+
+    release_tag: str = LATEST_RELEASE_TAG
+    external_id: Optional[str] = OMIT
+
+    expand_meta: Optional[PromptDeploymentExpandMetaRequest] = OMIT
+    raw_overrides: Optional[RawPromptExecutionOverridesRequest] = OMIT
+    expand_raw: Optional[Sequence[str]] = OMIT
+    metadata: Optional[Dict[str, Optional[Any]]] = OMIT
+
+    def _get_prompt_event_stream(self) -> Iterator[ExecutePromptEvent]:
+        return self._context.vellum_client.execute_prompt_stream(
+            inputs=self._compile_prompt_inputs(),
+            prompt_deployment_id=str(self.deployment) if isinstance(self.deployment, UUID) else None,
+            prompt_deployment_name=self.deployment if isinstance(self.deployment, str) else None,
+            release_tag=self.release_tag,
+            external_id=self.external_id,
+            expand_meta=self.expand_meta,
+            raw_overrides=self.raw_overrides,
+            expand_raw=self.expand_raw,
+            metadata=self.metadata,
+            request_options=self.request_options,
+        )
+
+    def _compile_prompt_inputs(self) -> List[PromptDeploymentInputRequest]:
+        # TODO: We may want to consolidate with subworkflow deployment input compilation
+        # https://app.shortcut.com/vellum/story/4117
+
+        compiled_inputs: List[PromptDeploymentInputRequest] = []
+
+        for input_name, input_value in self.prompt_inputs.items():
+            if isinstance(input_value, str):
+                compiled_inputs.append(
+                    StringInputRequest(
+                        name=input_name,
+                        value=input_value,
+                    )
+                )
+            elif isinstance(input_value, list) and all(isinstance(message, ChatMessage) for message in input_value):
+                compiled_inputs.append(
+                    ChatHistoryInputRequest(
+                        name=input_name,
+                        value=cast(List[ChatMessage], input_value),
+                    )
+                )
+            elif isinstance(input_value, dict):
+                # Note: We may want to fail early here if we know that input_value is not
+                #   JSON serializable.
+                compiled_inputs.append(
+                    JsonInputRequest(
+                        name=input_name,
+                        value=cast(Dict[str, Any], input_value),
+                    )
+                )
+            else:
+                raise NodeException(
+                    message=f"Unrecognized input type for input '{input_name}': {input_value.__class__}",
+                    code=VellumErrorCode.INVALID_INPUTS,
+                )
+
+        return compiled_inputs