vellum-ai 1.2.3__tar.gz → 1.2.4__tar.gz

{vellum_ai-1.2.3 → vellum_ai-1.2.4}/PKG-INFO

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

{vellum_ai-1.2.3 → vellum_ai-1.2.4}/ee/vellum_cli/__init__.py

@@ -68,6 +68,7 @@ with the provided module or be available for use. The Workflow Sandbox must also
 @click.option("--deployment-name", type=str, help="Unique name for the Deployment")
 @click.option("--deployment-description", type=str, help="Description for the Deployment")
 @click.option("--release-tag", help="Release Tag for the Deployment", multiple=True)
+@click.option("--release-description", type=str, help="Description for the Release")
 @click.option(
     "--dry-run",
     is_flag=True,
@@ -87,6 +88,7 @@ def workflows_push(
     deployment_name: Optional[str],
     deployment_description: Optional[str],
     release_tag: Optional[List[str]],
+    release_description: Optional[str],
     dry_run: Optional[bool],
     strict: Optional[bool],
     workspace: Optional[str],
@@ -104,6 +106,7 @@ def workflows_push(
         deployment_name=deployment_name,
         deployment_description=deployment_description,
         release_tags=release_tag,
+        release_description=release_description,
         dry_run=dry_run,
         strict=strict,
         workspace=workspace,
@@ -118,6 +121,7 @@ def workflows_push(
 @click.option("--deployment-name", type=str, help="Unique name for the Deployment")
 @click.option("--deployment-description", type=str, help="Description for the Deployment")
 @click.option("--release-tag", help="Release Tag for the Deployment", multiple=True)
+@click.option("--release-description", type=str, help="Description for the Release")
 @click.option(
     "--dry-run",
     is_flag=True,
@@ -137,6 +141,7 @@ def push_module(
     deployment_name: Optional[str],
     deployment_description: Optional[str],
     release_tag: Optional[List[str]],
+    release_description: Optional[str],
     dry_run: Optional[bool],
     strict: Optional[bool],
     workspace: Optional[str],
@@ -152,6 +157,7 @@ def push_module(
             deployment_name=deployment_name,
             deployment_description=deployment_description,
             release_tags=release_tag,
+            release_description=release_description,
             dry_run=dry_run,
             strict=strict,
             workspace=workspace,

{vellum_ai-1.2.3 → vellum_ai-1.2.4}/ee/vellum_cli/config.py

@@ -36,6 +36,7 @@ class WorkflowDeploymentConfig(UniversalBaseModel):
     name: Optional[str] = None
     description: Optional[str] = None
     release_tags: Optional[List[str]] = None
+    release_description: Optional[str] = None
 
     def merge(self, other: "WorkflowDeploymentConfig") -> "WorkflowDeploymentConfig":
         return WorkflowDeploymentConfig(
@@ -44,6 +45,7 @@ class WorkflowDeploymentConfig(UniversalBaseModel):
             name=self.name or other.name,
             description=self.description or other.description,
             release_tags=self.release_tags or other.release_tags,
+            release_description=self.release_description or other.release_description,
         )
 
 

{vellum_ai-1.2.3 → vellum_ai-1.2.4}/ee/vellum_cli/push.py

@@ -28,6 +28,7 @@ def push_command(
     deployment_name: Optional[str] = None,
     deployment_description: Optional[str] = None,
     release_tags: Optional[List[str]] = None,
+    release_description: Optional[str] = None,
     dry_run: Optional[bool] = None,
     strict: Optional[bool] = None,
     workspace: Optional[str] = None,
@@ -142,6 +143,7 @@ def push_command(
                 name=deployment_name or cli_deployment_config.name or to_kebab_case(module_name),
                 description=deployment_description or cli_deployment_config.description,
                 release_tags=release_tags or cli_deployment_config.release_tags,
+                release_description=release_description or cli_deployment_config.release_description,
             )
         except ValidationError as e:
             for error in e.errors():
@@ -286,6 +288,7 @@ Visit at: {base_url}/workflow-sandboxes/{response.workflow_sandbox_id}"""
             name=deployment_config.name if deploy else None,
             description=deployment_config.description if deploy else None,
             release_tags=deployment_config.release_tags if deploy else None,
+            release_description=getattr(deployment_config, "release_description", None) if deploy else None,
         )
         workflow_config.deployments.append(stored_deployment_config)
 

{vellum_ai-1.2.3 → vellum_ai-1.2.4}/ee/vellum_cli/tests/test_pull.py

@@ -393,6 +393,7 @@ def test_pull__workflow_deployment_with_no_config(vellum_client):
                             "name": "my-deployment",
                             "description": None,
                             "release_tags": None,
+                            "release_description": None,
                         }
                     ],
                     "container_image_tag": None,
@@ -641,6 +642,7 @@ def test_pull__sandbox_id_with_other_workflow_deployment_in_lock(vellum_client,
                         "name": None,
                         "description": None,
                         "release_tags": None,
+                        "release_description": None,
                     },
                 ],
                 "container_image_name": None,

{vellum_ai-1.2.3 → vellum_ai-1.2.4}/ee/vellum_cli/tests/test_push.py

@@ -1042,6 +1042,45 @@ def test_push__deploy_with_release_tags_success(mock_module, vellum_client):
     assert "Updated vellum.lock.json file." in result.output
 
 
+@pytest.mark.usefixtures("info_log_level")
+def test_push__deploy_with_release_description_success(mock_module, vellum_client):
+    # GIVEN a single workflow configured
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
+
+    # AND a workflow exists in the module successfully
+    _ensure_workflow_py(temp_dir, module)
+
+    # AND the push API call returns successfully
+    workflow_deployment_id = str(uuid4())
+    vellum_client.workflows.push.return_value = WorkflowPushResponse(
+        workflow_sandbox_id=str(uuid4()),
+        workflow_deployment_id=workflow_deployment_id,
+    )
+
+    # WHEN calling `vellum workflows push` with --deploy and --release-description
+    runner = CliRunner()
+    result = runner.invoke(
+        cli_main, ["workflows", "push", module, "--deploy", "--release-description", "This is a test release"]
+    )
+
+    # THEN it should succeed
+    assert result.exit_code == 0, result.output
+
+    # AND we should have called the push API with the correct deployment config
+    vellum_client.workflows.push.assert_called_once()
+    call_args = vellum_client.workflows.push.call_args.kwargs
+
+    # AND the deployment_config should contain the release description
+    deployment_config_str = call_args["deployment_config"]
+    deployment_config = json.loads(deployment_config_str)
+    assert deployment_config["release_description"] == "This is a test release"
+
+    # AND should show success message
+    assert "Successfully pushed" in result.output
+    assert "Updated vellum.lock.json file." in result.output
+
+
 def test_push__deploy_stores_deployment_config_in_lock_file(mock_module, vellum_client):
     # GIVEN a single workflow
     temp_dir = mock_module.temp_dir

{vellum_ai-1.2.3 → vellum_ai-1.2.4}/ee/vellum_ee/workflows/display/nodes/vellum/tests/test_tool_calling_node.py

@@ -191,6 +191,7 @@ def test_serialize_node__tool_calling_node__mcp_server_api_key():
                     {
                         "type": "MCP_SERVER",
                         "name": "my-mcp-server",
+                        "description": "",
                         "url": "https://my-mcp-server.com",
                         "authorization_type": "API_KEY",
                         "bearer_token_value": None,
@@ -243,6 +244,7 @@ def test_serialize_node__tool_calling_node__mcp_server_no_authorization():
                     {
                         "type": "MCP_SERVER",
                         "name": "my-mcp-server",
+                        "description": "",
                         "url": "https://my-mcp-server.com",
                         "authorization_type": None,
                         "bearer_token_value": None,

{vellum_ai-1.2.3 → vellum_ai-1.2.4}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_mcp_serialization.py

@@ -52,6 +52,7 @@ def test_serialize_workflow():
                     {
                         "type": "MCP_SERVER",
                         "name": "github",
+                        "description": "",
                         "url": "https://api.githubcopilot.com/mcp/",
                         "authorization_type": "BEARER_TOKEN",
                         "bearer_token_value": "GITHUB_PERSONAL_ACCESS_TOKEN",

{vellum_ai-1.2.3 → vellum_ai-1.2.4}/pyproject.toml

@@ -3,7 +3,7 @@ name = "vellum-ai"
 
 [tool.poetry]
 name = "vellum-ai"
-version = "1.2.3"
+version = "1.2.4"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-1.2.3 → vellum_ai-1.2.4}/src/vellum/client/core/client_wrapper.py

@@ -27,10 +27,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "vellum-ai/1.2.3",
+            "User-Agent": "vellum-ai/1.2.4",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.2.3",
+            "X-Fern-SDK-Version": "1.2.4",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

{vellum_ai-1.2.3 → vellum_ai-1.2.4}/src/vellum/workflows/events/tests/test_event.py

@@ -93,6 +93,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                     "workflow_version_exec_config": None,
                 },
                 "parent": None,
+                "links": None,
             },
         ),
         (
@@ -156,6 +157,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                     "type": "WORKFLOW_NODE",
                     "span_id": "123e4567-e89b-12d3-a456-426614174000",
                 },
+                "links": None,
             },
         ),
         (
@@ -191,6 +193,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                     },
                 },
                 "parent": None,
+                "links": None,
             },
         ),
         (
@@ -224,6 +227,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                     },
                 },
                 "parent": None,
+                "links": None,
             },
         ),
         (
@@ -259,6 +263,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                     },
                 },
                 "parent": None,
+                "links": None,
             },
         ),
         (
@@ -294,6 +299,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                     },
                 },
                 "parent": None,
+                "links": None,
             },
         ),
         (
@@ -334,6 +340,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                     "mocked": None,
                 },
                 "parent": None,
+                "links": None,
             },
         ),
         (
@@ -372,6 +379,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                     "mocked": None,
                 },
                 "parent": None,
+                "links": None,
             },
         ),
         (
@@ -405,6 +413,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                     "mocked": True,
                 },
                 "parent": None,
+                "links": None,
             },
         ),
     ],

{vellum_ai-1.2.3 → vellum_ai-1.2.4}/src/vellum/workflows/events/types.py

@@ -1,12 +1,13 @@
 from datetime import datetime
 import json
 from uuid import UUID, uuid4
-from typing import Annotated, Any, Literal, Optional, Union, get_args
+from typing import Annotated, Any, List, Literal, Optional, Union, get_args
 
 from pydantic import Field, GetCoreSchemaHandler, Tag, ValidationInfo
 from pydantic_core import CoreSchema, core_schema
 
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
+from vellum.client.types.span_link import SpanLink
 from vellum.workflows.state.encoder import DefaultStateEncoder
 from vellum.workflows.types.definition import VellumCodeResourceDefinition
 from vellum.workflows.types.utils import datetime_now
@@ -164,3 +165,4 @@ class BaseEvent(UniversalBaseModel):
     trace_id: UUID
     span_id: UUID
     parent: Optional[ParentContext] = None
+    links: Optional[List[SpanLink]] = None

{vellum_ai-1.2.3 → vellum_ai-1.2.4}/src/vellum/workflows/integrations/tests/test_mcp_service.py

@@ -2,7 +2,9 @@ import asyncio
 import json
 from unittest import mock
 
-from vellum.workflows.integrations.mcp_service import MCPHttpClient
+from vellum.workflows.constants import AuthorizationType
+from vellum.workflows.integrations.mcp_service import MCPHttpClient, MCPService
+from vellum.workflows.types.definition import MCPServer
 
 
 def test_mcp_http_client_sse_response():
@@ -79,3 +81,40 @@ def test_mcp_http_client_json_response():
 
         # THEN the JSON response should be returned as expected
         assert result == sample_json_response
+
+
+def test_mcp_service_bearer_token_auth():
+    """Test that bearer token auth headers are set correctly"""
+    # GIVEN an MCP server with bearer token auth
+    server = MCPServer(
+        name="test-server",
+        url="https://test.server.com",
+        authorization_type=AuthorizationType.BEARER_TOKEN,
+        bearer_token_value="test-token-123",
+    )
+
+    # WHEN we get auth headers
+    service = MCPService()
+    headers = service._get_auth_headers(server)
+
+    # THEN the Authorization header should be set correctly
+    assert headers == {"Authorization": "Bearer test-token-123"}
+
+
+def test_mcp_service_api_key_auth():
+    """Test that API key auth headers are set correctly"""
+    # GIVEN an MCP server with API key auth
+    server = MCPServer(
+        name="test-server",
+        url="https://test.server.com",
+        authorization_type=AuthorizationType.API_KEY,
+        api_key_header_key="X-API-Key",
+        api_key_header_value="api-key-123",
+    )
+
+    # WHEN we get auth headers
+    service = MCPService()
+    headers = service._get_auth_headers(server)
+
+    # THEN the custom API key header should be set correctly
+    assert headers == {"X-API-Key": "api-key-123"}

{vellum_ai-1.2.3 → vellum_ai-1.2.4}/src/vellum/workflows/nodes/core/templating_node/node.py

@@ -7,7 +7,7 @@ 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.utils import parse_type_from_str
+from vellum.workflows.nodes.utils import parse_type_from_str, wrap_inputs_for_backward_compatibility
 from vellum.workflows.types.core import EntityInputsInterface
 from vellum.workflows.types.generics import StateType
 from vellum.workflows.types.utils import get_original_base
@@ -86,9 +86,10 @@ class TemplatingNode(BaseNode[StateType], Generic[StateType, _OutputType], metac
 
     def _render_template(self) -> str:
         try:
+            wrapped_inputs = wrap_inputs_for_backward_compatibility(self.inputs)
             return render_sandboxed_jinja_template(
                 template=self.template,
-                input_values=self.inputs,
+                input_values=wrapped_inputs,
                 jinja_custom_filters={**self.jinja_custom_filters},
                 jinja_globals=self.jinja_globals,
             )

{vellum_ai-1.2.3 → vellum_ai-1.2.4}/src/vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py

@@ -317,3 +317,132 @@ def test_api_error_templating_node():
 
     # THEN the output should be empty string
     assert outputs.result == ""
+
+
+@pytest.mark.parametrize(
+    "template,inputs,expected_result",
+    [
+        # String value access
+        ("{{ text_input.value }}", {"text_input": "hello world"}, "hello world"),
+        # Function call value access
+        (
+            "{{ func.value.name }}",
+            {"func": FunctionCall(name="test_function", arguments={"key": "value"})},
+            "test_function",
+        ),
+        # Array item value access
+        ("{{ items[0].value }}", {"items": ["apple"]}, "apple"),
+    ],
+    ids=["string_value", "function_call_value", "array_item_value"],
+)
+def test_templating_node__value_access_patterns_str(template, inputs, expected_result):
+    # GIVEN a templating node that accesses wrapper value properties
+    class TemplateNode(TemplatingNode[BaseState, str]):
+        pass
+
+    # Set template and inputs dynamically
+    TemplateNode.template = template
+    TemplateNode.inputs = inputs
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN the value is accessible
+    assert outputs.result == expected_result
+
+
+@pytest.mark.parametrize(
+    "template,inputs,expected_result",
+    [
+        # Dict value access
+        ("{{ data.value }}", {"data": {"name": "test", "score": 42}}, {"name": "test", "score": 42}),
+        # List value access
+        ("{{ items.value }}", {"items": ["item1", "item2", "item3"]}, ["item1", "item2", "item3"]),
+    ],
+    ids=["dict_value", "list_value"],
+)
+def test_templating_node__value_access_patterns_json(template, inputs, expected_result):
+    # GIVEN a templating node that accesses wrapper value properties
+    class TemplateNode(TemplatingNode[BaseState, Json]):
+        pass
+
+    # Set template and inputs dynamically
+    TemplateNode.template = template
+    TemplateNode.inputs = inputs
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN the value is accessible
+    assert outputs.result == expected_result
+
+
+@pytest.mark.parametrize(
+    "template,inputs,expected_result",
+    [
+        # String type access
+        ("{{ text_input.type }}", {"text_input": "hello world"}, "STRING"),
+        # Function call type access
+        ("{{ func.type }}", {"func": FunctionCall(name="test_function", arguments={"key": "value"})}, "FUNCTION_CALL"),
+    ],
+    ids=["string_type", "function_call_type"],
+)
+def test_templating_node__type_access_patterns(template, inputs, expected_result):
+    # GIVEN a templating node that accesses wrapper type properties
+    class TemplateNode(TemplatingNode[BaseState, str]):
+        pass
+
+    # Set template and inputs dynamically
+    TemplateNode.template = template
+    TemplateNode.inputs = inputs
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN the type is accessible
+    assert outputs.result == expected_result
+
+
+def test_templating_node__nested_dict_access():
+    # GIVEN a templating node with nested dict access
+    class TemplateNode(TemplatingNode[BaseState, str]):
+        template = "{{ data.user.name }}"
+        inputs = {"data": {"user": {"name": "John Doe", "age": 30}, "status": "active"}}
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN nested properties are accessible
+    assert outputs.result == "John Doe"
+
+
+def test_templating_node__list_iteration_wrapper_access():
+    # GIVEN a templating node that iterates over list with wrapper access
+    class TemplateNode(TemplatingNode[BaseState, str]):
+        template = "{% for item in items %}{{ item.value }}{% if not loop.last %},{% endif %}{% endfor %}"
+        inputs = {"items": ["apple", "banana", "cherry"]}
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN list iteration with wrapper access works
+    assert outputs.result == "apple,banana,cherry"
+
+
+def test_templating_node__conditional_type_checking():
+    # GIVEN a templating node with conditional type checking
+    class TemplateNode(TemplatingNode[BaseState, str]):
+        template = "{% if input.type == 'STRING' %}{{ input.value }}{% else %}unknown{% endif %}"
+        inputs = {"input": "test string"}
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN conditional type checking works
+    assert outputs.result == "test string"

{vellum_ai-1.2.3 → vellum_ai-1.2.4}/src/vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py

@@ -28,6 +28,7 @@ from vellum.workflows.errors.types import vellum_error_to_workflow_error
 from vellum.workflows.events.types import default_serializer
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.bases.base_prompt_node import BasePromptNode
+from vellum.workflows.nodes.displayable.bases.utils import process_additional_prompt_outputs
 from vellum.workflows.outputs import BaseOutput
 from vellum.workflows.types import MergeBehavior
 from vellum.workflows.types.definition import DeploymentDefinition
@@ -197,6 +198,17 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
             elif event.state == "STREAMING":
                 yield BaseOutput(name="results", delta=event.output.value)
             elif event.state == "FULFILLED":
+                if event.meta and event.meta.finish_reason == "LENGTH":
+                    text_value, json_value = process_additional_prompt_outputs(event.outputs)
+                    if text_value == "":
+                        raise NodeException(
+                            message=(
+                                "Maximum tokens reached before model could output any content. "
+                                "Consider increasing the max_tokens Prompt Parameter."
+                            ),
+                            code=WorkflowErrorCode.INVALID_OUTPUTS,
+                        )
+
                 outputs = event.outputs
                 yield BaseOutput(name="results", value=event.outputs)
             elif event.state == "REJECTED":

{vellum_ai-1.2.3 → vellum_ai-1.2.4}/src/vellum/workflows/nodes/displayable/bases/inline_prompt_node/tests/test_inline_prompt_node.py

@@ -20,6 +20,7 @@ from vellum import (
 )
 from vellum.client.types.execute_prompt_event import ExecutePromptEvent
 from vellum.client.types.fulfilled_execute_prompt_event import FulfilledExecutePromptEvent
+from vellum.client.types.fulfilled_prompt_execution_meta import FulfilledPromptExecutionMeta
 from vellum.client.types.initiated_execute_prompt_event import InitiatedExecutePromptEvent
 from vellum.client.types.prompt_output import PromptOutput
 from vellum.client.types.prompt_request_string_input import PromptRequestStringInput
@@ -684,3 +685,43 @@ def test_inline_prompt_node__invalid_function_type():
     # AND the error should have the correct code and message
     assert excinfo.value.code == WorkflowErrorCode.INVALID_INPUTS
     assert "`not_a_function` is not a valid function definition" == str(excinfo.value)
+
+
+def test_inline_prompt_node__empty_string_output_with_length_finish_reason(vellum_adhoc_prompt_client):
+    """
+    Tests that InlinePromptNode raises NodeException for empty string output with LENGTH finish_reason.
+    """
+
+    # GIVEN an InlinePromptNode with basic configuration
+    class TestNode(InlinePromptNode):
+        ml_model = "test-model"
+        blocks = []
+        prompt_inputs = {}
+
+    expected_outputs: List[PromptOutput] = [
+        StringVellumValue(value=""),
+    ]
+
+    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,
+                meta=FulfilledPromptExecutionMeta(finish_reason="LENGTH"),
+            ),
+        ]
+        yield from events
+
+    vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.side_effect = generate_prompt_events
+
+    # WHEN the node is run
+    node = TestNode()
+
+    # THEN it should raise a NodeException with INVALID_OUTPUTS error code
+    with pytest.raises(NodeException) as excinfo:
+        list(node.run())
+
+    # AND the exception should have the correct error code
+    assert excinfo.value.code == WorkflowErrorCode.INVALID_OUTPUTS

{vellum_ai-1.2.3 → vellum_ai-1.2.4}/src/vellum/workflows/nodes/displayable/bases/utils.py

@@ -1,7 +1,8 @@
 import enum
 import json
-from typing import Any, List, Union, cast
+from typing import Any, List, Optional, Tuple, Union, cast
 
+from vellum import PromptOutput
 from vellum.client.types.array_vellum_value import ArrayVellumValue
 from vellum.client.types.array_vellum_value_request import ArrayVellumValueRequest
 from vellum.client.types.audio_vellum_value import AudioVellumValue
@@ -123,3 +124,39 @@ def primitive_to_vellum_value_request(value: Any) -> VellumValueRequest:
         raise ValueError(f"Unsupported variable type: {vellum_value.__class__.__name__}")
 
     return vellum_value_request_class.model_validate(vellum_value.model_dump())
+
+
+def process_additional_prompt_outputs(outputs: List[PromptOutput]) -> Tuple[str, Optional[Any]]:
+    """
+    Process prompt outputs using the same logic as prompt nodes to determine text output.
+
+    Args:
+        outputs: List of prompt outputs to process
+
+    Returns:
+        The text representation of the outputs joined with newlines
+        The JSON representation of the outputs
+    """
+    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))
+            json_output = output.value
+        elif output.type == "FUNCTION_CALL":
+            string_outputs.append(output.value.model_dump_json(indent=4))
+        elif output.type == "THINKING":
+            continue
+        else:
+            string_outputs.append(output.value.message)
+
+    return "\n".join(string_outputs), json_output