vellum-ai 1.8.2__py3-none-any.whl → 1.8.3__py3-none-any.whl

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

vellum/client/types/integration_name.py

@@ -41,6 +41,7 @@ IntegrationName = typing.Union[
         "JIRA",
         "KLAVIYO",
         "PAGERDUTY",
+        "PARSERA",
         "PEOPLEDATALABS",
         "PERPLEXITY",
         "POSTHOG",

vellum/workflows/expressions/concat.py

@@ -26,7 +26,10 @@ class ConcatExpression(BaseDescriptor[list], Generic[LHS, RHS]):
 
         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
+        # If RHS is a list, concatenate normally
+        if isinstance(rval, list):
+            return lval + rval
+        # If RHS is not a list, append it as a single item
+        else:
+            return lval + [rval]

vellum/workflows/expressions/tests/test_concat.py

@@ -38,16 +38,71 @@ def test_concat_expression_lhs_fail():
     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
+def test_concat_expression_with_single_item():
+    # GIVEN a list and a single item
     state = TestState()
     lhs_ref = ConstantValueReference([1, 2, 3])
-    rhs_ref = ConstantValueReference(False)
+    rhs_ref = ConstantValueReference(4)
     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)
+    # WHEN we resolve the expression
+    result = 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)
+    # THEN the item should be appended to the list
+    assert result == [1, 2, 3, 4]
+
+
+def test_concat_expression_with_string():
+    # GIVEN a list and a string item
+    state = TestState()
+    lhs_ref = ConstantValueReference(["hello", "world"])
+    rhs_ref = ConstantValueReference("!")
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we resolve the expression
+    result = concat_expr.resolve(state)
+
+    # THEN the string should be appended to the list
+    assert result == ["hello", "world", "!"]
+
+
+def test_concat_expression_with_none():
+    # GIVEN a list and None item
+    state = TestState()
+    lhs_ref = ConstantValueReference([1, 2])
+    rhs_ref = ConstantValueReference(None)
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we resolve the expression
+    result = concat_expr.resolve(state)
+
+    # THEN None should be appended to the list
+    assert result == [1, 2, None]
+
+
+def test_concat_expression_with_list_item():
+    # GIVEN a list and another list
+    state = TestState()
+    lhs_ref = ConstantValueReference([1, 2])
+    rhs_ref = ConstantValueReference([3, 4])
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we resolve the expression
+    result = concat_expr.resolve(state)
+
+    # THEN the lists should be concatenated normally
+    assert result == [1, 2, 3, 4]
+
+
+def test_concat_expression_empty_list():
+    # GIVEN an empty list and an item
+    state = TestState()
+    lhs_ref: ConstantValueReference[list] = ConstantValueReference([])
+    rhs_ref = ConstantValueReference("first")
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we resolve the expression
+    result = concat_expr.resolve(state)
+
+    # THEN the item should be appended to the empty list
+    assert result == ["first"]

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

@@ -1,5 +1,6 @@
 from abc import abstractmethod
-from typing import ClassVar, Generator, Generic, Iterator, List, Optional, Union
+from itertools import chain
+from typing import ClassVar, Generator, Generic, Iterator, List, Optional, Union, cast
 
 from vellum import AdHocExecutePromptEvent, ExecutePromptEvent, PromptOutput
 from vellum.client.core import RequestOptions
@@ -60,15 +61,26 @@ class BasePromptNode(BaseNode[StateType], Generic[StateType]):
         except ApiError as e:
             self._handle_api_error(e)
 
-        # We don't use the INITIATED event anyway, so we can just skip it
-        # and use the exception handling to catch other api level errors
         try:
-            next(prompt_event_stream)
+            first_event = next(prompt_event_stream)
         except ApiError as e:
             self._handle_api_error(e)
+        else:
+            if first_event.state == "REJECTED":
+                workflow_error = vellum_error_to_workflow_error(first_event.error)
+                raise NodeException.of(workflow_error)
+            if first_event.state != "INITIATED":
+                prompt_event_stream = cast(
+                    Union[Iterator[AdHocExecutePromptEvent], Iterator[ExecutePromptEvent]],
+                    chain([first_event], prompt_event_stream),
+                )
 
         outputs: Optional[List[PromptOutput]] = None
+        exception: Optional[NodeException] = None
         for event in prompt_event_stream:
+            if exception:
+                continue
+
             if event.state == "INITIATED":
                 continue
             elif event.state == "STREAMING":
@@ -78,7 +90,10 @@ class BasePromptNode(BaseNode[StateType], Generic[StateType]):
                 yield BaseOutput(name="results", value=event.outputs)
             elif event.state == "REJECTED":
                 workflow_error = vellum_error_to_workflow_error(event.error)
-                raise NodeException.of(workflow_error)
+                exception = NodeException.of(workflow_error)
+
+        if exception:
+            raise exception
 
         return outputs
 

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

@@ -1,3 +1,4 @@
+from itertools import chain
 import json
 from uuid import uuid4
 from typing import Callable, ClassVar, Generator, Generic, Iterator, List, Optional, Set, Tuple, Union
@@ -225,13 +226,16 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
         except ApiError as e:
             self._handle_api_error(e)
 
-        if not self.settings or (self.settings and self.settings.stream_enabled):
-            # We don't use the INITIATED event anyway, so we can just skip it
-            # and use the exception handling to catch other api level errors
-            try:
-                next(prompt_event_stream)
-            except ApiError as e:
-                self._handle_api_error(e)
+        try:
+            first_event = next(prompt_event_stream)
+        except ApiError as e:
+            self._handle_api_error(e)
+        else:
+            if first_event.state == "REJECTED":
+                workflow_error = vellum_error_to_workflow_error(first_event.error)
+                raise NodeException.of(workflow_error)
+            if first_event.state != "INITIATED":
+                prompt_event_stream = chain([first_event], prompt_event_stream)
 
         outputs: Optional[List[PromptOutput]] = None
         for event in prompt_event_stream:

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

@@ -25,6 +25,7 @@ from vellum import (
     PromptRequestStringInput,
     PromptRequestVideoInput,
     PromptSettings,
+    RejectedExecutePromptEvent,
     RichTextPromptBlock,
     StringVellumValue,
     VariablePromptBlock,
@@ -32,6 +33,7 @@ from vellum import (
     VellumAudioRequest,
     VellumDocument,
     VellumDocumentRequest,
+    VellumError,
     VellumImage,
     VellumImageRequest,
     VellumVideo,
@@ -896,3 +898,43 @@ def test_inline_prompt_node__json_output_with_markdown_code_blocks(vellum_adhoc_
     json_output = outputs[2]
     assert json_output.name == "json"
     assert json_output.value == expected_json
+
+
+def test_inline_prompt_node__provider_error_from_api(vellum_adhoc_prompt_client):
+    """
+    Tests that InlinePromptNode raises NodeException with PROVIDER_ERROR code when first event is REJECTED.
+    """
+
+    # GIVEN an InlinePromptNode with basic configuration
+    class TestNode(InlinePromptNode):
+        ml_model = "test-model"
+        blocks = []
+        prompt_inputs = {}
+
+    # AND the API returns a REJECTED event as the first event with a provider error
+    provider_error = VellumError(
+        code="PROVIDER_ERROR",
+        message="Provider rate limit exceeded",
+    )
+
+    def generate_prompt_events(*args: Any, **kwargs: Any) -> Iterator[ExecutePromptEvent]:
+        execution_id = str(uuid4())
+        events: List[ExecutePromptEvent] = [
+            RejectedExecutePromptEvent(
+                execution_id=execution_id,
+                error=provider_error,
+            ),
+        ]
+        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 PROVIDER_ERROR 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.PROVIDER_ERROR

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

@@ -1,6 +1,6 @@
 import json
-from uuid import UUID
-from typing import TYPE_CHECKING, Any, ClassVar, Dict, Generic, Iterator, List, Optional, Set, Union, cast
+from uuid import UUID, uuid4
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, Generic, Iterator, List, Optional, Set, Type, Union, cast
 
 from vellum import (
     ChatMessage,
@@ -19,12 +19,13 @@ from vellum.workflows.constants import LATEST_RELEASE_TAG, OMIT, undefined
 from vellum.workflows.context import execution_context, get_execution_context, get_parent_context
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.errors.types import workflow_event_error_to_workflow_error
-from vellum.workflows.events.types import default_serializer
+from vellum.workflows.events.types import WorkflowDeploymentParentContext, default_serializer
 from vellum.workflows.events.workflow import is_workflow_event
 from vellum.workflows.exceptions import NodeException, WorkflowInitializationException
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.outputs.base import BaseOutput
+from vellum.workflows.state.context import WorkflowContext, WorkflowDeploymentMetadata
 from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior
 from vellum.workflows.types.generics import StateType
 from vellum.workflows.workflows.event_filters import all_workflow_event_filter
@@ -155,69 +156,95 @@ class SubworkflowDeploymentNode(BaseNode[StateType], Generic[StateType]):
             filtered_inputs = {k: v for k, v in self.subworkflow_inputs.items() if v is not None}
             return inputs_class(**filtered_inputs)
 
-    def _run_resolved_workflow(self, resolved_workflow: "BaseWorkflow") -> Iterator[BaseOutput]:
+    def _run_resolved_workflow(
+        self,
+        workflow_class: Type["BaseWorkflow"],
+        deployment_metadata: Optional[WorkflowDeploymentMetadata],
+    ) -> Iterator[BaseOutput]:
         """Execute resolved workflow directly (similar to InlineSubworkflowNode)."""
-        with execution_context(parent_context=get_parent_context()):
+        # Construct the parent context hierarchy for the subworkflow
+        parent_context = get_parent_context()
+
+        # If we have deployment metadata, wrap the parent context with WorkflowDeploymentParentContext
+        if deployment_metadata:
+            parent_context = WorkflowDeploymentParentContext(
+                span_id=uuid4(),
+                deployment_id=deployment_metadata.deployment_id,
+                deployment_name=deployment_metadata.deployment_name,
+                deployment_history_item_id=deployment_metadata.deployment_history_item_id,
+                release_tag_id=deployment_metadata.release_tag_id,
+                release_tag_name=deployment_metadata.release_tag_name,
+                workflow_version_id=deployment_metadata.workflow_version_id,
+                external_id=self.external_id if self.external_id is not OMIT else None,
+                metadata=self.metadata if self.metadata is not OMIT else None,
+                parent=parent_context,
+            )
+
+        with execution_context(parent_context=parent_context):
+            # Instantiate the workflow inside the execution context so it captures the correct parent context
+            resolved_workflow = workflow_class(
+                context=WorkflowContext.create_from(self._context), parent_state=self.state
+            )
             subworkflow_stream = resolved_workflow.stream(
                 inputs=self._compile_subworkflow_inputs_for_direct_invocation(resolved_workflow),
                 event_filter=all_workflow_event_filter,
                 node_output_mocks=self._context._get_all_node_output_mocks(),
             )
 
-        try:
-            first_event = next(subworkflow_stream)
-            self._context._emit_subworkflow_event(first_event)
-        except WorkflowInitializationException as e:
-            hashed_module = e.definition.__module__
-            raise NodeException(
-                message=e.message,
-                code=e.code,
-                raw_data={"hashed_module": hashed_module},
-            ) from e
-
-        outputs = None
-        exception = None
-        fulfilled_output_names: Set[str] = set()
+            try:
+                first_event = next(subworkflow_stream)
+                self._context._emit_subworkflow_event(first_event)
+            except WorkflowInitializationException as e:
+                hashed_module = e.definition.__module__
+                raise NodeException(
+                    message=e.message,
+                    code=e.code,
+                    raw_data={"hashed_module": hashed_module},
+                ) from e
+
+            outputs = None
+            exception = None
+            fulfilled_output_names: Set[str] = set()
+
+            for event in subworkflow_stream:
+                self._context._emit_subworkflow_event(event)
+                if exception:
+                    continue
+
+                if not is_workflow_event(event):
+                    continue
+                if event.workflow_definition != resolved_workflow.__class__:
+                    continue
+
+                if event.name == "workflow.execution.streaming":
+                    if event.output.is_fulfilled:
+                        fulfilled_output_names.add(event.output.name)
+                    yield event.output
+                elif event.name == "workflow.execution.fulfilled":
+                    outputs = event.outputs
+                elif event.name == "workflow.execution.rejected":
+                    exception = NodeException.of(event.error)
+                elif event.name == "workflow.execution.paused":
+                    exception = NodeException(
+                        code=WorkflowErrorCode.INVALID_OUTPUTS,
+                        message="Subworkflow unexpectedly paused",
+                    )
 
-        for event in subworkflow_stream:
-            self._context._emit_subworkflow_event(event)
             if exception:
-                continue
+                raise exception
 
-            if not is_workflow_event(event):
-                continue
-            if event.workflow_definition != resolved_workflow.__class__:
-                continue
-
-            if event.name == "workflow.execution.streaming":
-                if event.output.is_fulfilled:
-                    fulfilled_output_names.add(event.output.name)
-                yield event.output
-            elif event.name == "workflow.execution.fulfilled":
-                outputs = event.outputs
-            elif event.name == "workflow.execution.rejected":
-                exception = NodeException.of(event.error)
-            elif event.name == "workflow.execution.paused":
-                exception = NodeException(
+            if outputs is None:
+                raise NodeException(
+                    message="Expected to receive outputs from Workflow Deployment",
                     code=WorkflowErrorCode.INVALID_OUTPUTS,
-                    message="Subworkflow unexpectedly paused",
                 )
 
-        if exception:
-            raise exception
-
-        if outputs is None:
-            raise NodeException(
-                message="Expected to receive outputs from Workflow Deployment",
-                code=WorkflowErrorCode.INVALID_OUTPUTS,
-            )
-
-        for output_descriptor, output_value in outputs:
-            if output_descriptor.name not in fulfilled_output_names:
-                yield BaseOutput(
-                    name=output_descriptor.name,
-                    value=output_value,
-                )
+            for output_descriptor, output_value in outputs:
+                if output_descriptor.name not in fulfilled_output_names:
+                    yield BaseOutput(
+                        name=output_descriptor.name,
+                        value=output_value,
+                    )
 
     def run(self) -> Iterator[BaseOutput]:
         execution_context = get_execution_context()
@@ -248,11 +275,12 @@ class SubworkflowDeploymentNode(BaseNode[StateType], Generic[StateType]):
                 message="Expected deployment name to be provided for subworkflow execution.",
             )
 
-        resolved_workflow = self._context.resolve_workflow_deployment(
+        resolved_result = self._context.resolve_workflow_deployment(
             deployment_name=deployment_name, release_tag=self.release_tag, state=self.state
         )
-        if resolved_workflow:
-            yield from self._run_resolved_workflow(resolved_workflow)
+        if resolved_result:
+            workflow_class, deployment_metadata = resolved_result
+            yield from self._run_resolved_workflow(workflow_class, deployment_metadata)
             return
 
         try:

vellum/workflows/nodes/experimental/__init__.py

@@ -1,3 +1 @@
-from .openai_chat_completion_node import OpenAIChatCompletionNode
-
-__all__ = ["OpenAIChatCompletionNode"]
+__all__: list[str] = []

vellum/workflows/runner/runner.py

@@ -74,6 +74,9 @@ from vellum.workflows.references import ExternalInputReference, OutputReference
 from vellum.workflows.references.state_value import StateValueReference
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.state.delta import StateDelta
+from vellum.workflows.triggers.base import BaseTrigger
+from vellum.workflows.triggers.integration import IntegrationTrigger
+from vellum.workflows.triggers.manual import ManualTrigger
 from vellum.workflows.types.core import CancelSignal
 from vellum.workflows.types.generics import InputsType, OutputsType, StateType
 
@@ -109,6 +112,7 @@ class WorkflowRunner(Generic[StateType]):
         max_concurrency: Optional[int] = None,
         timeout: Optional[float] = None,
         init_execution_context: Optional[ExecutionContext] = None,
+        trigger: Optional[BaseTrigger] = None,
     ):
         if state and external_inputs:
             raise ValueError("Can only run a Workflow providing one of state or external inputs, not both")
@@ -198,7 +202,24 @@ class WorkflowRunner(Generic[StateType]):
                 )
 
             self._entrypoints = self.workflow.get_entrypoints()
+        elif trigger:
+            # When trigger is provided, set up default state and filter entrypoints by trigger type
+            normalized_inputs = deepcopy(inputs) if inputs else self.workflow.get_default_inputs()
+            if state:
+                self._initial_state = deepcopy(state)
+                self._initial_state.meta.workflow_inputs = normalized_inputs
+                self._initial_state.meta.span_id = uuid4()
+                self._initial_state.meta.workflow_definition = self.workflow.__class__
+            else:
+                self._initial_state = self.workflow.get_default_state(normalized_inputs)
+                self._should_emit_initial_state = False
+
+            # Validate and bind trigger, then filter entrypoints
+            self._validate_and_bind_trigger(trigger)
+            self._entrypoints = self.workflow.get_entrypoints()
+            self._filter_entrypoints_for_trigger(trigger)
         else:
+            # Default case: no entrypoint overrides and no trigger
             normalized_inputs = deepcopy(inputs) if inputs else self.workflow.get_default_inputs()
             if state:
                 self._initial_state = deepcopy(state)
@@ -213,6 +234,9 @@ class WorkflowRunner(Generic[StateType]):
                 self._should_emit_initial_state = False
             self._entrypoints = self.workflow.get_entrypoints()
 
+            # Check if workflow requires a trigger but none was provided
+            self._validate_no_trigger_provided()
+
         # This queue is responsible for sending events from WorkflowRunner to the outside world
         self._workflow_event_outer_queue: Queue[WorkflowEvent] = Queue()
 
@@ -250,6 +274,126 @@ class WorkflowRunner(Generic[StateType]):
         self._cancel_thread: Optional[Thread] = None
         self._timeout_thread: Optional[Thread] = None
 
+    def _has_manual_trigger(self) -> bool:
+        """Check if workflow has ManualTrigger."""
+        for subgraph in self.workflow.get_subgraphs():
+            for trigger in subgraph.triggers:
+                if issubclass(trigger, ManualTrigger):
+                    return True
+        return False
+
+    def _get_entrypoints_for_trigger_type(self, trigger_class: Type) -> List[Type[BaseNode]]:
+        """Get all entrypoints connected to a specific trigger type.
+
+        Allows subclasses: if trigger_class is a subclass of any declared trigger,
+        returns those entrypoints.
+        """
+        entrypoints: List[Type[BaseNode]] = []
+        for subgraph in self.workflow.get_subgraphs():
+            for trigger in subgraph.triggers:
+                # Check if the provided trigger_class is a subclass of the declared trigger
+                # This allows runtime instances to be subclasses of what's declared in the workflow
+                if issubclass(trigger_class, trigger):
+                    entrypoints.extend(subgraph.entrypoints)
+        return entrypoints
+
+    def _validate_and_bind_trigger(self, trigger: BaseTrigger) -> None:
+        """
+        Validate that trigger is compatible with workflow and bind it to state.
+
+        Supports all trigger types derived from BaseTrigger:
+        - IntegrationTrigger instances (Slack, Gmail, etc.)
+        - ManualTrigger instances (explicit manual execution)
+        - ScheduledTrigger instances (time-based triggers)
+        - Any future trigger types
+
+        Raises:
+            WorkflowInitializationException: If trigger type is not compatible with workflow
+        """
+        trigger_class = type(trigger)
+
+        # Search for a compatible trigger type in the workflow
+        found_compatible_trigger = False
+        has_any_triggers = False
+        incompatible_trigger_names: List[str] = []
+
+        for subgraph in self.workflow.get_subgraphs():
+            for declared_trigger in subgraph.triggers:
+                has_any_triggers = True
+                # Allow subclasses: if workflow declares BaseSlackTrigger, accept SpecificSlackTrigger instances
+                if issubclass(trigger_class, declared_trigger):
+                    found_compatible_trigger = True
+                    break
+                else:
+                    incompatible_trigger_names.append(declared_trigger.__name__)
+
+            if found_compatible_trigger:
+                break
+
+        # Special case: workflows with no explicit triggers implicitly support ManualTrigger
+        if not has_any_triggers and not isinstance(trigger, ManualTrigger):
+            raise WorkflowInitializationException(
+                message=f"Provided trigger type {trigger_class.__name__} is not compatible with workflow. "
+                f"Workflow has no explicit triggers and only supports ManualTrigger.",
+                workflow_definition=self.workflow.__class__,
+                code=WorkflowErrorCode.INVALID_INPUTS,
+            )
+
+        # Validate that we found a compatible trigger type
+        if has_any_triggers and not found_compatible_trigger:
+            raise WorkflowInitializationException(
+                message=f"Provided trigger type {trigger_class.__name__} is not compatible with workflow triggers. "
+                f"Workflow has: {sorted(set(incompatible_trigger_names))}",
+                workflow_definition=self.workflow.__class__,
+                code=WorkflowErrorCode.INVALID_INPUTS,
+            )
+
+        # Bind trigger to state (works for all trigger types via BaseTrigger.bind_to_state)
+        trigger.bind_to_state(self._initial_state)
+
+    def _filter_entrypoints_for_trigger(self, trigger: BaseTrigger) -> None:
+        """
+        Filter entrypoints to those connected to the specific trigger type.
+
+        Uses the specific trigger subclass, not the parent class, allowing workflows
+        with multiple triggers to route to the correct path.
+        """
+        trigger_class = type(trigger)
+        specific_entrypoints = self._get_entrypoints_for_trigger_type(trigger_class)
+        if specific_entrypoints:
+            self._entrypoints = specific_entrypoints
+
+    def _validate_no_trigger_provided(self) -> None:
+        """
+        Validate that workflow can run without a trigger.
+
+        If workflow has IntegrationTrigger(s) but no ManualTrigger, it requires a trigger instance.
+        If workflow has both, filter entrypoints to ManualTrigger path only.
+
+        Raises:
+            WorkflowInitializationException: If workflow requires trigger but none was provided
+        """
+        # Collect all IntegrationTrigger types in the workflow
+        workflow_integration_triggers = []
+        for subgraph in self.workflow.get_subgraphs():
+            for trigger_type in subgraph.triggers:
+                if issubclass(trigger_type, IntegrationTrigger):
+                    workflow_integration_triggers.append(trigger_type)
+
+        if workflow_integration_triggers:
+            if not self._has_manual_trigger():
+                # Workflow has ONLY IntegrationTrigger - this is an error
+                raise WorkflowInitializationException(
+                    message="Workflow has IntegrationTrigger which requires trigger parameter",
+                    workflow_definition=self.workflow.__class__,
+                    code=WorkflowErrorCode.INVALID_INPUTS,
+                )
+
+            # Workflow has both IntegrationTrigger and ManualTrigger - filter to ManualTrigger path
+            manual_entrypoints = self._get_entrypoints_for_trigger_type(ManualTrigger)
+            if manual_entrypoints:
+                self._entrypoints = manual_entrypoints
+
     @contextmanager
     def _httpx_logger_with_span_id(self) -> Iterator[None]:
         """