vellum-ai 0.14.49__py3-none-any.whl → 0.14.51__py3-none-any.whl

vellum/__init__.py

@@ -544,7 +544,9 @@ from .types import (
     WorkflowExecutionSpanAttributes,
     WorkflowExecutionStreamingBody,
     WorkflowExecutionStreamingEvent,
-    WorkflowExecutionUsageCalculationFulfilledBody,
+    WorkflowExecutionUsageCalculationError,
+    WorkflowExecutionUsageCalculationErrorCodeEnum,
+    WorkflowExecutionUsageResult,
     WorkflowExecutionViewOnlineEvalMetricResult,
     WorkflowExecutionWorkflowResultEvent,
     WorkflowExpandMetaRequest,
@@ -1177,7 +1179,9 @@ __all__ = [
     "WorkflowExecutionSpanAttributes",
     "WorkflowExecutionStreamingBody",
     "WorkflowExecutionStreamingEvent",
-    "WorkflowExecutionUsageCalculationFulfilledBody",
+    "WorkflowExecutionUsageCalculationError",
+    "WorkflowExecutionUsageCalculationErrorCodeEnum",
+    "WorkflowExecutionUsageResult",
     "WorkflowExecutionViewOnlineEvalMetricResult",
     "WorkflowExecutionWorkflowResultEvent",
     "WorkflowExpandMetaRequest",

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.49",
+            "X-Fern-SDK-Version": "0.14.51",
         }
         headers["X-API-KEY"] = self.api_key
         return headers

vellum/client/types/__init__.py

@@ -568,7 +568,9 @@ from .workflow_execution_span import WorkflowExecutionSpan
 from .workflow_execution_span_attributes import WorkflowExecutionSpanAttributes
 from .workflow_execution_streaming_body import WorkflowExecutionStreamingBody
 from .workflow_execution_streaming_event import WorkflowExecutionStreamingEvent
-from .workflow_execution_usage_calculation_fulfilled_body import WorkflowExecutionUsageCalculationFulfilledBody
+from .workflow_execution_usage_calculation_error import WorkflowExecutionUsageCalculationError
+from .workflow_execution_usage_calculation_error_code_enum import WorkflowExecutionUsageCalculationErrorCodeEnum
+from .workflow_execution_usage_result import WorkflowExecutionUsageResult
 from .workflow_execution_view_online_eval_metric_result import WorkflowExecutionViewOnlineEvalMetricResult
 from .workflow_execution_workflow_result_event import WorkflowExecutionWorkflowResultEvent
 from .workflow_expand_meta_request import WorkflowExpandMetaRequest
@@ -1154,7 +1156,9 @@ __all__ = [
     "WorkflowExecutionSpanAttributes",
     "WorkflowExecutionStreamingBody",
     "WorkflowExecutionStreamingEvent",
-    "WorkflowExecutionUsageCalculationFulfilledBody",
+    "WorkflowExecutionUsageCalculationError",
+    "WorkflowExecutionUsageCalculationErrorCodeEnum",
+    "WorkflowExecutionUsageResult",
     "WorkflowExecutionViewOnlineEvalMetricResult",
     "WorkflowExecutionWorkflowResultEvent",
     "WorkflowExpandMetaRequest",

vellum/client/types/deployment_read.py

@@ -50,7 +50,7 @@ class DeploymentRead(UniversalBaseModel):
 
     active_model_version_ids: typing.Optional[typing.List[str]] = pydantic.Field(default=None)
     """
-    Deprecated. This now always returns a null value.
+    Deprecated. This now always returns an empty array.
     """
 
     last_deployed_history_item_id: str = pydantic.Field()

vellum/client/types/slim_workflow_execution_read.py

@@ -15,7 +15,7 @@ from .execution_vellum_value import ExecutionVellumValue
 from .workflow_error import WorkflowError
 from .workflow_execution_actual import WorkflowExecutionActual
 from .workflow_execution_view_online_eval_metric_result import WorkflowExecutionViewOnlineEvalMetricResult
-from .workflow_execution_usage_calculation_fulfilled_body import WorkflowExecutionUsageCalculationFulfilledBody
+from .workflow_execution_usage_result import WorkflowExecutionUsageResult
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import pydantic
 
@@ -30,7 +30,7 @@ class SlimWorkflowExecutionRead(UniversalBaseModel):
     error: typing.Optional[WorkflowError] = None
     latest_actual: typing.Optional[WorkflowExecutionActual] = None
     metric_results: typing.List[WorkflowExecutionViewOnlineEvalMetricResult]
-    usage_results: typing.List[WorkflowExecutionUsageCalculationFulfilledBody]
+    usage_results: typing.Optional[typing.List[WorkflowExecutionUsageResult]] = 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_event_execution_read.py

@@ -15,7 +15,7 @@ from .execution_vellum_value import ExecutionVellumValue
 from .workflow_error import WorkflowError
 from .workflow_execution_actual import WorkflowExecutionActual
 from .workflow_execution_view_online_eval_metric_result import WorkflowExecutionViewOnlineEvalMetricResult
-from .workflow_execution_usage_calculation_fulfilled_body import WorkflowExecutionUsageCalculationFulfilledBody
+from .workflow_execution_usage_result import WorkflowExecutionUsageResult
 from .vellum_span import VellumSpan
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import pydantic
@@ -31,7 +31,7 @@ class WorkflowEventExecutionRead(UniversalBaseModel):
     error: typing.Optional[WorkflowError] = None
     latest_actual: typing.Optional[WorkflowExecutionActual] = None
     metric_results: typing.List[WorkflowExecutionViewOnlineEvalMetricResult]
-    usage_results: typing.List[WorkflowExecutionUsageCalculationFulfilledBody]
+    usage_results: typing.Optional[typing.List[WorkflowExecutionUsageResult]] = None
     spans: typing.List[VellumSpan]
 
     if IS_PYDANTIC_V2:

vellum/client/types/{workflow_execution_usage_calculation_fulfilled_body.py → workflow_execution_usage_calculation_error.py}

@@ -1,16 +1,15 @@
 # This file was auto-generated by Fern from our API Definition.
 
 from ..core.pydantic_utilities import UniversalBaseModel
-import typing
-from .ml_model_usage_wrapper import MlModelUsageWrapper
-from .price import Price
+from .workflow_execution_usage_calculation_error_code_enum import WorkflowExecutionUsageCalculationErrorCodeEnum
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import typing
 import pydantic
 
 
-class WorkflowExecutionUsageCalculationFulfilledBody(UniversalBaseModel):
-    usage: typing.List[MlModelUsageWrapper]
-    cost: typing.List[Price]
+class WorkflowExecutionUsageCalculationError(UniversalBaseModel):
+    code: WorkflowExecutionUsageCalculationErrorCodeEnum
+    message: str
 
     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_usage_calculation_error_code_enum.py

@@ -0,0 +1,7 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+WorkflowExecutionUsageCalculationErrorCodeEnum = typing.Union[
+    typing.Literal["UNKNOWN", "DEPENDENCIES_FAILED", "NO_USAGE_CALCULATED", "INTERNAL_SERVER_ERROR"], typing.Any
+]

vellum/client/types/workflow_execution_usage_result.py

@@ -0,0 +1,24 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+from .ml_model_usage_wrapper import MlModelUsageWrapper
+from .price import Price
+from .workflow_execution_usage_calculation_error import WorkflowExecutionUsageCalculationError
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
+
+
+class WorkflowExecutionUsageResult(UniversalBaseModel):
+    usage: typing.Optional[typing.List[MlModelUsageWrapper]] = None
+    cost: typing.Optional[typing.List[Price]] = None
+    error: typing.Optional[WorkflowExecutionUsageCalculationError] = 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/types/{workflow_execution_usage_calculation_fulfilled_body.py → workflow_execution_usage_calculation_error.py}

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

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

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

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

@@ -1,7 +1,7 @@
 from collections import defaultdict
+import concurrent.futures
 import logging
 from queue import Empty, Queue
-from threading import Thread
 from typing import (
     TYPE_CHECKING,
     Callable,
@@ -75,95 +75,90 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
             return
 
         self._event_queue: Queue[Tuple[int, WorkflowEvent]] = Queue()
-        self._concurrency_queue: Queue[Thread] = Queue()
-        fulfilled_iterations: List[bool] = []
-        for index, item in enumerate(self.items):
-            fulfilled_iterations.append(False)
+        fulfilled_iterations: List[bool] = [False] * len(self.items)
+
+        max_workers = self.max_concurrency if self.max_concurrency is not None else len(self.items)
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+            futures = []
             current_execution_context = get_execution_context()
-            thread = Thread(
-                target=self._context_run_subworkflow,
-                kwargs={
-                    "item": item,
-                    "index": index,
-                    "current_execution_context": current_execution_context,
-                },
-            )
-            if self.max_concurrency is None:
-                thread.start()
-            else:
-                self._concurrency_queue.put(thread)
-
-        if self.max_concurrency is not None:
-            concurrency_count = 0
-            while concurrency_count < self.max_concurrency:
-                is_empty = self._start_thread()
-                if is_empty:
-                    break
-
-                concurrency_count += 1
-
-        try:
-            while map_node_event := self._event_queue.get():
-                index = map_node_event[0]
-                subworkflow_event = map_node_event[1]
-                self._context._emit_subworkflow_event(subworkflow_event)
-
-                if not is_workflow_event(subworkflow_event):
-                    continue
-
-                if subworkflow_event.workflow_definition != self.subworkflow:
-                    continue
-
-                if subworkflow_event.name == "workflow.execution.initiated":
-                    for output_name in mapped_items.keys():
-                        yield BaseOutput(name=output_name, delta=(None, index, "INITIATED"))
-
-                elif subworkflow_event.name == "workflow.execution.fulfilled":
-                    for output_reference, output_value in subworkflow_event.outputs:
-                        if not isinstance(output_reference, OutputReference):
-                            logger.error(
-                                "Invalid key to map node's subworkflow event outputs",
-                                extra={"output_reference_type": type(output_reference)},
+            for index, item in enumerate(self.items):
+                future = executor.submit(
+                    self._context_run_subworkflow,
+                    item=item,
+                    index=index,
+                    current_execution_context=current_execution_context,
+                )
+                futures.append(future)
+
+            while not all(fulfilled_iterations):
+                try:
+                    map_node_event = self._event_queue.get(block=False)
+                    index = map_node_event[0]
+                    subworkflow_event = map_node_event[1]
+                    self._context._emit_subworkflow_event(subworkflow_event)
+
+                    if not is_workflow_event(subworkflow_event):
+                        continue
+
+                    if subworkflow_event.workflow_definition != self.subworkflow:
+                        continue
+
+                    if subworkflow_event.name == "workflow.execution.initiated":
+                        for output_name in mapped_items.keys():
+                            yield BaseOutput(name=output_name, delta=(None, index, "INITIATED"))
+
+                    elif subworkflow_event.name == "workflow.execution.fulfilled":
+                        for output_reference, output_value in subworkflow_event.outputs:
+                            if not isinstance(output_reference, OutputReference):
+                                logger.error(
+                                    "Invalid key to map node's subworkflow event outputs",
+                                    extra={"output_reference_type": type(output_reference)},
+                                )
+                                continue
+
+                            output_mapped_items = mapped_items[output_reference.name]
+                            if index < 0 or index >= len(output_mapped_items):
+                                logger.error(
+                                    "Invalid map node index",
+                                    extra={"index": index, "output_name": output_reference.name},
+                                )
+                                continue
+
+                            output_mapped_items[index] = output_value
+                            yield BaseOutput(
+                                name=output_reference.name,
+                                delta=(output_value, index, "FULFILLED"),
                             )
-                            continue
 
-                        output_mapped_items = mapped_items[output_reference.name]
-                        if index < 0 or index >= len(output_mapped_items):
-                            logger.error(
-                                "Invalid map node index", extra={"index": index, "output_name": output_reference.name}
-                            )
-                            continue
+                        fulfilled_iterations[index] = True
 
-                        output_mapped_items[index] = output_value
-                        yield BaseOutput(
-                            name=output_reference.name,
-                            delta=(output_value, index, "FULFILLED"),
+                    elif subworkflow_event.name == "workflow.execution.paused":
+                        raise NodeException(
+                            code=WorkflowErrorCode.INVALID_OUTPUTS,
+                            message=f"Subworkflow unexpectedly paused on iteration {index}",
                         )
+                    elif subworkflow_event.name == "workflow.execution.rejected":
+                        raise NodeException(
+                            f"Subworkflow failed on iteration {index} with error: {subworkflow_event.error.message}",
+                            code=subworkflow_event.error.code,
+                        )
+                except Empty:
+                    all_futures_done = all(future.done() for future in futures)
 
-                    fulfilled_iterations[index] = True
-                    if all(fulfilled_iterations):
-                        break
-
-                    if self.max_concurrency is not None:
-                        self._start_thread()
-                elif subworkflow_event.name == "workflow.execution.paused":
-                    raise NodeException(
-                        code=WorkflowErrorCode.INVALID_OUTPUTS,
-                        message=f"Subworkflow unexpectedly paused on iteration {index}",
-                    )
-                elif subworkflow_event.name == "workflow.execution.rejected":
-                    raise NodeException(
-                        f"Subworkflow failed on iteration {index} with error: {subworkflow_event.error.message}",
-                        code=subworkflow_event.error.code,
-                    )
-        except Empty:
-            pass
+                    if all_futures_done:
+                        if not all(fulfilled_iterations):
+                            if self._event_queue.empty():
+                                logger.warning("All threads completed but not all iterations fulfilled")
+                                break
+                        else:
+                            break
 
         for output_name, output_list in mapped_items.items():
             yield BaseOutput(name=output_name, value=output_list)
 
     def _context_run_subworkflow(
-        self, *, item: MapNodeItemType, index: int, current_execution_context: ExecutionContext
+        self, item: MapNodeItemType, index: int, current_execution_context: ExecutionContext
     ) -> None:
         parent_context = current_execution_context.parent_context
         trace_id = current_execution_context.trace_id
@@ -186,14 +181,6 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
         for event in events:
             self._event_queue.put((index, event))
 
-    def _start_thread(self) -> bool:
-        if self._concurrency_queue.empty():
-            return False
-
-        thread = self._concurrency_queue.get()
-        thread.start()
-        return True
-
     @overload
     @classmethod
     def wrap(

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

@@ -1,3 +1,5 @@
+import datetime
+import threading
 import time
 
 from vellum.workflows.inputs.base import BaseInputs
@@ -172,3 +174,50 @@ def test_map_node__nested_map_node():
         ["apple carrot", "apple potato"],
         ["banana carrot", "banana potato"],
     ]
+
+
+def test_map_node_parallel_execution_with_workflow():
+    # TODO: Find a better way to test this such that it represents what a user would see.
+    # https://linear.app/vellum/issue/APO-482/find-a-better-way-to-test-concurrency-with-map-nodes
+    thread_ids = {}
+
+    # GIVEN a series of nodes that simulate work
+    class BaseNode1(BaseNode):
+        item = MapNode.SubworkflowInputs.item
+
+        class Outputs(BaseOutputs):
+            output: str
+            thread_id: int
+
+        def run(self) -> Outputs:
+            current_thread_id = threading.get_ident()
+            thread_ids[self.item] = current_thread_id
+
+            # Simulate work
+            time.sleep(0.01)
+
+            end = time.time()
+            end_str = datetime.datetime.fromtimestamp(end).strftime("%Y-%m-%d %H:%M:%S.%f")
+
+            return self.Outputs(output=end_str, thread_id=current_thread_id)
+
+    # AND a workflow that connects these nodes
+    class TestWorkflow(BaseWorkflow[MapNode.SubworkflowInputs, BaseState]):
+        graph = BaseNode1
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_output = BaseNode1.Outputs.output
+            thread_id = BaseNode1.Outputs.thread_id
+
+    # AND a map node that uses this workflow
+    class TestMapNode(MapNode):
+        items = [1, 2, 3]
+        subworkflow = TestWorkflow
+
+    # WHEN we run the map node
+    node = TestMapNode()
+    list(node.run())
+
+    # AND each item should have run on a different thread
+    thread_ids_list = list(thread_ids.values())
+    assert len(set(thread_ids_list)) == 3

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

@@ -20,7 +20,6 @@ from vellum.client import ApiError, RequestOptions
 from vellum.client.types.chat_message_request import ChatMessageRequest
 from vellum.client.types.prompt_settings import PromptSettings
 from vellum.client.types.rich_text_child_block import RichTextChildBlock
-from vellum.workflows.constants import OMIT
 from vellum.workflows.context import get_execution_context
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.errors.types import vellum_error_to_workflow_error
@@ -56,7 +55,7 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
     functions: Optional[List[Union[FunctionDefinition, Callable]]] = None
 
     parameters: PromptParameters = DEFAULT_PROMPT_PARAMETERS
-    expand_meta: Optional[AdHocExpandMeta] = OMIT
+    expand_meta: Optional[AdHocExpandMeta] = None
 
     settings: Optional[PromptSettings] = None
 

vellum/workflows/nodes/displayable/bases/inline_prompt_node/tests/test_inline_prompt_node.py

@@ -270,7 +270,7 @@ def test_inline_prompt_node__json_output(vellum_adhoc_prompt_client):
     # AND we should have made the expected call to Vellum search
     vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.assert_called_once_with(
         blocks=[],
-        expand_meta=Ellipsis,
+        expand_meta=None,
         functions=None,
         input_values=[],
         input_variables=[],
@@ -350,7 +350,7 @@ def test_inline_prompt_node__streaming_disabled(vellum_adhoc_prompt_client):
     # AND we should have made the expected call to Vellum search
     vellum_adhoc_prompt_client.adhoc_execute_prompt.assert_called_once_with(
         blocks=[],
-        expand_meta=Ellipsis,
+        expand_meta=None,
         functions=None,
         input_values=[],
         input_variables=[],
@@ -444,7 +444,7 @@ def test_inline_prompt_node__json_output_with_streaming_disabled(vellum_adhoc_pr
     # AND we should have made the expected call to Vellum search
     vellum_adhoc_prompt_client.adhoc_execute_prompt.assert_called_once_with(
         blocks=[],
-        expand_meta=Ellipsis,
+        expand_meta=None,
         functions=None,
         input_values=[],
         input_variables=[],

vellum/workflows/nodes/displayable/tests/test_inline_text_prompt_node.py

@@ -74,7 +74,7 @@ def test_inline_text_prompt_node__basic(vellum_adhoc_prompt_client):
     # AND we should have made the expected call to Vellum search
     vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.assert_called_once_with(
         blocks=[],
-        expand_meta=Ellipsis,
+        expand_meta=None,
         functions=None,
         input_values=[],
         input_variables=[],

vellum/workflows/nodes/experimental/__init__.py

@@ -0,0 +1,3 @@
+from .tool_calling_node import ToolCallingNode
+
+__all__ = ["ToolCallingNode"]

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

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

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

@@ -57,12 +57,19 @@ def create_tool_router_node(
     Ports = type("Ports", (), {})
     for function in functions:
         function_name = function.__name__
-        port_condition = LazyReference(
-            lambda: (
-                node.Outputs.results[0]["type"].equals("FUNCTION_CALL")
-                & node.Outputs.results[0]["value"]["name"].equals(function_name)
+
+        # Avoid using lambda to capture function_name
+        # lambda will capture the function_name by reference,
+        # and if the function_name is changed, the port_condition will also change.
+        def create_port_condition(fn_name):
+            return LazyReference(
+                lambda: (
+                    node.Outputs.results[0]["type"].equals("FUNCTION_CALL")
+                    & node.Outputs.results[0]["value"]["name"].equals(fn_name)
+                )
             )
-        )
+
+        port_condition = create_port_condition(function_name)
         port = Port.on_if(port_condition)
         setattr(Ports, function_name, port)
 

vellum/workflows/state/encoder.py

@@ -13,6 +13,7 @@ from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
 from vellum.workflows.ports.port import Port
 from vellum.workflows.state.base import BaseState, NodeExecutionCache
+from vellum.workflows.utils.functions import compile_function_definition
 
 
 class DefaultStateEncoder(JSONEncoder):
@@ -57,6 +58,9 @@ class DefaultStateEncoder(JSONEncoder):
         if isinstance(obj, type):
             return str(obj)
 
+        if callable(obj):
+            return compile_function_definition(obj)
+
         if obj.__class__ in self.encoders:
             return self.encoders[obj.__class__](obj)
 

vellum/workflows/workflows/base.py

@@ -276,6 +276,14 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
         """
         return cls._get_edges_from_subgraphs(cls.get_unused_subgraphs())
 
+    @classmethod
+    def get_all_nodes(cls) -> Iterator[Type[BaseNode]]:
+        """
+        Returns an iterator over all nodes in the Workflow, used or unused.
+        """
+        yield from cls.get_nodes()
+        yield from cls.get_unused_nodes()
+
     @classmethod
     def get_entrypoints(cls) -> Iterable[Type[BaseNode]]:
         return iter({e for g in cls.get_subgraphs() for e in g.entrypoints})

{vellum_ai-0.14.49.dist-info → vellum_ai-0.14.51.dist-info}/METADATA

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