vellum-ai 0.14.35__tar.gz → 0.14.36__tar.gz

{vellum_ai-0.14.35 → vellum_ai-0.14.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 0.14.35
+Version: 0.14.36
 Summary: 
 License: MIT
 Requires-Python: >=3.9,<4.0

{vellum_ai-0.14.35 → vellum_ai-0.14.36}/ee/vellum_cli/pull.py

@@ -35,6 +35,7 @@ class PullContentsMetadata(UniversalBaseModel):
     runner_config: Optional[RunnerConfig] = None
     deployment_id: Optional[UUID] = None
     deployment_name: Optional[str] = None
+    workflow_sandbox_id: Optional[UUID] = None
 
 
 def _resolve_workflow_config(
@@ -198,6 +199,8 @@ def pull_command(
                     workflow_config.container_image_tag = pull_contents_metadata.runner_config.container_image_tag
                     if workflow_config.container_image_name and not workflow_config.container_image_tag:
                         workflow_config.container_image_tag = "latest"
+                if not workflow_config.workflow_sandbox_id and pull_contents_metadata.workflow_sandbox_id:
+                    workflow_config.workflow_sandbox_id = str(pull_contents_metadata.workflow_sandbox_id)
                 if not workflow_config.module and workflow_deployment and pull_contents_metadata.deployment_name:
                     workflow_config.module = snake_case(pull_contents_metadata.deployment_name)
                 if not workflow_config.module and pull_contents_metadata.label:

{vellum_ai-0.14.35 → vellum_ai-0.14.36}/ee/vellum_cli/tests/test_pull.py

@@ -1185,7 +1185,7 @@ def test_pull__workflow_deployment_with_name_and_id(vellum_client):
     deployment_id = str(uuid4())  # config will always use the deployment_id return from the API
     deployment_name = "Test Deployment"
     deployment_label = "Test Label"
-
+    workflow_sandbox_id = str(uuid4())
     # AND the workflow pull API call returns a zip file with metadata
     vellum_client.workflows.pull.return_value = iter(
         [
@@ -1197,6 +1197,7 @@ def test_pull__workflow_deployment_with_name_and_id(vellum_client):
                             "deployment_id": deployment_id,
                             "deployment_name": deployment_name,
                             "label": deployment_label,
+                            "workflow_sandbox_id": workflow_sandbox_id,
                         }
                     ),
                 }
@@ -1227,6 +1228,7 @@ def test_pull__workflow_deployment_with_name_and_id(vellum_client):
         assert str(deployment["id"]) == deployment_id
         assert deployment["name"] == deployment_name
         assert deployment["label"] == deployment_label
+        assert lock_data["workflows"][0]["workflow_sandbox_id"] == workflow_sandbox_id
 
     os.chdir(current_dir)
 

{vellum_ai-0.14.35 → vellum_ai-0.14.36}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vellum-ai"
-version = "0.14.35"
+version = "0.14.36"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-0.14.35 → vellum_ai-0.14.36}/src/vellum/__init__.py

@@ -300,6 +300,9 @@ from .types import (
     PromptDeploymentExpandMetaRequest,
     PromptDeploymentInputRequest,
     PromptDeploymentParentContext,
+    PromptDeploymentRelease,
+    PromptDeploymentReleasePromptDeployment,
+    PromptDeploymentReleasePromptVersion,
     PromptExecConfig,
     PromptExecutionMeta,
     PromptNodeExecutionMeta,
@@ -922,6 +925,9 @@ __all__ = [
     "PromptDeploymentExpandMetaRequest",
     "PromptDeploymentInputRequest",
     "PromptDeploymentParentContext",
+    "PromptDeploymentRelease",
+    "PromptDeploymentReleasePromptDeployment",
+    "PromptDeploymentReleasePromptVersion",
     "PromptExecConfig",
     "PromptExecutionMeta",
     "PromptNodeExecutionMeta",

{vellum_ai-0.14.35 → vellum_ai-0.14.36}/src/vellum/client/core/client_wrapper.py

@@ -18,7 +18,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.14.35",
+            "X-Fern-SDK-Version": "0.14.36",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

{vellum_ai-0.14.35 → vellum_ai-0.14.36}/src/vellum/client/resources/release_reviews/client.py

@@ -3,11 +3,12 @@
 from ...core.client_wrapper import SyncClientWrapper
 import typing
 from ...core.request_options import RequestOptions
-from ...types.workflow_deployment_release import WorkflowDeploymentRelease
+from ...types.prompt_deployment_release import PromptDeploymentRelease
 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 ...types.workflow_deployment_release import WorkflowDeploymentRelease
 from ...core.client_wrapper import AsyncClientWrapper
 
 
@@ -15,6 +16,60 @@ class ReleaseReviewsClient:
     def __init__(self, *, client_wrapper: SyncClientWrapper):
         self._client_wrapper = client_wrapper
 
+    def retrieve_prompt_deployment_release(
+        self, id: str, release_id_or_release_tag: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> PromptDeploymentRelease:
+        """
+        Retrieve a specific Prompt Deployment Release by either its UUID or the name of a Release Tag that points to it.
+
+        Parameters
+        ----------
+        id : str
+            A UUID string identifying this deployment.
+
+        release_id_or_release_tag : str
+            Either the UUID of Prompt Deployment Release you'd like to retrieve, or the name of a Release Tag that's pointing to the Prompt Deployment Release you'd like to retrieve.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        PromptDeploymentRelease
+
+
+        Examples
+        --------
+        from vellum import Vellum
+
+        client = Vellum(
+            api_key="YOUR_API_KEY",
+        )
+        client.release_reviews.retrieve_prompt_deployment_release(
+            id="id",
+            release_id_or_release_tag="release_id_or_release_tag",
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/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(
+                    PromptDeploymentRelease,
+                    parse_obj_as(
+                        type_=PromptDeploymentRelease,  # 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)
+
     def retrieve_workflow_deployment_release(
         self, id: str, release_id_or_release_tag: str, *, request_options: typing.Optional[RequestOptions] = None
     ) -> WorkflowDeploymentRelease:
@@ -74,6 +129,68 @@ class AsyncReleaseReviewsClient:
     def __init__(self, *, client_wrapper: AsyncClientWrapper):
         self._client_wrapper = client_wrapper
 
+    async def retrieve_prompt_deployment_release(
+        self, id: str, release_id_or_release_tag: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> PromptDeploymentRelease:
+        """
+        Retrieve a specific Prompt Deployment Release by either its UUID or the name of a Release Tag that points to it.
+
+        Parameters
+        ----------
+        id : str
+            A UUID string identifying this deployment.
+
+        release_id_or_release_tag : str
+            Either the UUID of Prompt Deployment Release you'd like to retrieve, or the name of a Release Tag that's pointing to the Prompt Deployment Release you'd like to retrieve.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        PromptDeploymentRelease
+
+
+        Examples
+        --------
+        import asyncio
+
+        from vellum import AsyncVellum
+
+        client = AsyncVellum(
+            api_key="YOUR_API_KEY",
+        )
+
+
+        async def main() -> None:
+            await client.release_reviews.retrieve_prompt_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/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(
+                    PromptDeploymentRelease,
+                    parse_obj_as(
+                        type_=PromptDeploymentRelease,  # 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)
+
     async def retrieve_workflow_deployment_release(
         self, id: str, release_id_or_release_tag: str, *, request_options: typing.Optional[RequestOptions] = None
     ) -> WorkflowDeploymentRelease:

{vellum_ai-0.14.35 → vellum_ai-0.14.36}/src/vellum/client/types/__init__.py

@@ -308,6 +308,9 @@ from .prompt_block_state import PromptBlockState
 from .prompt_deployment_expand_meta_request import PromptDeploymentExpandMetaRequest
 from .prompt_deployment_input_request import PromptDeploymentInputRequest
 from .prompt_deployment_parent_context import PromptDeploymentParentContext
+from .prompt_deployment_release import PromptDeploymentRelease
+from .prompt_deployment_release_prompt_deployment import PromptDeploymentReleasePromptDeployment
+from .prompt_deployment_release_prompt_version import PromptDeploymentReleasePromptVersion
 from .prompt_exec_config import PromptExecConfig
 from .prompt_execution_meta import PromptExecutionMeta
 from .prompt_node_execution_meta import PromptNodeExecutionMeta
@@ -902,6 +905,9 @@ __all__ = [
     "PromptDeploymentExpandMetaRequest",
     "PromptDeploymentInputRequest",
     "PromptDeploymentParentContext",
+    "PromptDeploymentRelease",
+    "PromptDeploymentReleasePromptDeployment",
+    "PromptDeploymentReleasePromptVersion",
     "PromptExecConfig",
     "PromptExecutionMeta",
     "PromptNodeExecutionMeta",

vellum_ai-0.14.36/src/vellum/client/types/prompt_deployment_release.py

@@ -0,0 +1,34 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import datetime as dt
+from .release_environment import ReleaseEnvironment
+import typing
+from .release_created_by import ReleaseCreatedBy
+from .prompt_deployment_release_prompt_version import PromptDeploymentReleasePromptVersion
+from .prompt_deployment_release_prompt_deployment import PromptDeploymentReleasePromptDeployment
+from .release_release_tag import ReleaseReleaseTag
+from .slim_release_review import SlimReleaseReview
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
+
+
+class PromptDeploymentRelease(UniversalBaseModel):
+    id: str
+    created: dt.datetime
+    environment: ReleaseEnvironment
+    created_by: typing.Optional[ReleaseCreatedBy] = None
+    prompt_version: PromptDeploymentReleasePromptVersion
+    deployment: PromptDeploymentReleasePromptDeployment
+    description: typing.Optional[str] = None
+    release_tags: typing.List[ReleaseReleaseTag]
+    reviews: typing.List[SlimReleaseReview]
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vellum_ai-0.14.36/src/vellum/client/types/prompt_deployment_release_prompt_deployment.py

@@ -0,0 +1,19 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import typing
+import pydantic
+
+
+class PromptDeploymentReleasePromptDeployment(UniversalBaseModel):
+    name: str
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vellum_ai-0.14.36/src/vellum/client/types/prompt_deployment_release_prompt_version.py

@@ -0,0 +1,19 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import typing
+import pydantic
+
+
+class PromptDeploymentReleasePromptVersion(UniversalBaseModel):
+    id: str
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vellum_ai-0.14.36/src/vellum/types/prompt_deployment_release.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.prompt_deployment_release import *

vellum_ai-0.14.36/src/vellum/types/prompt_deployment_release_prompt_deployment.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.prompt_deployment_release_prompt_deployment import *

vellum_ai-0.14.36/src/vellum/types/prompt_deployment_release_prompt_version.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.prompt_deployment_release_prompt_version import *

{vellum_ai-0.14.35 → vellum_ai-0.14.36}/src/vellum/workflows/nodes/displayable/guardrail_node/node.py

@@ -34,6 +34,7 @@ class GuardrailNode(BaseNode[StateType], Generic[StateType]):
 
     class Outputs(BaseOutputs):
         score: float
+        normalized_score: Optional[float]
         log: Optional[str]
 
     def run(self) -> Outputs:
@@ -46,16 +47,30 @@ class GuardrailNode(BaseNode[StateType], Generic[StateType]):
 
         metric_outputs = {output.name: output.value for output in metric_execution.outputs}
 
-        score = metric_outputs.get("score")
+        SCORE_KEY = "score"
+        NORMALIZED_SCORE_KEY = "normalized_score"
+        LOG_KEY = "log"
+
+        score = metric_outputs.get(SCORE_KEY)
         if not isinstance(score, float):
             raise NodeException(
-                message="Metric execution must have one output named 'score' with type 'float'",
+                message=f"Metric execution must have one output named '{SCORE_KEY}' with type 'float'",
                 code=WorkflowErrorCode.INVALID_OUTPUTS,
             )
-        metric_outputs.pop("score")
+        metric_outputs.pop(SCORE_KEY)
+
+        if NORMALIZED_SCORE_KEY in metric_outputs:
+            normalized_score = metric_outputs.pop(NORMALIZED_SCORE_KEY)
+            if not isinstance(normalized_score, float):
+                raise NodeException(
+                    message=f"Metric execution must have one output named '{NORMALIZED_SCORE_KEY}' with type 'float'",
+                    code=WorkflowErrorCode.INVALID_OUTPUTS,
+                )
+        else:
+            normalized_score = None
 
-        if "log" in metric_outputs:
-            log = metric_outputs.pop("log") or ""
+        if LOG_KEY in metric_outputs:
+            log = metric_outputs.pop(LOG_KEY) or ""
             if not isinstance(log, str):
                 raise NodeException(
                     message="Metric execution log output must be of type 'str'",
@@ -64,7 +79,7 @@ class GuardrailNode(BaseNode[StateType], Generic[StateType]):
         else:
             log = None
 
-        return self.Outputs(score=score, log=log, **metric_outputs)
+        return self.Outputs(score=score, normalized_score=normalized_score, log=log, **metric_outputs)
 
     def _compile_metric_inputs(self) -> List[MetricDefinitionInput]:
         # TODO: We may want to consolidate with prompt deployment input compilation

vellum_ai-0.14.36/src/vellum/workflows/nodes/displayable/guardrail_node/test_node.py

@@ -0,0 +1,101 @@
+import pytest
+
+from vellum import TestSuiteRunMetricNumberOutput
+from vellum.client.types.metric_definition_execution import MetricDefinitionExecution
+from vellum.client.types.test_suite_run_metric_string_output import TestSuiteRunMetricStringOutput
+from vellum.workflows.errors import WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.nodes.displayable.guardrail_node.node import GuardrailNode
+
+
+@pytest.mark.parametrize("log_value", [None, ""], ids=["None", "Empty"])
+def test_run_guardrail_node__empty_log(vellum_client, log_value):
+    """Confirm that we can successfully invoke a Guardrail Node"""
+
+    # GIVEN a Guardrail Node
+    class MyGuard(GuardrailNode):
+        metric_definition = "example_metric_definition"
+        metric_inputs = {}
+
+    # AND we know that the guardrail node will return a blank log
+    mock_metric_execution = MetricDefinitionExecution(
+        outputs=[
+            TestSuiteRunMetricNumberOutput(
+                name="score",
+                value=0.6,
+            ),
+            TestSuiteRunMetricStringOutput(
+                name="log",
+                value=log_value,
+            ),
+        ],
+    )
+    vellum_client.metric_definitions.execute_metric_definition.return_value = mock_metric_execution
+
+    # WHEN we run the Guardrail Node
+    outputs = MyGuard().run()
+
+    # THEN the workflow should have completed successfully
+    assert outputs.score == 0.6
+    assert outputs.log == ""
+
+
+def test_run_guardrail_node__normalized_score(vellum_client):
+    """Confirm that we can successfully invoke a Guardrail Node"""
+
+    # GIVEN a Guardrail Node
+    class MyGuard(GuardrailNode):
+        metric_definition = "example_metric_definition"
+        metric_inputs = {}
+
+    # AND we know that the guardrail node will return a normalized score
+    mock_metric_execution = MetricDefinitionExecution(
+        outputs=[
+            TestSuiteRunMetricNumberOutput(
+                name="score",
+                value=0.6,
+            ),
+            TestSuiteRunMetricNumberOutput(
+                name="normalized_score",
+                value=1.0,
+            ),
+        ],
+    )
+    vellum_client.metric_definitions.execute_metric_definition.return_value = mock_metric_execution
+
+    # WHEN we run the Guardrail Node
+    outputs = MyGuard().run()
+
+    # THEN the workflow should have completed successfully
+    assert outputs.score == 0.6
+    assert outputs.normalized_score == 1.0
+
+
+def test_run_guardrail_node__normalized_score_null(vellum_client):
+    # GIVEN a Guardrail Node
+    class MyGuard(GuardrailNode):
+        metric_definition = "example_metric_definition"
+        metric_inputs = {}
+
+    # AND we know that the guardrail node will return a normalized score that is None
+    mock_metric_execution = MetricDefinitionExecution(
+        outputs=[
+            TestSuiteRunMetricNumberOutput(
+                name="score",
+                value=0.6,
+            ),
+            TestSuiteRunMetricNumberOutput(
+                name="normalized_score",
+                value=None,
+            ),
+        ],
+    )
+    vellum_client.metric_definitions.execute_metric_definition.return_value = mock_metric_execution
+
+    # WHEN we run the Guardrail Node
+    with pytest.raises(NodeException) as exc_info:
+        MyGuard().run()
+
+    # THEN we get an exception
+    assert exc_info.value.message == "Metric execution must have one output named 'normalized_score' with type 'float'"
+    assert exc_info.value.code == WorkflowErrorCode.INVALID_OUTPUTS

{vellum_ai-0.14.35 → vellum_ai-0.14.36}/src/vellum/workflows/nodes/displayable/prompt_deployment_node/node.py

@@ -1,6 +1,7 @@
 import json
-from typing import Iterator
+from typing import Any, Dict, Iterator, Type, Union
 
+from vellum.workflows.constants import undefined
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.bases import BasePromptDeploymentNode as BasePromptDeploymentNode
@@ -11,7 +12,7 @@ from vellum.workflows.types.generics import StateType
 
 class PromptDeploymentNode(BasePromptDeploymentNode[StateType]):
     """
-    Used to execute a Prompt Deployment and surface a string output for convenience.
+    Used to execute a Prompt Deployment and surface a string output and json output if applicable for convenience.
 
     prompt_inputs: EntityInputsInterface - The inputs for the Prompt
     deployment: Union[UUID, str] - Either the Prompt Deployment's UUID or its name.
@@ -33,9 +34,11 @@ class PromptDeploymentNode(BasePromptDeploymentNode[StateType]):
         The outputs of the PromptDeploymentNode.
 
         text: str - The result of the Prompt Execution
+        json: Optional[Dict[Any, Any]] - The result of the Prompt Execution in JSON format
         """
 
         text: str
+        json: Union[Dict[Any, Any], Type[undefined]] = undefined
 
     def run(self) -> Iterator[BaseOutput]:
         outputs = yield from self._process_prompt_event_stream()
@@ -46,12 +49,18 @@ class PromptDeploymentNode(BasePromptDeploymentNode[StateType]):
             )
 
         string_outputs = []
+        json_output = None
+
         for output in outputs:
             if output.value is None:
                 continue
 
             if output.type == "STRING":
                 string_outputs.append(output.value)
+                try:
+                    json_output = json.loads(output.value)
+                except (json.JSONDecodeError, TypeError):
+                    pass
             elif output.type == "JSON":
                 string_outputs.append(json.dumps(output.value, indent=4))
             elif output.type == "FUNCTION_CALL":
@@ -61,3 +70,6 @@ class PromptDeploymentNode(BasePromptDeploymentNode[StateType]):
 
         value = "\n".join(string_outputs)
         yield BaseOutput(name="text", value=value)
+
+        if json_output:
+            yield BaseOutput(name="json", value=json_output)

{vellum_ai-0.14.35 → vellum_ai-0.14.36}/src/vellum/workflows/nodes/displayable/prompt_deployment_node/tests/test_node.py

@@ -151,3 +151,46 @@ def test_prompt_deployment_node__parent_context_serialization(mock_httpx_transpo
     request_execution_context = json.loads(call_request_args.read().decode("utf-8"))["execution_context"]
     assert request_execution_context["trace_id"] == str(trace_id)
     assert request_execution_context["parent_context"]
+
+
+def test_prompt_deployment_node__json_output(vellum_client):
+    # GIVEN a PromptDeploymentNode
+    class MyPromptDeploymentNode(PromptDeploymentNode):
+        deployment = "example_prompt_deployment"
+        prompt_inputs = {}
+
+    # AND a known JSON response from invoking a prompt deployment
+    expected_json = {"result": "Hello, world!"}
+    expected_outputs: List[PromptOutput] = [
+        StringVellumValue(value=json.dumps(expected_json)),
+    ]
+
+    def generate_prompt_events(*args: Any, **kwargs: Any) -> Iterator[ExecutePromptEvent]:
+        execution_id = str(uuid4())
+        events: List[ExecutePromptEvent] = [
+            InitiatedExecutePromptEvent(execution_id=execution_id),
+            FulfilledExecutePromptEvent(
+                execution_id=execution_id,
+                outputs=expected_outputs,
+            ),
+        ]
+        yield from events
+
+    vellum_client.execute_prompt_stream.side_effect = generate_prompt_events
+
+    # WHEN the node is run
+    node = MyPromptDeploymentNode()
+    outputs = [o for o in node.run()]
+
+    # THEN the node should have produced the outputs we expect
+    results_output = outputs[0]
+    assert results_output.name == "results"
+    assert results_output.value == expected_outputs
+
+    text_output = outputs[1]
+    assert text_output.name == "text"
+    assert text_output.value == '{"result": "Hello, world!"}'
+
+    json_output = outputs[2]
+    assert json_output.name == "json"
+    assert json_output.value == expected_json

{vellum_ai-0.14.35 → vellum_ai-0.14.36}/src/vellum/workflows/state/base.py

@@ -2,6 +2,7 @@ from collections import defaultdict
 from copy import deepcopy
 from dataclasses import field
 from datetime import datetime
+import logging
 from queue import Queue
 from threading import Lock
 from uuid import UUID, uuid4
@@ -29,6 +30,8 @@ from vellum.workflows.types.utils import (
 if TYPE_CHECKING:
     from vellum.workflows.nodes.bases import BaseNode
 
+logger = logging.getLogger(__name__)
+
 
 class _Snapshottable:
     _snapshot_callback: Callable[[], None]
@@ -377,7 +380,10 @@ class BaseState(metaclass=_BaseStateMeta):
         Snapshots the current state to the workflow emitter. The invoked callback is overridden by the
         workflow runner.
         """
-        self.__snapshot_callback__(deepcopy(self))
+        try:
+            self.__snapshot_callback__(deepcopy(self))
+        except Exception:
+            logger.exception("Failed to snapshot Workflow state.")
 
     @classmethod
     def __get_pydantic_core_schema__(