vellum-ai 1.0.2__py3-none-any.whl → 1.0.4__py3-none-any.whl

vellum/__init__.py

@@ -272,6 +272,7 @@ from .client.types import (
     NodeOutputCompiledNumberValue,
     NodeOutputCompiledSearchResultsValue,
     NodeOutputCompiledStringValue,
+    NodeOutputCompiledThinkingValue,
     NodeOutputCompiledValue,
     NodeParentContext,
     NormalizedLogProbs,
@@ -541,6 +542,7 @@ from .client.types import (
     WorkflowExecutionActualChatHistoryRequest,
     WorkflowExecutionActualJsonRequest,
     WorkflowExecutionActualStringRequest,
+    WorkflowExecutionDetail,
     WorkflowExecutionEventErrorCode,
     WorkflowExecutionEventType,
     WorkflowExecutionFulfilledBody,
@@ -631,6 +633,7 @@ from .resources import (
     test_suite_runs,
     test_suites,
     workflow_deployments,
+    workflow_executions,
     workflow_sandboxes,
     workflows,
     workspace_secrets,
@@ -919,6 +922,7 @@ __all__ = [
     "NodeOutputCompiledNumberValue",
     "NodeOutputCompiledSearchResultsValue",
     "NodeOutputCompiledStringValue",
+    "NodeOutputCompiledThinkingValue",
     "NodeOutputCompiledValue",
     "NodeParentContext",
     "NormalizedLogProbs",
@@ -1192,6 +1196,7 @@ __all__ = [
     "WorkflowExecutionActualChatHistoryRequest",
     "WorkflowExecutionActualJsonRequest",
     "WorkflowExecutionActualStringRequest",
+    "WorkflowExecutionDetail",
     "WorkflowExecutionEventErrorCode",
     "WorkflowExecutionEventType",
     "WorkflowExecutionFulfilledBody",
@@ -1273,6 +1278,7 @@ __all__ = [
     "test_suite_runs",
     "test_suites",
     "workflow_deployments",
+    "workflow_executions",
     "workflow_sandboxes",
     "workflows",
     "workspace_secrets",

vellum/client/__init__.py

@@ -21,6 +21,7 @@ from .resources.test_suite_runs.client import TestSuiteRunsClient
 from .resources.test_suites.client import TestSuitesClient
 from .resources.workflow_deployments.client import WorkflowDeploymentsClient
 from .resources.release_reviews.client import ReleaseReviewsClient
+from .resources.workflow_executions.client import WorkflowExecutionsClient
 from .resources.workflow_sandboxes.client import WorkflowSandboxesClient
 from .resources.workflows.client import WorkflowsClient
 from .resources.workspace_secrets.client import WorkspaceSecretsClient
@@ -79,6 +80,7 @@ from .resources.test_suite_runs.client import AsyncTestSuiteRunsClient
 from .resources.test_suites.client import AsyncTestSuitesClient
 from .resources.workflow_deployments.client import AsyncWorkflowDeploymentsClient
 from .resources.release_reviews.client import AsyncReleaseReviewsClient
+from .resources.workflow_executions.client import AsyncWorkflowExecutionsClient
 from .resources.workflow_sandboxes.client import AsyncWorkflowSandboxesClient
 from .resources.workflows.client import AsyncWorkflowsClient
 from .resources.workspace_secrets.client import AsyncWorkspaceSecretsClient
@@ -163,6 +165,7 @@ class Vellum:
         self.test_suites = TestSuitesClient(client_wrapper=self._client_wrapper)
         self.workflow_deployments = WorkflowDeploymentsClient(client_wrapper=self._client_wrapper)
         self.release_reviews = ReleaseReviewsClient(client_wrapper=self._client_wrapper)
+        self.workflow_executions = WorkflowExecutionsClient(client_wrapper=self._client_wrapper)
         self.workflow_sandboxes = WorkflowSandboxesClient(client_wrapper=self._client_wrapper)
         self.workflows = WorkflowsClient(client_wrapper=self._client_wrapper)
         self.workspace_secrets = WorkspaceSecretsClient(client_wrapper=self._client_wrapper)
@@ -1597,6 +1600,7 @@ class AsyncVellum:
         self.test_suites = AsyncTestSuitesClient(client_wrapper=self._client_wrapper)
         self.workflow_deployments = AsyncWorkflowDeploymentsClient(client_wrapper=self._client_wrapper)
         self.release_reviews = AsyncReleaseReviewsClient(client_wrapper=self._client_wrapper)
+        self.workflow_executions = AsyncWorkflowExecutionsClient(client_wrapper=self._client_wrapper)
         self.workflow_sandboxes = AsyncWorkflowSandboxesClient(client_wrapper=self._client_wrapper)
         self.workflows = AsyncWorkflowsClient(client_wrapper=self._client_wrapper)
         self.workspace_secrets = AsyncWorkspaceSecretsClient(client_wrapper=self._client_wrapper)

vellum/client/core/client_wrapper.py

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

vellum/client/reference.md

@@ -6029,6 +6029,64 @@ client.release_reviews.retrieve_workflow_deployment_release(
 </dl>
 
 
+</dd>
+</dl>
+</details>
+
+## WorkflowExecutions
+<details><summary><code>client.workflow_executions.<a href="src/vellum/resources/workflow_executions/client.py">retrieve_workflow_execution_detail</a>(...)</code></summary>
+<dl>
+<dd>
+
+#### 🔌 Usage
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+```python
+from vellum import Vellum
+
+client = Vellum(
+    api_version="YOUR_API_VERSION",
+    api_key="YOUR_API_KEY",
+)
+client.workflow_executions.retrieve_workflow_execution_detail(
+    execution_id="execution_id",
+)
+
+```
+</dd>
+</dl>
+</dd>
+</dl>
+
+#### ⚙️ Parameters
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+**execution_id:** `str` 
+    
+</dd>
+</dl>
+
+<dl>
+<dd>
+
+**request_options:** `typing.Optional[RequestOptions]` — Request-specific configuration.
+    
+</dd>
+</dl>
+</dd>
+</dl>
+
+
 </dd>
 </dl>
 </details>

vellum/client/resources/__init__.py

@@ -16,6 +16,7 @@ from . import (
     test_suite_runs,
     test_suites,
     workflow_deployments,
+    workflow_executions,
     workflow_sandboxes,
     workflows,
     workspace_secrets,
@@ -50,6 +51,7 @@ __all__ = [
     "test_suite_runs",
     "test_suites",
     "workflow_deployments",
+    "workflow_executions",
     "workflow_sandboxes",
     "workflows",
     "workspace_secrets",

vellum/client/resources/workflow_executions/__init__.py

@@ -0,0 +1,2 @@
+# This file was auto-generated by Fern from our API Definition.
+

vellum/client/resources/workflow_executions/client.py

@@ -0,0 +1,125 @@
+# 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_execution_detail import WorkflowExecutionDetail
+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 WorkflowExecutionsClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    def retrieve_workflow_execution_detail(
+        self, execution_id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> WorkflowExecutionDetail:
+        """
+        Parameters
+        ----------
+        execution_id : str
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        WorkflowExecutionDetail
+
+
+        Examples
+        --------
+        from vellum import Vellum
+
+        client = Vellum(
+            api_version="YOUR_API_VERSION",
+            api_key="YOUR_API_KEY",
+        )
+        client.workflow_executions.retrieve_workflow_execution_detail(
+            execution_id="execution_id",
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/workflow-executions/{jsonable_encoder(execution_id)}/detail",
+            base_url=self._client_wrapper.get_environment().default,
+            method="GET",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    WorkflowExecutionDetail,
+                    parse_obj_as(
+                        type_=WorkflowExecutionDetail,  # 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 AsyncWorkflowExecutionsClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    async def retrieve_workflow_execution_detail(
+        self, execution_id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> WorkflowExecutionDetail:
+        """
+        Parameters
+        ----------
+        execution_id : str
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        WorkflowExecutionDetail
+
+
+        Examples
+        --------
+        import asyncio
+
+        from vellum import AsyncVellum
+
+        client = AsyncVellum(
+            api_version="YOUR_API_VERSION",
+            api_key="YOUR_API_KEY",
+        )
+
+
+        async def main() -> None:
+            await client.workflow_executions.retrieve_workflow_execution_detail(
+                execution_id="execution_id",
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/workflow-executions/{jsonable_encoder(execution_id)}/detail",
+            base_url=self._client_wrapper.get_environment().default,
+            method="GET",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    WorkflowExecutionDetail,
+                    parse_obj_as(
+                        type_=WorkflowExecutionDetail,  # 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/client/types/__init__.py

@@ -280,6 +280,7 @@ from .node_output_compiled_json_value import NodeOutputCompiledJsonValue
 from .node_output_compiled_number_value import NodeOutputCompiledNumberValue
 from .node_output_compiled_search_results_value import NodeOutputCompiledSearchResultsValue
 from .node_output_compiled_string_value import NodeOutputCompiledStringValue
+from .node_output_compiled_thinking_value import NodeOutputCompiledThinkingValue
 from .node_output_compiled_value import NodeOutputCompiledValue
 from .node_parent_context import NodeParentContext
 from .normalized_log_probs import NormalizedLogProbs
@@ -565,6 +566,7 @@ from .workflow_execution_actual import WorkflowExecutionActual
 from .workflow_execution_actual_chat_history_request import WorkflowExecutionActualChatHistoryRequest
 from .workflow_execution_actual_json_request import WorkflowExecutionActualJsonRequest
 from .workflow_execution_actual_string_request import WorkflowExecutionActualStringRequest
+from .workflow_execution_detail import WorkflowExecutionDetail
 from .workflow_execution_event_error_code import WorkflowExecutionEventErrorCode
 from .workflow_execution_event_type import WorkflowExecutionEventType
 from .workflow_execution_fulfilled_body import WorkflowExecutionFulfilledBody
@@ -900,6 +902,7 @@ __all__ = [
     "NodeOutputCompiledNumberValue",
     "NodeOutputCompiledSearchResultsValue",
     "NodeOutputCompiledStringValue",
+    "NodeOutputCompiledThinkingValue",
     "NodeOutputCompiledValue",
     "NodeParentContext",
     "NormalizedLogProbs",
@@ -1169,6 +1172,7 @@ __all__ = [
     "WorkflowExecutionActualChatHistoryRequest",
     "WorkflowExecutionActualJsonRequest",
     "WorkflowExecutionActualStringRequest",
+    "WorkflowExecutionDetail",
     "WorkflowExecutionEventErrorCode",
     "WorkflowExecutionEventType",
     "WorkflowExecutionFulfilledBody",

vellum/client/types/node_output_compiled_thinking_value.py

@@ -0,0 +1,28 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+from .string_vellum_value import StringVellumValue
+from .workflow_node_result_event_state import WorkflowNodeResultEventState
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
+
+
+class NodeOutputCompiledThinkingValue(UniversalBaseModel):
+    """
+    An output returned by a node that is of type THINKING.
+    """
+
+    type: typing.Literal["THINKING"] = "THINKING"
+    value: typing.Optional[StringVellumValue] = None
+    node_output_id: str
+    state: typing.Optional[WorkflowNodeResultEventState] = None
+
+    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/client/types/node_output_compiled_value.py

@@ -9,6 +9,7 @@ from .node_output_compiled_search_results_value import NodeOutputCompiledSearchR
 from .node_output_compiled_error_value import NodeOutputCompiledErrorValue
 from .node_output_compiled_array_value import NodeOutputCompiledArrayValue
 from .node_output_compiled_function_call_value import NodeOutputCompiledFunctionCallValue
+from .node_output_compiled_thinking_value import NodeOutputCompiledThinkingValue
 
 NodeOutputCompiledValue = typing.Union[
     NodeOutputCompiledStringValue,
@@ -19,4 +20,5 @@ NodeOutputCompiledValue = typing.Union[
     NodeOutputCompiledErrorValue,
     NodeOutputCompiledArrayValue,
     NodeOutputCompiledFunctionCallValue,
+    NodeOutputCompiledThinkingValue,
 ]

vellum/client/types/organization_limit_config.py

@@ -13,6 +13,7 @@ class OrganizationLimitConfig(UniversalBaseModel):
     prompt_executions_quota: typing.Optional[Quota] = None
     workflow_executions_quota: typing.Optional[Quota] = None
     workflow_runtime_seconds_quota: typing.Optional[Quota] = None
+    max_workflow_runtime_seconds: typing.Optional[int] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

vellum/client/types/workflow_execution_detail.py

@@ -0,0 +1,42 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+from .api_request_parent_context import ApiRequestParentContext
+from .node_parent_context import NodeParentContext
+from .prompt_deployment_parent_context import PromptDeploymentParentContext
+from .span_link import SpanLink
+from .workflow_deployment_parent_context import WorkflowDeploymentParentContext
+from .workflow_parent_context import WorkflowParentContext
+from .workflow_sandbox_parent_context import WorkflowSandboxParentContext
+from .array_vellum_value import ArrayVellumValue
+import typing
+from .parent_context import ParentContext
+import datetime as dt
+from .execution_vellum_value import ExecutionVellumValue
+from .workflow_error import WorkflowError
+from .workflow_execution_usage_result import WorkflowExecutionUsageResult
+from .vellum_span import VellumSpan
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
+
+
+class WorkflowExecutionDetail(UniversalBaseModel):
+    span_id: str
+    parent_context: typing.Optional[ParentContext] = None
+    start: dt.datetime
+    end: typing.Optional[dt.datetime] = None
+    inputs: typing.List[ExecutionVellumValue]
+    outputs: typing.List[ExecutionVellumValue]
+    error: typing.Optional[WorkflowError] = None
+    usage_results: typing.Optional[typing.List[WorkflowExecutionUsageResult]] = None
+    spans: typing.List[VellumSpan]
+    state: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = None
+
+    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/prompts/blocks/compilation.py

@@ -105,7 +105,11 @@ def compile_prompt_blocks(
                         cache_config=block.cache_config,
                     )
                 )
-            elif compiled_input == "JSON":
+            elif compiled_input.type == "JSON":
+                # Skip empty JSON arrays when there are chat message blocks present
+                if compiled_input.value == [] and any(block.block_type == "CHAT_MESSAGE" for block in compiled_blocks):
+                    continue
+
                 compiled_blocks.append(
                     CompiledValuePromptBlock(
                         content=JsonVellumValue(value=compiled_input.value),

vellum/prompts/blocks/tests/test_compilation.py

@@ -10,7 +10,10 @@ from vellum import (
     VariablePromptBlock,
     VellumVariable,
 )
+from vellum.client.types.json_vellum_value import JsonVellumValue
 from vellum.client.types.number_input import NumberInput
+from vellum.client.types.prompt_block import PromptBlock
+from vellum.client.types.prompt_request_json_input import PromptRequestJsonInput
 from vellum.prompts.blocks.compilation import compile_prompt_blocks
 from vellum.prompts.blocks.types import CompiledChatMessagePromptBlock, CompiledValuePromptBlock
 
@@ -146,3 +149,64 @@ def test_compile_prompt_blocks__happy(blocks, inputs, input_variables, expected)
     actual = compile_prompt_blocks(blocks=blocks, inputs=inputs, input_variables=input_variables)
 
     assert actual == expected
+
+
+def test_compile_prompt_blocks__empty_json_variable_with_chat_message_blocks():
+    """Test JSON variable handling logic, specifically the empty array skipping behavior."""
+
+    # GIVEN empty array with chat message blocks
+    blocks_with_chat: list[PromptBlock] = [
+        ChatMessagePromptBlock(
+            chat_role="USER",
+            blocks=[RichTextPromptBlock(blocks=[PlainTextPromptBlock(text="User message")])],
+        ),
+        VariablePromptBlock(input_variable="json_data"),
+    ]
+
+    inputs_with_empty_json = [PromptRequestJsonInput(key="json_data", value=[], type="JSON")]
+
+    input_variables = [VellumVariable(id="901ec2d6-430c-4341-b963-ca689006f5cc", type="JSON", key="json_data")]
+
+    # THEN the empty JSON array should be skipped when there are chat message blocks
+    expected_with_chat = [
+        CompiledChatMessagePromptBlock(
+            role="USER",
+            blocks=[CompiledValuePromptBlock(content=StringVellumValue(value="User message"))],
+        ),
+    ]
+
+    actual = compile_prompt_blocks(
+        blocks=blocks_with_chat, inputs=inputs_with_empty_json, input_variables=input_variables
+    )
+    assert actual == expected_with_chat
+
+
+def test_compile_prompt_blocks__non_empty_json_variable_with_chat_message_blocks():
+    """Test that non-empty JSON variables are included even when there are chat message blocks."""
+
+    # GIVEN non-empty JSON with chat message blocks
+    blocks_with_chat: list[PromptBlock] = [
+        ChatMessagePromptBlock(
+            chat_role="USER",
+            blocks=[RichTextPromptBlock(blocks=[PlainTextPromptBlock(text="User message")])],
+        ),
+        VariablePromptBlock(input_variable="json_data"),
+    ]
+
+    inputs_with_non_empty_json = [PromptRequestJsonInput(key="json_data", value={"key": "value"}, type="JSON")]
+
+    input_variables = [VellumVariable(id="901ec2d6-430c-4341-b963-ca689006f5cc", type="JSON", key="json_data")]
+
+    # THEN the non-empty JSON should be included
+    expected_with_non_empty = [
+        CompiledChatMessagePromptBlock(
+            role="USER",
+            blocks=[CompiledValuePromptBlock(content=StringVellumValue(value="User message"))],
+        ),
+        CompiledValuePromptBlock(content=JsonVellumValue(value={"key": "value"})),
+    ]
+
+    actual = compile_prompt_blocks(
+        blocks=blocks_with_chat, inputs=inputs_with_non_empty_json, input_variables=input_variables
+    )
+    assert actual == expected_with_non_empty

vellum/resources/workflow_executions/__init__.py

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

vellum/resources/workflow_executions/client.py

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

vellum/types/node_output_compiled_thinking_value.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.node_output_compiled_thinking_value import *

vellum/types/workflow_execution_detail.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.workflow_execution_detail import *

vellum/workflows/descriptors/base.py

@@ -6,6 +6,7 @@ if TYPE_CHECKING:
     from vellum.workflows.expressions.begins_with import BeginsWithExpression
     from vellum.workflows.expressions.between import BetweenExpression
     from vellum.workflows.expressions.coalesce_expression import CoalesceExpression
+    from vellum.workflows.expressions.concat import ConcatExpression
     from vellum.workflows.expressions.contains import ContainsExpression
     from vellum.workflows.expressions.does_not_begin_with import DoesNotBeginWithExpression
     from vellum.workflows.expressions.does_not_contain import DoesNotContainExpression
@@ -364,3 +365,14 @@ class BaseDescriptor(Generic[_T]):
         from vellum.workflows.expressions.is_error import IsErrorExpression
 
         return IsErrorExpression(expression=self)
+
+    @overload
+    def concat(self, other: "BaseDescriptor[_O]") -> "ConcatExpression[_T, _O]": ...
+
+    @overload
+    def concat(self, other: _O) -> "ConcatExpression[_T, _O]": ...
+
+    def concat(self, other: "Union[BaseDescriptor[_O], _O]") -> "ConcatExpression[_T, _O]":
+        from vellum.workflows.expressions.concat import ConcatExpression
+
+        return ConcatExpression(lhs=self, rhs=other)

vellum/workflows/expressions/concat.py

@@ -0,0 +1,32 @@
+from typing import Generic, TypeVar, Union
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+LHS = TypeVar("LHS")
+RHS = TypeVar("RHS")
+
+
+class ConcatExpression(BaseDescriptor[list], Generic[LHS, RHS]):
+    def __init__(
+        self,
+        *,
+        lhs: Union[BaseDescriptor[LHS], LHS],
+        rhs: Union[BaseDescriptor[RHS], RHS],
+    ) -> None:
+        super().__init__(name=f"{lhs} + {rhs}", types=(list,))
+        self._lhs = lhs
+        self._rhs = rhs
+
+    def resolve(self, state: "BaseState") -> list:
+        lval = resolve_value(self._lhs, state)
+        rval = resolve_value(self._rhs, state)
+
+        if not isinstance(lval, list):
+            raise InvalidExpressionException(f"Expected LHS to be a list, got {type(lval)}")
+        if not isinstance(rval, list):
+            raise InvalidExpressionException(f"Expected RHS to be a list, got {type(rval)}")
+
+        return lval + rval

vellum/workflows/expressions/tests/test_concat.py

@@ -0,0 +1,53 @@
+import pytest
+
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
+from vellum.workflows.references.constant import ConstantValueReference
+from vellum.workflows.state.base import BaseState
+
+
+class TestState(BaseState):
+    pass
+
+
+def test_concat_expression_happy_path():
+    # GIVEN two lists
+    state = TestState()
+    lhs_ref = ConstantValueReference([1, 2, 3])
+    rhs_ref = ConstantValueReference([4, 5, 6])
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we resolve the expression
+    result = concat_expr.resolve(state)
+
+    # THEN the lists should be concatenated
+    assert result == [1, 2, 3, 4, 5, 6]
+
+
+def test_concat_expression_lhs_fail():
+    # GIVEN a non-list lhs and a list rhs
+    state = TestState()
+    lhs_ref = ConstantValueReference(0)
+    rhs_ref = ConstantValueReference([4, 5, 6])
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we attempt to resolve the expression
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        concat_expr.resolve(state)
+
+    # THEN an exception should be raised
+    assert "Expected LHS to be a list, got <class 'int'>" in str(exc_info.value)
+
+
+def test_concat_expression_rhs_fail():
+    # GIVEN a list lhs and a non-list rhs
+    state = TestState()
+    lhs_ref = ConstantValueReference([1, 2, 3])
+    rhs_ref = ConstantValueReference(False)
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we attempt to resolve the expression
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        concat_expr.resolve(state)
+
+    # THEN an exception should be raised
+    assert "Expected RHS to be a list, got <class 'bool'>" in str(exc_info.value)

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

@@ -64,8 +64,7 @@ class InlinePromptNode(BaseInlinePromptNode[StateType]):
             elif output.type == "FUNCTION_CALL":
                 string_outputs.append(output.value.model_dump_json(indent=4))
             elif output.type == "THINKING":
-                if output.value.type == "STRING":
-                    string_outputs.append(output.value.value)
+                continue
             else:
                 string_outputs.append(output.value.message)