vellum-ai 1.7.6__tar.gz → 1.7.8__tar.gz

{vellum_ai-1.7.6 → vellum_ai-1.7.8}/PKG-INFO

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

{vellum_ai-1.7.6 → vellum_ai-1.7.8}/ee/vellum_ee/workflows/display/base.py

@@ -16,6 +16,7 @@ if TYPE_CHECKING:
 
 class WorkflowTriggerType(Enum):
     MANUAL = "MANUAL"
+    SLACK_MESSAGE = "SLACK_MESSAGE"
 
 
 def get_trigger_type_mapping() -> Dict[Type["BaseTrigger"], WorkflowTriggerType]:
@@ -29,9 +30,11 @@ def get_trigger_type_mapping() -> Dict[Type["BaseTrigger"], WorkflowTriggerType]
         Dictionary mapping trigger classes to their enum types
     """
     from vellum.workflows.triggers.manual import ManualTrigger
+    from vellum.workflows.triggers.slack import SlackTrigger
 
     return {
         ManualTrigger: WorkflowTriggerType.MANUAL,
+        SlackTrigger: WorkflowTriggerType.SLACK_MESSAGE,
     }
 
 

{vellum_ai-1.7.6 → vellum_ai-1.7.8}/ee/vellum_ee/workflows/display/nodes/base_node_display.py

@@ -188,7 +188,7 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
             type = primitive_type_to_vellum_variable_type(output)
             value = (
                 serialize_value(node_id, display_context, output.instance)
-                if output.instance is not None and output.instance != undefined
+                if output.instance is not None and output.instance is not undefined
                 else None
             )
 

{vellum_ai-1.7.6 → vellum_ai-1.7.8}/ee/vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_attributes_serialization.py

@@ -688,3 +688,19 @@ def test_serialize_node__comment_expanded_preserved_when_explicitly_set(serializ
     assert "comment" in display_data
     assert display_data["comment"]["value"] == "This is a test comment."
     assert display_data["comment"]["expanded"] is False
+
+
+def test_serialize_node__attribute_with_type_annotation_no_default(serialize_node):
+    """
+    Tests that attributes with type annotations but no default values serialize as None.
+    """
+
+    # GIVEN a node with typed attributes but no default values
+    class NodeWithTypedAttributesNoDefault(BaseNode):
+        attr: str
+
+    # WHEN the node is serialized
+    serialized_node = serialize_node(NodeWithTypedAttributesNoDefault)
+
+    # THEN the attribute should serialize as None
+    assert serialized_node["attributes"][0]["value"] is None

vellum_ai-1.7.8/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_slack_trigger_serialization.py

@@ -0,0 +1,167 @@
+"""Tests for serialization of workflows with SlackTrigger."""
+
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.state.base import BaseState
+from vellum.workflows.triggers.slack import SlackTrigger
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+class Inputs(BaseInputs):
+    input: str
+
+
+class SimpleNode(BaseNode):
+    class Outputs(BaseNode.Outputs):
+        output = Inputs.input
+
+
+def test_slack_trigger_serialization() -> None:
+    """Workflow with SlackTrigger serializes with triggers field."""
+
+    class TestWorkflow(BaseWorkflow[Inputs, BaseState]):
+        graph = SlackTrigger >> SimpleNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            output = SimpleNode.Outputs.output
+
+    result = get_workflow_display(workflow_class=TestWorkflow).serialize()
+
+    # Validate triggers structure
+    assert "triggers" in result
+    triggers = result["triggers"]
+    assert isinstance(triggers, list)
+    assert len(triggers) == 1
+
+    trigger = triggers[0]
+    assert isinstance(trigger, dict)
+    assert trigger["type"] == "SLACK_MESSAGE"
+    assert "id" in trigger
+
+    # Validate attributes
+    assert "attributes" in trigger
+    attributes = trigger["attributes"]
+    assert isinstance(attributes, list)
+    assert len(attributes) == 6
+
+    attribute_names = set()
+    for attribute in attributes:
+        assert isinstance(attribute, dict)
+        assert "name" in attribute
+        assert isinstance(attribute["name"], str)
+        attribute_names.add(attribute["name"])
+    assert attribute_names == {
+        "message",
+        "channel",
+        "user",
+        "timestamp",
+        "thread_ts",
+        "event_type",
+    }
+
+    for attribute in attributes:
+        assert isinstance(attribute, dict)
+        assert attribute["value"] is None
+        assert isinstance(attribute["id"], str)
+        assert attribute["id"]
+
+
+def test_slack_trigger_multiple_entrypoints() -> None:
+    """SlackTrigger with multiple entrypoints."""
+
+    class NodeA(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            output = Inputs.input
+
+    class NodeB(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            output = Inputs.input
+
+    class MultiWorkflow(BaseWorkflow[Inputs, BaseState]):
+        graph = SlackTrigger >> {NodeA, NodeB}
+
+        class Outputs(BaseWorkflow.Outputs):
+            output_a = NodeA.Outputs.output
+            output_b = NodeB.Outputs.output
+
+    result = get_workflow_display(workflow_class=MultiWorkflow).serialize()
+
+    # Validate triggers
+    assert "triggers" in result
+    triggers = result["triggers"]
+    assert isinstance(triggers, list)
+    assert len(triggers) == 1
+
+    trigger = triggers[0]
+    assert isinstance(trigger, dict)
+    assert trigger["type"] == "SLACK_MESSAGE"
+
+    # Validate attributes
+    assert "attributes" in trigger
+    attributes = trigger["attributes"]
+    assert isinstance(attributes, list)
+    attribute_names = set()
+    for attribute in attributes:
+        assert isinstance(attribute, dict)
+        assert "name" in attribute
+        assert isinstance(attribute["name"], str)
+        attribute_names.add(attribute["name"])
+
+    assert attribute_names == {
+        "message",
+        "channel",
+        "user",
+        "timestamp",
+        "thread_ts",
+        "event_type",
+    }
+
+    # Validate nodes
+    assert "workflow_raw_data" in result
+    workflow_data = result["workflow_raw_data"]
+    assert isinstance(workflow_data, dict)
+    assert "nodes" in workflow_data
+    nodes = workflow_data["nodes"]
+    assert isinstance(nodes, list)
+
+    generic_nodes = [node for node in nodes if isinstance(node, dict) and node.get("type") == "GENERIC"]
+    assert len(generic_nodes) >= 2
+
+
+def test_serialized_slack_workflow_structure() -> None:
+    """Verify complete structure of serialized workflow with SlackTrigger."""
+
+    class TestWorkflow(BaseWorkflow[Inputs, BaseState]):
+        graph = SlackTrigger >> SimpleNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            output = SimpleNode.Outputs.output
+
+    result = get_workflow_display(workflow_class=TestWorkflow).serialize()
+
+    # Validate top-level structure
+    assert isinstance(result, dict)
+    assert set(result.keys()) == {
+        "workflow_raw_data",
+        "input_variables",
+        "state_variables",
+        "output_variables",
+        "triggers",
+    }
+
+    # Validate workflow_raw_data structure
+    workflow_raw_data = result["workflow_raw_data"]
+    assert isinstance(workflow_raw_data, dict)
+    assert set(workflow_raw_data.keys()) == {
+        "nodes",
+        "edges",
+        "display_data",
+        "definition",
+        "output_values",
+    }
+
+    # Validate definition
+    definition = workflow_raw_data["definition"]
+    assert isinstance(definition, dict)
+    assert definition["name"] == "TestWorkflow"

{vellum_ai-1.7.6 → vellum_ai-1.7.8}/ee/vellum_ee/workflows/display/utils/expressions.py

@@ -3,7 +3,7 @@ import inspect
 from io import StringIO
 import sys
 from uuid import UUID
-from typing import TYPE_CHECKING, Any, Dict, List, cast
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
 
 from pydantic import BaseModel
 
@@ -248,13 +248,11 @@ def serialize_key(key: Any) -> str:
         return str(key)
 
 
-# Sentinel value to indicate a value should be omitted from serialization
-_UNDEFINED_SENTINEL: JsonObject = {"__undefined__": True}
-
-
-def serialize_value(executable_id: UUID, display_context: "WorkflowDisplayContext", value: Any) -> JsonObject:
+def serialize_value(executable_id: UUID, display_context: "WorkflowDisplayContext", value: Any) -> Optional[JsonObject]:
     """
-    Serialize a value to a JSON object.
+    Serialize a value to a JSON object. Returns `None` if the value resolves to `undefined`.
+    This is safe because all valid values are a JSON object, including the `None` constant:
+    > `{"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}}`
 
     Args:
         executable_id: node id or workflow id
@@ -265,7 +263,7 @@ def serialize_value(executable_id: UUID, display_context: "WorkflowDisplayContex
         serialized value
     """
     if value is undefined:
-        return _UNDEFINED_SENTINEL
+        return None
 
     if isinstance(value, ConstantValueReference):
         return serialize_value(executable_id, display_context, value._value)
@@ -353,7 +351,7 @@ def serialize_value(executable_id: UUID, display_context: "WorkflowDisplayContex
         serialized_items = []
         for item in value:
             serialized_item = serialize_value(executable_id, display_context, item)
-            if serialized_item != _UNDEFINED_SENTINEL:
+            if serialized_item is not None:
                 serialized_items.append(serialized_item)
 
         if all(isinstance(item, dict) and item["type"] == "CONSTANT_VALUE" for item in serialized_items):
@@ -389,7 +387,7 @@ def serialize_value(executable_id: UUID, display_context: "WorkflowDisplayContex
         serialized_entries: List[Dict[str, Any]] = []
         for key, val in value.items():
             serialized_val = serialize_value(executable_id, display_context, val)
-            if serialized_val != _UNDEFINED_SENTINEL:
+            if serialized_val is not None:
                 serialized_entries.append(
                     {
                         "id": str(uuid4_from_hash(f"{executable_id}|{key}")),
@@ -455,7 +453,9 @@ def serialize_value(executable_id: UUID, display_context: "WorkflowDisplayContex
         if inputs:
             serialized_inputs = {}
             for param_name, input_ref in inputs.items():
-                serialized_inputs[param_name] = serialize_value(executable_id, display_context, input_ref)
+                serialized_input = serialize_value(executable_id, display_context, input_ref)
+                if serialized_input is not None:
+                    serialized_inputs[param_name] = serialized_input
 
             model_data = function_definition.model_dump()
             model_data["inputs"] = serialized_inputs

{vellum_ai-1.7.6 → vellum_ai-1.7.8}/ee/vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -29,6 +29,7 @@ from vellum.workflows.types.core import Json, JsonArray, JsonObject
 from vellum.workflows.types.generics import WorkflowType
 from vellum.workflows.types.utils import get_original_base
 from vellum.workflows.utils.uuids import uuid4_from_hash
+from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_variable_type
 from vellum.workflows.vellum_client import create_vellum_client
 from vellum_ee.workflows.display.base import (
     EdgeDisplay,
@@ -475,17 +476,32 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
         # Return as a list with a single trigger object matching Django schema
         trigger_id = uuid4_from_hash(f"{trigger_class.__module__} | {trigger_class.__qualname__}")
 
-        return cast(
+        # Serialize trigger attributes like node outputs
+        attribute_references = trigger_class.attribute_references().values()
+        trigger_attributes: JsonArray = cast(
             JsonArray,
             [
-                {
-                    "id": str(trigger_id),
-                    "type": trigger_type.value,
-                    "attributes": [],
-                }
+                cast(
+                    JsonObject,
+                    {
+                        "id": str(reference.id),
+                        "name": reference.name,
+                        "type": primitive_type_to_vellum_variable_type(reference),
+                        "value": None,
+                    },
+                )
+                for reference in sorted(attribute_references, key=lambda ref: ref.name)
             ],
         )
 
+        trigger_data: JsonObject = {
+            "id": str(trigger_id),
+            "type": trigger_type.value,
+            "attributes": trigger_attributes,
+        }
+
+        return cast(JsonArray, [trigger_data])
+
     def _serialize_edge_display_data(self, edge_display: EdgeDisplay) -> Optional[JsonObject]:
         """Serialize edge display data, returning None if no display data is present."""
         if edge_display.z_index is not None:

{vellum_ai-1.7.6 → vellum_ai-1.7.8}/pyproject.toml

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

{vellum_ai-1.7.6 → vellum_ai-1.7.8}/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.7.6",
+            "User-Agent": "vellum-ai/1.7.8",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.7.6",
+            "X-Fern-SDK-Version": "1.7.8",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

{vellum_ai-1.7.6 → vellum_ai-1.7.8}/src/vellum/client/reference.md

@@ -4566,6 +4566,22 @@ client.integration_providers.list_integration_tools(
 <dl>
 <dd>
 
+**important:** `typing.Optional[bool]` — Whether to filter the tools by important
+    
+</dd>
+</dl>
+
+<dl>
+<dd>
+
+**include_deprecated:** `typing.Optional[bool]` — Whether to include deprecated tools
+    
+</dd>
+</dl>
+
+<dl>
+<dd>
+
 **integration_name:** `typing.Optional[str]` — The Vellum Integration name
     
 </dd>

{vellum_ai-1.7.6 → vellum_ai-1.7.8}/src/vellum/client/resources/ad_hoc/raw_client.py

@@ -73,7 +73,7 @@ class RawAdHocClient:
         """
         _response = self._client_wrapper.httpx_client.request(
             "v1/ad-hoc/execute-prompt",
-            base_url=self._client_wrapper.get_environment().default,
+            base_url=self._client_wrapper.get_environment().predict,
             method="POST",
             json={
                 "ml_model": ml_model,
@@ -344,7 +344,7 @@ class AsyncRawAdHocClient:
         """
         _response = await self._client_wrapper.httpx_client.request(
             "v1/ad-hoc/execute-prompt",
-            base_url=self._client_wrapper.get_environment().default,
+            base_url=self._client_wrapper.get_environment().predict,
             method="POST",
             json={
                 "ml_model": ml_model,

{vellum_ai-1.7.6 → vellum_ai-1.7.8}/src/vellum/client/resources/integration_providers/client.py

@@ -81,6 +81,8 @@ class IntegrationProvidersClient:
         self,
         integration_provider: str,
         *,
+        important: typing.Optional[bool] = None,
+        include_deprecated: typing.Optional[bool] = None,
         integration_name: typing.Optional[str] = None,
         limit: typing.Optional[int] = None,
         offset: typing.Optional[int] = None,
@@ -95,6 +97,12 @@ class IntegrationProvidersClient:
         integration_provider : str
             The integration provider name
 
+        important : typing.Optional[bool]
+            Whether to filter the tools by important
+
+        include_deprecated : typing.Optional[bool]
+            Whether to include deprecated tools
+
         integration_name : typing.Optional[str]
             The Vellum Integration name
 
@@ -129,6 +137,8 @@ class IntegrationProvidersClient:
         """
         _response = self._raw_client.list_integration_tools(
             integration_provider,
+            important=important,
+            include_deprecated=include_deprecated,
             integration_name=integration_name,
             limit=limit,
             offset=offset,
@@ -214,6 +224,8 @@ class AsyncIntegrationProvidersClient:
         self,
         integration_provider: str,
         *,
+        important: typing.Optional[bool] = None,
+        include_deprecated: typing.Optional[bool] = None,
         integration_name: typing.Optional[str] = None,
         limit: typing.Optional[int] = None,
         offset: typing.Optional[int] = None,
@@ -228,6 +240,12 @@ class AsyncIntegrationProvidersClient:
         integration_provider : str
             The integration provider name
 
+        important : typing.Optional[bool]
+            Whether to filter the tools by important
+
+        include_deprecated : typing.Optional[bool]
+            Whether to include deprecated tools
+
         integration_name : typing.Optional[str]
             The Vellum Integration name
 
@@ -270,6 +288,8 @@ class AsyncIntegrationProvidersClient:
         """
         _response = await self._raw_client.list_integration_tools(
             integration_provider,
+            important=important,
+            include_deprecated=include_deprecated,
             integration_name=integration_name,
             limit=limit,
             offset=offset,

{vellum_ai-1.7.6 → vellum_ai-1.7.8}/src/vellum/client/resources/integration_providers/raw_client.py

@@ -72,6 +72,8 @@ class RawIntegrationProvidersClient:
         self,
         integration_provider: str,
         *,
+        important: typing.Optional[bool] = None,
+        include_deprecated: typing.Optional[bool] = None,
         integration_name: typing.Optional[str] = None,
         limit: typing.Optional[int] = None,
         offset: typing.Optional[int] = None,
@@ -86,6 +88,12 @@ class RawIntegrationProvidersClient:
         integration_provider : str
             The integration provider name
 
+        important : typing.Optional[bool]
+            Whether to filter the tools by important
+
+        include_deprecated : typing.Optional[bool]
+            Whether to include deprecated tools
+
         integration_name : typing.Optional[str]
             The Vellum Integration name
 
@@ -111,6 +119,8 @@ class RawIntegrationProvidersClient:
             base_url=self._client_wrapper.get_environment().default,
             method="GET",
             params={
+                "important": important,
+                "include_deprecated": include_deprecated,
                 "integration_name": integration_name,
                 "limit": limit,
                 "offset": offset,
@@ -193,6 +203,8 @@ class AsyncRawIntegrationProvidersClient:
         self,
         integration_provider: str,
         *,
+        important: typing.Optional[bool] = None,
+        include_deprecated: typing.Optional[bool] = None,
         integration_name: typing.Optional[str] = None,
         limit: typing.Optional[int] = None,
         offset: typing.Optional[int] = None,
@@ -207,6 +219,12 @@ class AsyncRawIntegrationProvidersClient:
         integration_provider : str
             The integration provider name
 
+        important : typing.Optional[bool]
+            Whether to filter the tools by important
+
+        include_deprecated : typing.Optional[bool]
+            Whether to include deprecated tools
+
         integration_name : typing.Optional[str]
             The Vellum Integration name
 
@@ -232,6 +250,8 @@ class AsyncRawIntegrationProvidersClient:
             base_url=self._client_wrapper.get_environment().default,
             method="GET",
             params={
+                "important": important,
+                "include_deprecated": include_deprecated,
                 "integration_name": integration_name,
                 "limit": limit,
                 "offset": offset,

{vellum_ai-1.7.6 → vellum_ai-1.7.8}/src/vellum/client/types/integration_name.py

@@ -15,6 +15,7 @@ IntegrationName = typing.Union[
         "GOOGLE_CALENDAR",
         "GOOGLE_DRIVE",
         "GMAIL",
+        "AIRTABLE",
     ],
     typing.Any,
 ]

{vellum_ai-1.7.6 → vellum_ai-1.7.8}/src/vellum/client/types/workflow_execution_fulfilled_body.py

@@ -10,6 +10,7 @@ from .vellum_code_resource_definition import VellumCodeResourceDefinition
 class WorkflowExecutionFulfilledBody(UniversalBaseModel):
     workflow_definition: VellumCodeResourceDefinition
     outputs: typing.Dict[str, typing.Optional[typing.Any]]
+    final_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

{vellum_ai-1.7.6 → vellum_ai-1.7.8}/src/vellum/workflows/nodes/bases/base_adornment_node.py

@@ -1,10 +1,12 @@
 from abc import ABC
-from typing import TYPE_CHECKING, Any, Dict, Generic, Optional, Tuple, Type
+from uuid import UUID
+from typing import TYPE_CHECKING, Any, Dict, Generic, Optional, Set, Tuple, Type
 
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode, BaseNodeMeta
 from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.references.output import OutputReference
+from vellum.workflows.types.core import MergeBehavior
 from vellum.workflows.types.generics import StateType
 
 if TYPE_CHECKING:
@@ -79,6 +81,56 @@ class BaseAdornmentNode(
     __wrapped_node__: Optional[Type["BaseNode"]] = None
     subworkflow: Type["BaseWorkflow"]
 
+    class Trigger(BaseNode.Trigger):
+        """
+        Trigger class for adornment nodes that delegates to the wrapped node's Trigger
+        for proper merge behavior handling.
+        """
+
+        @classmethod
+        def should_initiate(
+            cls,
+            state: StateType,
+            dependencies: Set["Type[BaseNode]"],
+            node_span_id: UUID,
+        ) -> bool:
+            """
+            Delegates to the wrapped node's Trigger.should_initiate method to ensure
+            proper merge behavior (like AWAIT_ALL) is respected for initiation logic.
+            """
+            # Get the wrapped node's Trigger class
+            wrapped_node = cls.node_class.__wrapped_node__
+            if wrapped_node is not None:
+                wrapped_trigger = wrapped_node.Trigger
+                # Only delegate if the wrapped node has a specific merge behavior
+                # that differs from the default AWAIT_ATTRIBUTES
+                if (
+                    hasattr(wrapped_trigger, "merge_behavior")
+                    and wrapped_trigger.merge_behavior != MergeBehavior.AWAIT_ATTRIBUTES
+                ):
+                    return wrapped_trigger.should_initiate(state, dependencies, node_span_id)
+
+            # Fallback to the base implementation if no wrapped node
+            return super().should_initiate(state, dependencies, node_span_id)
+
+        @classmethod
+        def _queue_node_execution(
+            cls, state: StateType, dependencies: set[Type[BaseNode]], invoked_by: Optional[UUID] = None
+        ) -> UUID:
+            """
+            Delegates to the wrapped node's Trigger._queue_node_execution method to ensure
+            proper merge behavior (like AWAIT_ALL) is respected for dependency tracking.
+            """
+            # Get the wrapped node's Trigger class
+            wrapped_node = cls.node_class.__wrapped_node__
+            if wrapped_node is not None:
+                wrapped_trigger = wrapped_node.Trigger
+                # Delegate to the wrapped node's trigger logic for queuing
+                return wrapped_trigger._queue_node_execution(state, dependencies, invoked_by)
+
+            # Fallback to the base implementation if no wrapped node
+            return super()._queue_node_execution(state, dependencies, invoked_by)
+
     @classmethod
     def __annotate_outputs_class__(cls, outputs_class: Type[BaseOutputs], reference: OutputReference) -> None:
         # Subclasses of BaseAdornableNode can override this method to provider their own

{vellum_ai-1.7.6 → vellum_ai-1.7.8}/src/vellum/workflows/nodes/core/map_node/node.py

@@ -17,6 +17,7 @@ from typing import (
     overload,
 )
 
+from vellum.workflows.constants import undefined
 from vellum.workflows.context import ExecutionContext, execution_context, get_execution_context
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.errors.types import WorkflowErrorCode
@@ -218,6 +219,15 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
         #     value: List[str]
         outputs_class.__annotations__ = {**previous_annotations, reference.name: annotation}
 
+        # Create a NEW OutputReference with the List-wrapped type for discoverability during iteration
+        map_output_reference = OutputReference(
+            name=reference.name,
+            types=(annotation,),
+            instance=undefined,
+            outputs_class=outputs_class,
+        )
+        setattr(outputs_class, reference.name, map_output_reference)
+
         subworkflow_class = cls.subworkflow.instance if isinstance(cls.subworkflow, NodeReference) else None
         if subworkflow_class:
             output_id = subworkflow_class.__output_ids__.get(reference.name) or uuid4_from_hash(