vellum-ai 1.5.0__py3-none-any.whl → 1.5.2__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.5.0",
+            "User-Agent": "vellum-ai/1.5.2",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.5.0",
+            "X-Fern-SDK-Version": "1.5.2",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

vellum/workflows/descriptors/utils.py

@@ -33,6 +33,9 @@ def resolve_value(
     from the `_T` generic.
     """
 
+    if memo is not None and path in memo:
+        return cast(_T, memo[path])
+
     if inspect.isclass(value):
         return cast(_T, value)
 

vellum/workflows/emitters/vellum_emitter.py

@@ -126,7 +126,10 @@ class VellumEmitter(BaseWorkflowEmitter):
             return
 
         client = self._context.vellum_client
-        request_options = RequestOptions(timeout_in_seconds=self._timeout, max_retries=self._max_retries)
+        if self._timeout is not None:
+            request_options = RequestOptions(timeout_in_seconds=int(self._timeout), max_retries=self._max_retries)
+        else:
+            request_options = RequestOptions(max_retries=self._max_retries)
 
         client.events.create(
             # The API accepts a ClientWorkflowEvent but our SDK emits an SDKWorkflowEvent. These shapes are

vellum/workflows/integrations/__init__.py

@@ -0,0 +1,5 @@
+from .composio_service import ComposioService
+from .mcp_service import MCPService
+from .vellum_integration_service import VellumIntegrationService
+
+__all__ = ["ComposioService", "MCPService", "VellumIntegrationService"]

vellum/workflows/integrations/tests/test_vellum_integration_service.py

@@ -0,0 +1,206 @@
+import pytest
+from unittest import mock
+
+from vellum.workflows.constants import VellumIntegrationProviderType
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.integrations.vellum_integration_service import VellumIntegrationService
+from vellum.workflows.types.definition import VellumIntegrationToolDetails
+
+
+def test_vellum_integration_service_get_tool_definition_success(vellum_client):
+    """Test that tool definitions are successfully retrieved from Vellum API"""
+    mock_client = vellum_client
+    mock_client.integrations = mock.MagicMock()
+
+    mock_response = mock.MagicMock()
+    mock_response.name = "GITHUB_CREATE_AN_ISSUE"
+    mock_response.description = "Create a new issue in a GitHub repository"
+    mock_response.parameters = {
+        "type": "object",
+        "properties": {
+            "repo": {"type": "string", "description": "Repository name"},
+            "title": {"type": "string", "description": "Issue title"},
+            "body": {"type": "string", "description": "Issue body"},
+        },
+        "required": ["repo", "title"],
+    }
+    mock_response.provider = "COMPOSIO"
+
+    mock_client.integrations.retrieve_integration_tool_definition.return_value = mock_response
+
+    # WHEN we request a tool definition
+    service = VellumIntegrationService(client=mock_client)
+    result = service.get_tool_definition(
+        integration="GITHUB",
+        provider="COMPOSIO",
+        tool_name="GITHUB_CREATE_AN_ISSUE",
+    )
+
+    # THEN the tool definition should be returned with all expected fields
+    assert isinstance(result, VellumIntegrationToolDetails)
+    assert result.name == "GITHUB_CREATE_AN_ISSUE"
+    assert result.description == "Create a new issue in a GitHub repository"
+    assert result.provider == VellumIntegrationProviderType.COMPOSIO
+    # Parameters should now be included in the tool details
+    assert result.parameters is not None
+    assert result.parameters["type"] == "object"
+    assert "properties" in result.parameters
+    assert "repo" in result.parameters["properties"]
+    assert "title" in result.parameters["properties"]
+
+    # AND the API should have been called with the correct parameters
+    mock_client.integrations.retrieve_integration_tool_definition.assert_called_once_with(
+        integration="GITHUB",
+        provider="COMPOSIO",
+        tool_name="GITHUB_CREATE_AN_ISSUE",
+    )
+
+
+def test_vellum_integration_service_get_tool_definition_api_error(vellum_client):
+    """Test that API errors are properly handled when retrieving tool definitions"""
+    mock_client = vellum_client
+    mock_client.integrations = mock.MagicMock()
+    mock_client.integrations.retrieve_integration_tool_definition.side_effect = Exception("Tool not found")
+
+    # WHEN we attempt to get a tool definition for an invalid tool
+    service = VellumIntegrationService(client=mock_client)
+
+    # THEN it should raise a NodeException with appropriate error message
+    with pytest.raises(NodeException) as exc_info:
+        service.get_tool_definition(
+            integration="GITHUB",
+            provider="COMPOSIO",
+            tool_name="INVALID_TOOL",
+        )
+
+    assert "Failed to retrieve tool definition" in str(exc_info.value)
+    assert "Tool not found" in str(exc_info.value)
+
+
+def test_vellum_integration_service_execute_tool_success(vellum_client):
+    """Test that tools are successfully executed via Vellum API"""
+    mock_client = vellum_client
+    mock_client.integrations = mock.MagicMock()
+
+    mock_response = mock.MagicMock()
+    mock_response.data = {
+        "success": True,
+        "issue_id": 123,
+        "issue_url": "https://github.com/user/repo/issues/123",
+    }
+
+    mock_client.integrations.execute_integration_tool.return_value = mock_response
+
+    # WHEN we execute a tool with valid arguments
+    service = VellumIntegrationService(client=mock_client)
+    result = service.execute_tool(
+        integration="GITHUB",
+        provider="COMPOSIO",
+        tool_name="GITHUB_CREATE_AN_ISSUE",
+        arguments={
+            "repo": "user/repo",
+            "title": "Test Issue",
+            "body": "Test body",
+        },
+    )
+
+    # THEN the execution result should contain expected data
+    assert result["success"] is True
+    assert result["issue_id"] == 123
+    assert result["issue_url"] == "https://github.com/user/repo/issues/123"
+
+    # AND the API should have been called with correct parameters
+    mock_client.integrations.execute_integration_tool.assert_called_once_with(
+        integration="GITHUB",
+        provider="COMPOSIO",
+        tool_name="GITHUB_CREATE_AN_ISSUE",
+        arguments={
+            "repo": "user/repo",
+            "title": "Test Issue",
+            "body": "Test body",
+        },
+    )
+
+
+def test_vellum_integration_service_execute_tool_api_error(vellum_client):
+    """Test that execution errors are properly handled"""
+    mock_client = vellum_client
+    mock_client.integrations = mock.MagicMock()
+    mock_client.integrations.execute_integration_tool.side_effect = Exception("Authentication failed")
+
+    # WHEN we attempt to execute a tool that encounters an error
+    service = VellumIntegrationService(client=mock_client)
+
+    # THEN it should raise a NodeException with appropriate error message
+    with pytest.raises(NodeException) as exc_info:
+        service.execute_tool(
+            integration="GITHUB",
+            provider="COMPOSIO",
+            tool_name="GITHUB_CREATE_AN_ISSUE",
+            arguments={"repo": "user/repo"},
+        )
+
+    assert "Failed to execute tool" in str(exc_info.value)
+    assert "Authentication failed" in str(exc_info.value)
+
+
+def test_vellum_integration_service_execute_tool_empty_response(vellum_client):
+    """Test that empty response data is handled gracefully"""
+    mock_client = vellum_client
+    mock_client.integrations = mock.MagicMock()
+
+    mock_response = mock.MagicMock()
+    mock_response.data = {}
+
+    mock_client.integrations.execute_integration_tool.return_value = mock_response
+
+    # WHEN we execute a tool that returns empty data
+    service = VellumIntegrationService(client=mock_client)
+    result = service.execute_tool(
+        integration="SLACK",
+        provider="COMPOSIO",
+        tool_name="SLACK_SEND_MESSAGE",
+        arguments={
+            "channel": "#general",
+            "message": "Hello, world!",
+        },
+    )
+
+    # THEN an empty dictionary should be returned without errors
+    assert result == {}
+
+
+def test_vellum_integration_service_multiple_tool_executions(vellum_client):
+    """Test that the service handles multiple sequential tool executions"""
+    mock_client = vellum_client
+    mock_client.integrations = mock.MagicMock()
+
+    responses = [
+        mock.MagicMock(data={"result": "first"}),
+        mock.MagicMock(data={"result": "second"}),
+    ]
+    mock_client.integrations.execute_integration_tool.side_effect = responses
+
+    # WHEN we execute multiple tools in sequence
+    service = VellumIntegrationService(client=mock_client)
+
+    result1 = service.execute_tool(
+        integration="GITHUB",
+        provider="COMPOSIO",
+        tool_name="TOOL_1",
+        arguments={"arg": "val1"},
+    )
+
+    result2 = service.execute_tool(
+        integration="SLACK",
+        provider="COMPOSIO",
+        tool_name="TOOL_2",
+        arguments={"arg": "val2"},
+    )
+
+    # THEN each tool execution should return its respective result
+    assert result1["result"] == "first"
+    assert result2["result"] == "second"
+
+    # AND the API should have been called twice
+    assert mock_client.integrations.execute_integration_tool.call_count == 2

vellum/workflows/integrations/vellum_integration_service.py

@@ -0,0 +1,98 @@
+from typing import Any, Dict, Optional
+
+from vellum.workflows.constants import VellumIntegrationProviderType
+from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.types.definition import VellumIntegrationToolDetails
+from vellum.workflows.vellum_client import create_vellum_client
+
+
+class VellumIntegrationService:
+    """Vellum Integration Service for retrieving tool definitions and executing tools.
+
+    This service uses the native Vellum client SDK to interact with Vellum's integration
+    endpoints, providing functionality similar to ComposioService but using Vellum's
+    own integration infrastructure.
+    """
+
+    def __init__(self, client: Optional[Any] = None) -> None:
+        """Initialize the VellumIntegrationService with a Vellum client."""
+        self._client = client or create_vellum_client()
+
+    def get_tool_definition(
+        self,
+        integration: str,
+        provider: str,
+        tool_name: str,
+    ) -> VellumIntegrationToolDetails:
+        """Retrieve a tool definition from Vellum integrations.
+
+        Args:
+            integration: The integration name (e.g., "GITHUB", "SLACK")
+            provider: The integration provider name (e.g., "COMPOSIO")
+            tool_name: The tool's unique name as specified by the provider
+
+        Returns:
+            VellumIntegrationToolDetails containing the tool definition with parameters
+
+        Raises:
+            NodeException: If the tool definition cannot be retrieved
+        """
+        try:
+            response = self._client.integrations.retrieve_integration_tool_definition(
+                integration=integration,
+                provider=provider,
+                tool_name=tool_name,
+            )
+
+            return VellumIntegrationToolDetails(
+                provider=VellumIntegrationProviderType(response.provider),
+                integration=integration,
+                name=response.name,
+                description=response.description,
+                parameters=response.parameters,
+            )
+        except Exception as e:
+            error_message = f"Failed to retrieve tool definition for {tool_name}: {str(e)}"
+            raise NodeException(
+                message=error_message,
+                code=WorkflowErrorCode.INVALID_OUTPUTS,
+            ) from e
+
+    def execute_tool(
+        self,
+        integration: str,
+        provider: str,
+        tool_name: str,
+        arguments: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """Execute a tool through Vellum integrations.
+
+        Args:
+            integration: The integration name (e.g., "GITHUB", "SLACK")
+            provider: The integration provider name (e.g., "COMPOSIO")
+            tool_name: The tool's unique name as specified by the provider
+            arguments: Arguments to pass to the tool
+
+        Returns:
+            Dict containing the execution result data
+
+        Raises:
+            NodeException: If the tool execution fails
+        """
+        try:
+            response = self._client.integrations.execute_integration_tool(
+                integration=integration,
+                provider=provider,
+                tool_name=tool_name,
+                arguments=arguments,
+            )
+
+            # Return the data from the response
+            return response.data
+        except Exception as e:
+            error_message = f"Failed to execute tool {tool_name}: {str(e)}"
+            raise NodeException(
+                message=error_message,
+                code=WorkflowErrorCode.INVALID_OUTPUTS,
+            ) from e

vellum/workflows/nodes/bases/base.py

@@ -439,6 +439,7 @@ class BaseNode(Generic[StateType], ABC, BaseExecutable, metaclass=BaseNodeMeta):
         *,
         state: Optional[StateType] = None,
         context: Optional[WorkflowContext] = None,
+        inputs: Optional[Dict[str, Any]] = None,
     ):
         if state:
             self.state = state
@@ -459,7 +460,27 @@ class BaseNode(Generic[StateType], ABC, BaseExecutable, metaclass=BaseNodeMeta):
             self.state = state_type()
 
         self._context = context or WorkflowContext()
-        inputs: Dict[str, Any] = {}
+        inputs_memo: Dict[str, Any] = inputs.copy() if inputs else {}
+        if inputs:
+            for input_key, input_value in inputs.items():
+                path_parts = input_key.split(".")
+                dir_path = path_parts[:-1]
+                leaf = path_parts[-1]
+                base: Any = self.__class__
+
+                for attr_name in dir_path:
+                    if hasattr(base, attr_name):
+                        base = getattr(base, attr_name)
+                    elif isinstance(base, dict) and attr_name in base:
+                        base = base[attr_name]
+                    else:
+                        break
+
+                if isinstance(base, dict):
+                    base[leaf] = input_value
+                else:
+                    setattr(base, leaf, input_value)
+
         for descriptor in self.__class__:
             if not descriptor.instance:
                 continue
@@ -468,12 +489,12 @@ class BaseNode(Generic[StateType], ABC, BaseExecutable, metaclass=BaseNodeMeta):
                 # We don't want to resolve attributes that are _meant_ to be descriptors
                 continue
 
-            resolved_value = resolve_value(descriptor.instance, self.state, path=descriptor.name, memo=inputs)
+            resolved_value = resolve_value(descriptor.instance, self.state, path=descriptor.name, memo=inputs_memo)
             setattr(self, descriptor.name, resolved_value)
 
         # We only want to store the attributes that were actually set as inputs, not every attribute that exists.
         all_inputs = {}
-        for key, value in inputs.items():
+        for key, value in inputs_memo.items():
             path_parts = key.split(".")
             node_attribute_descriptor = getattr(self.__class__, path_parts[0])
             inputs_key = reduce(lambda acc, part: acc[part], path_parts[1:], node_attribute_descriptor)

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

@@ -130,6 +130,11 @@ class InlineSubworkflowNode(
                 )
 
     def _compile_subworkflow_inputs(self) -> InputsType:
+        if self.subworkflow is None:
+            raise NodeException(
+                message="InlineSubworkflowNode requires a subworkflow to be defined",
+                code=WorkflowErrorCode.INVALID_INPUTS,
+            )
         inputs_class = self.subworkflow.get_inputs_class()
         try:
             if self.subworkflow_inputs is undefined:

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

@@ -57,6 +57,7 @@ from vellum.workflows.utils.functions import (
     compile_function_definition,
     compile_inline_workflow_function_definition,
     compile_mcp_tool_definition,
+    compile_vellum_integration_tool_definition,
     compile_workflow_deployment_function_definition,
     get_mcp_tool_name,
 )
@@ -151,11 +152,7 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
                 elif isinstance(function, ComposioToolDefinition):
                     normalized_functions.append(compile_composio_tool_definition(function))
                 elif isinstance(function, VellumIntegrationToolDefinition):
-                    # TODO: Implement compile_vellum_integration_tool_definition
-                    raise NotImplementedError(
-                        "VellumIntegrationToolDefinition support coming soon. "
-                        "This will be implemented when compile_vellum_integration_tool_definition is created."
-                    )
+                    normalized_functions.append(compile_vellum_integration_tool_definition(function))
                 elif isinstance(function, MCPServer):
                     tool_definitions = compile_mcp_tool_definition(function)
                     for tool_def in tool_definitions:

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

@@ -21,6 +21,7 @@ from vellum.workflows.expressions.concat import ConcatExpression
 from vellum.workflows.inputs import BaseInputs
 from vellum.workflows.integrations.composio_service import ComposioService
 from vellum.workflows.integrations.mcp_service import MCPService
+from vellum.workflows.integrations.vellum_integration_service import VellumIntegrationService
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.core.inline_subworkflow_node.node import InlineSubworkflowNode
 from vellum.workflows.nodes.displayable.inline_prompt_node.node import InlinePromptNode
@@ -263,6 +264,34 @@ class MCPNode(BaseNode[ToolCallingState], FunctionCallNodeMixin):
         yield from []
 
 
+class VellumIntegrationNode(BaseNode[ToolCallingState], FunctionCallNodeMixin):
+    """Node that executes a Vellum Integration tool with function call output."""
+
+    vellum_integration_tool: VellumIntegrationToolDefinition
+
+    def run(self) -> Iterator[BaseOutput]:
+        arguments = self._extract_function_arguments()
+
+        try:
+            vellum_service = VellumIntegrationService()
+            result = vellum_service.execute_tool(
+                integration=self.vellum_integration_tool.integration,
+                provider=self.vellum_integration_tool.provider.value,
+                tool_name=self.vellum_integration_tool.name,
+                arguments=arguments,
+            )
+        except Exception as e:
+            raise NodeException(
+                message=f"Error executing Vellum Integration tool '{self.vellum_integration_tool.name}': {str(e)}",
+                code=WorkflowErrorCode.NODE_EXECUTION,
+            )
+
+        # Add result to chat history
+        self._add_function_result_to_chat_history(result, self.state)
+
+        yield from []
+
+
 class ElseNode(BaseNode[ToolCallingState]):
     """Node that executes when no function conditions match."""
 
@@ -465,11 +494,16 @@ def create_function_node(
         )
         return node
     elif isinstance(function, VellumIntegrationToolDefinition):
-        # TODO: Implement VellumIntegrationNode
-        raise NotImplementedError(
-            "VellumIntegrationToolDefinition support coming soon. "
-            "This will be implemented when the VellumIntegrationService is created."
+        node = type(
+            f"VellumIntegrationNode_{function.name}",
+            (VellumIntegrationNode,),
+            {
+                "vellum_integration_tool": function,
+                "function_call_output": tool_prompt_node.Outputs.results,
+                "__module__": __name__,
+            },
         )
+        return node
     elif is_workflow_class(function):
         function.is_dynamic = True
         node = type(

vellum/workflows/types/definition.py

@@ -177,6 +177,17 @@ class VellumIntegrationToolDefinition(UniversalBaseModel):
     description: str
 
 
+class VellumIntegrationToolDetails(VellumIntegrationToolDefinition):
+    """Extended version of VellumIntegrationToolDefinition with runtime parameters.
+
+    This class includes the parameters field which is populated during compilation
+    from the Vellum integrations API response. It inherits all fields from the base
+    VellumIntegrationToolDefinition class.
+    """
+
+    parameters: Optional[Dict[str, Any]] = None
+
+
 class MCPServer(UniversalBaseModel):
     type: Literal["MCP_SERVER"] = "MCP_SERVER"
     name: str

vellum/workflows/utils/functions.py

@@ -10,6 +10,7 @@ from vellum import Vellum
 from vellum.client.types.function_definition import FunctionDefinition
 from vellum.workflows.integrations.composio_service import ComposioService
 from vellum.workflows.integrations.mcp_service import MCPService
+from vellum.workflows.integrations.vellum_integration_service import VellumIntegrationService
 from vellum.workflows.types.definition import (
     ComposioToolDefinition,
     DeploymentDefinition,
@@ -95,22 +96,21 @@ def compile_annotation(annotation: Optional[Any], defs: dict[str, Any]) -> dict:
             defs[annotation.__name__] = {"type": "object", "properties": properties, "required": required}
         return {"$ref": f"#/$defs/{annotation.__name__}"}
 
-    if issubclass(annotation, BaseModel):
+    if inspect.isclass(annotation) and issubclass(annotation, BaseModel):
         if annotation.__name__ not in defs:
             properties = {}
             required = []
-            for field_name, field in annotation.model_fields.items():
-                # Mypy is incorrect here, the `annotation` attribute is defined on `FieldInfo`
-                field_annotation = field.annotation  # type: ignore[attr-defined]
-                properties[field_name] = compile_annotation(field_annotation, defs)
+            for field_name, field_info in annotation.model_fields.items():
+                # field_info is a FieldInfo object which has an annotation attribute
+                properties[field_name] = compile_annotation(field_info.annotation, defs)
 
-                if hasattr(field, "description") and field.description is not None:
-                    properties[field_name]["description"] = field.description  # type: ignore[attr-defined]
+                if field_info.description is not None:
+                    properties[field_name]["description"] = field_info.description
 
-                if field.default is PydanticUndefined:
+                if field_info.default is PydanticUndefined:
                     required.append(field_name)
                 else:
-                    properties[field_name]["default"] = _compile_default_value(field.default)
+                    properties[field_name]["default"] = _compile_default_value(field_info.default)
             defs[annotation.__name__] = {"type": "object", "properties": properties, "required": required}
 
         return {"$ref": f"#/$defs/{annotation.__name__}"}
@@ -326,20 +326,28 @@ def compile_composio_tool_definition(tool_def: ComposioToolDefinition) -> Functi
 def compile_vellum_integration_tool_definition(tool_def: VellumIntegrationToolDefinition) -> FunctionDefinition:
     """Compile a VellumIntegrationToolDefinition into a FunctionDefinition.
 
-    TODO: Implement when VellumIntegrationService is created.
-
     Args:
         tool_def: The VellumIntegrationToolDefinition to compile
 
     Returns:
         FunctionDefinition with tool parameters and description
     """
-    # TODO: Implement when VellumIntegrationService is available
-    # This will eventually use VellumIntegrationService to fetch tool details
-    raise NotImplementedError(
-        "VellumIntegrationToolDefinition compilation coming soon. "
-        "This will be implemented when the VellumIntegrationService is created."
-    )
+    try:
+        service = VellumIntegrationService()
+        tool_details = service.get_tool_definition(
+            integration=tool_def.integration,
+            provider=tool_def.provider.value,
+            tool_name=tool_def.name,
+        )
+
+        return FunctionDefinition(
+            name=tool_def.name,
+            description=tool_details.description,
+            parameters=tool_details.parameters or {},
+        )
+    except Exception:
+        # Fallback for service failures
+        return FunctionDefinition(name=tool_def.name, description=tool_def.description, parameters={})
 
 
 def use_tool_inputs(**inputs):

vellum/workflows/workflows/base.py

@@ -565,10 +565,14 @@ class BaseWorkflow(Generic[InputsType, StateType], BaseExecutable, metaclass=_Ba
         # https://app.shortcut.com/vellum/story/4327
         pass
 
-    def run_node(self, node: Type[BaseNode]) -> Generator[NodeEvent, None, None]:
+    def run_node(
+        self, node: Type[BaseNode], *, inputs: Optional[Dict[str, Any]] = None
+    ) -> Generator[NodeEvent, None, None]:
         runner = WorkflowRunner(self)
         span_id = uuid4()
-        return runner.run_node(node=node(state=self.get_default_state(), context=self._context), span_id=span_id)
+        node_instance = node(state=self.get_default_state(), context=self._context, inputs=inputs)
+
+        return runner.run_node(node=node_instance, span_id=span_id)
 
     @classmethod
     @lru_cache

vellum/workflows/workflows/tests/test_base_workflow.py

@@ -738,3 +738,48 @@ def test_base_workflow__run_node_emits_correct_events():
     assert isinstance(events[1], NodeExecutionFulfilledEvent)
     assert events[0].span_id == events[1].span_id
     assert events[1].body.outputs.result == "test_output"
+
+
+def test_base_workflow__run_node_with_inputs():
+    """Test that run_node method accepts and applies inputs parameter with dot notation."""
+
+    class TestInputs(BaseInputs):
+        pass
+
+    class TestState(BaseState):
+        pass
+
+    class TestCodeNode(BaseNode[TestState]):
+        code_inputs: dict = {"input1": "default_value", "input2": "default_value2"}
+        test_attr: str = "default"
+        another_attr: str = "not_overridden"
+
+        class Outputs(BaseNode.Outputs):
+            result: str
+
+        def run(self) -> "TestCodeNode.Outputs":
+            return self.Outputs(
+                result=f"{self.test_attr}_{self.code_inputs['input1']}_{self.code_inputs['input2']}_{self.another_attr}"
+            )
+
+    class TestWorkflow(BaseWorkflow[TestInputs, TestState]):
+        graph = TestCodeNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            result: str
+
+    workflow = TestWorkflow()
+
+    inputs_data = {"test_attr": "overridden", "code_inputs.input1": "overridden_value"}
+
+    # WHEN we run the node with inputs
+    events = list(workflow.run_node(node=TestCodeNode, inputs=inputs_data))
+
+    # THEN the node should execute with the overridden attributes
+    assert len(events) == 2
+    assert isinstance(events[0], NodeExecutionInitiatedEvent)
+    assert isinstance(events[1], NodeExecutionFulfilledEvent)
+
+    # AND the execution result should use the overridden and non-overridden attributes
+    fulfilled_event = events[1]
+    assert fulfilled_event.body.outputs.result == "overridden_overridden_value_default_value2_not_overridden"