nvidia-nat 1.3.0a20250917__py3-none-any.whl → 1.3.0a20250923__py3-none-any.whl

nat/builder/context.py

@@ -69,12 +69,10 @@ class ContextState(metaclass=Singleton):
         self.user_message_id: ContextVar[str | None] = ContextVar("user_message_id", default=None)
         self.input_message: ContextVar[typing.Any] = ContextVar("input_message", default=None)
         self.user_manager: ContextVar[typing.Any] = ContextVar("user_manager", default=None)
-        self.metadata: ContextVar[RequestAttributes] = ContextVar("request_attributes", default=RequestAttributes())
-        self.event_stream: ContextVar[Subject[IntermediateStep] | None] = ContextVar("event_stream", default=Subject())
-        self.active_function: ContextVar[InvocationNode] = ContextVar("active_function",
-                                                                      default=InvocationNode(function_id="root",
-                                                                                             function_name="root"))
-        self.active_span_id_stack: ContextVar[list[str]] = ContextVar("active_span_id_stack", default=["root"])
+        self._metadata: ContextVar[RequestAttributes | None] = ContextVar("request_attributes", default=None)
+        self._event_stream: ContextVar[Subject[IntermediateStep] | None] = ContextVar("event_stream", default=None)
+        self._active_function: ContextVar[InvocationNode | None] = ContextVar("active_function", default=None)
+        self._active_span_id_stack: ContextVar[list[str] | None] = ContextVar("active_span_id_stack", default=None)
 
         # Default is a lambda no-op which returns NoneType
         self.user_input_callback: ContextVar[Callable[[InteractionPrompt], Awaitable[HumanResponse | None]]
@@ -85,6 +83,30 @@ class ContextState(metaclass=Singleton):
                                                      Awaitable[AuthenticatedContext]]
                                             | None] = ContextVar("user_auth_callback", default=None)
 
+    @property
+    def metadata(self) -> ContextVar[RequestAttributes]:
+        if self._metadata.get() is None:
+            self._metadata.set(RequestAttributes())
+        return typing.cast(ContextVar[RequestAttributes], self._metadata)
+
+    @property
+    def active_function(self) -> ContextVar[InvocationNode]:
+        if self._active_function.get() is None:
+            self._active_function.set(InvocationNode(function_id="root", function_name="root"))
+        return typing.cast(ContextVar[InvocationNode], self._active_function)
+
+    @property
+    def event_stream(self) -> ContextVar[Subject[IntermediateStep]]:
+        if self._event_stream.get() is None:
+            self._event_stream.set(Subject())
+        return typing.cast(ContextVar[Subject[IntermediateStep]], self._event_stream)
+
+    @property
+    def active_span_id_stack(self) -> ContextVar[list[str]]:
+        if self._active_span_id_stack.get() is None:
+            self._active_span_id_stack.set(["root"])
+        return typing.cast(ContextVar[list[str]], self._active_span_id_stack)
+
     @staticmethod
     def get() -> "ContextState":
         return ContextState()

nat/builder/function.py

@@ -21,6 +21,7 @@ from abc import abstractmethod
 from collections.abc import AsyncGenerator
 from collections.abc import Awaitable
 from collections.abc import Callable
+from collections.abc import Sequence
 
 from pydantic import BaseModel
 
@@ -352,7 +353,11 @@ class FunctionGroup:
     A group of functions that can be used together, sharing the same configuration, context, and resources.
     """
 
-    def __init__(self, *, config: FunctionGroupBaseConfig, instance_name: str | None = None):
+    def __init__(self,
+                 *,
+                 config: FunctionGroupBaseConfig,
+                 instance_name: str | None = None,
+                 filter_fn: Callable[[Sequence[str]], Sequence[str]] | None = None):
         """
         Creates a new function group.
 
@@ -362,10 +367,15 @@ class FunctionGroup:
             The configuration for the function group.
         instance_name : str | None, optional
             The name of the function group. If not provided, the type of the function group will be used.
+        filter_fn : Callable[[Sequence[str]], Sequence[str]] | None, optional
+            A callback function to additionally filter the functions in the function group dynamically when
+            the functions are accessed via any accessor method.
         """
         self._config = config
         self._instance_name = instance_name or config.type
-        self._functions: dict[str, Function] = {}
+        self._functions: dict[str, Function] = dict()
+        self._filter_fn = filter_fn
+        self._per_function_filter_fn: dict[str, Callable[[str], bool]] = dict()
 
     def add_function(self,
                      name: str,
@@ -373,7 +383,8 @@ class FunctionGroup:
                      *,
                      input_schema: type[BaseModel] | None = None,
                      description: str | None = None,
-                     converters: list[Callable] | None = None):
+                     converters: list[Callable] | None = None,
+                     filter_fn: Callable[[str], bool] | None = None):
         """
         Adds a function to the function group.
 
@@ -389,6 +400,11 @@ class FunctionGroup:
             The description of the function.
         converters : list[Callable] | None, optional
             The converters to use for the function.
+        filter_fn : Callable[[str], bool] | None, optional
+            A callback to determine if the function should be included in the function group. The
+            callback will be called with the function name. The callback is invoked dynamically when
+            the functions are accessed via any accessor method such as `get_accessible_functions`,
+            `get_included_functions`, `get_excluded_functions`, `get_all_functions`.
 
         Raises
         ------
@@ -408,6 +424,8 @@ class FunctionGroup:
         full_name = self._get_fn_name(name)
         lambda_fn = LambdaFunction.from_info(config=EmptyFunctionConfig(), info=info, instance_name=full_name)
         self._functions[name] = lambda_fn
+        if filter_fn:
+            self._per_function_filter_fn[name] = filter_fn
 
     def get_config(self) -> FunctionGroupBaseConfig:
         """
@@ -423,24 +441,54 @@ class FunctionGroup:
     def _get_fn_name(self, name: str) -> str:
         return f"{self._instance_name}.{name}"
 
-    def _get_all_but_excluded_functions(self) -> dict[str, Function]:
+    def _fn_should_be_included(self, name: str) -> bool:
+        return (name not in self._per_function_filter_fn or self._per_function_filter_fn[name](name))
+
+    def _get_all_but_excluded_functions(
+        self,
+        filter_fn: Callable[[Sequence[str]], Sequence[str]] | None = None,
+    ) -> dict[str, Function]:
         """
         Returns a dictionary of all functions in the function group except the excluded functions.
         """
         missing = set(self._config.exclude) - set(self._functions.keys())
         if missing:
             raise ValueError(f"Unknown excluded functions: {sorted(missing)}")
+        filter_fn = filter_fn or self._filter_fn or (lambda x: x)
         excluded = set(self._config.exclude)
-        return {self._get_fn_name(name): self._functions[name] for name in self._functions if name not in excluded}
+        included = set(filter_fn(list(self._functions.keys())))
+
+        def predicate(name: str) -> bool:
+            if name in excluded:
+                return False
+            if not self._fn_should_be_included(name):
+                return False
+            return name in included
 
-    def get_accessible_functions(self) -> dict[str, Function]:
+        return {self._get_fn_name(name): self._functions[name] for name in self._functions if predicate(name)}
+
+    def get_accessible_functions(
+        self,
+        filter_fn: Callable[[Sequence[str]], Sequence[str]] | None = None,
+    ) -> dict[str, Function]:
         """
         Returns a dictionary of all accessible functions in the function group.
+
+        First, the functions are filtered by the function group's configuration.
         If the function group is configured to:
         - include some functions, this will return only the included functions.
         - not include or exclude any function, this will return all functions in the group.
         - exclude some functions, this will return all functions in the group except the excluded functions.
 
+        Then, the functions are filtered by filter function and per-function filter functions.
+
+        Parameters
+        ----------
+        filter_fn : Callable[[Sequence[str]], Sequence[str]] | None, optional
+            A callback function to additionally filter the functions in the function group dynamically. If not provided
+            then fall back to the function group's filter function. If no filter function is set for the function group
+            all functions will be returned.
+
         Returns
         -------
         dict[str, Function]
@@ -452,15 +500,25 @@ class FunctionGroup:
             When the function group is configured to include functions that are not found in the group.
         """
         if self._config.include:
-            return self.get_included_functions()
+            return self.get_included_functions(filter_fn=filter_fn)
         if self._config.exclude:
-            return self._get_all_but_excluded_functions()
-        return self.get_all_functions()
+            return self._get_all_but_excluded_functions(filter_fn=filter_fn)
+        return self.get_all_functions(filter_fn=filter_fn)
 
-    def get_excluded_functions(self) -> dict[str, Function]:
+    def get_excluded_functions(
+        self,
+        filter_fn: Callable[[Sequence[str]], Sequence[str]] | None = None,
+    ) -> dict[str, Function]:
         """
-        Returns a dictionary of all functions in the function group which are configured to be excluded.
-        If the function group is configured to not exclude any functions, this will return an empty dictionary.
+        Returns a dictionary of all functions in the function group which are configured to be excluded or filtered
+        out by a filter function or per-function filter function.
+
+        Parameters
+        ----------
+        filter_fn : Callable[[Sequence[str]], Sequence[str]] | None, optional
+            A callback function to additionally filter the functions in the function group dynamically. If not provided
+            then fall back to the function group's filter function. If no filter function is set for the function group
+            then no functions will be added to the returned dictionary.
 
         Returns
         -------
@@ -475,14 +533,35 @@ class FunctionGroup:
         missing = set(self._config.exclude) - set(self._functions.keys())
         if missing:
             raise ValueError(f"Unknown excluded functions: {sorted(missing)}")
-        return {self._get_fn_name(name): self._functions[name] for name in self._config.exclude}
+        filter_fn = filter_fn or self._filter_fn or (lambda x: x)
+        excluded = set(self._config.exclude)
+        included = set(filter_fn(list(self._functions.keys())))
+
+        def predicate(name: str) -> bool:
+            if name in excluded:
+                return True
+            if not self._fn_should_be_included(name):
+                return True
+            return name not in included
 
-    def get_included_functions(self) -> dict[str, Function]:
+        return {self._get_fn_name(name): self._functions[name] for name in self._functions if predicate(name)}
+
+    def get_included_functions(
+        self,
+        filter_fn: Callable[[Sequence[str]], Sequence[str]] | None = None,
+    ) -> dict[str, Function]:
         """
         Returns a dictionary of all functions in the function group which are:
         - configured to be included and added to the global function registry
         - not configured to be excluded.
-        If the function group is configured to not include any functions, this will return an empty dictionary.
+        - not filtered out by a filter function.
+
+        Parameters
+        ----------
+        filter_fn : Callable[[Sequence[str]], Sequence[str]] | None, optional
+            A callback function to additionally filter the functions in the function group dynamically. If not provided
+            then fall back to the function group's filter function. If no filter function is set for the function group
+            all functions will be returned.
 
         Returns
         -------
@@ -497,15 +576,82 @@ class FunctionGroup:
         missing = set(self._config.include) - set(self._functions.keys())
         if missing:
             raise ValueError(f"Unknown included functions: {sorted(missing)}")
-        return {self._get_fn_name(name): self._functions[name] for name in self._config.include}
-
-    def get_all_functions(self) -> dict[str, Function]:
+        filter_fn = filter_fn or self._filter_fn or (lambda x: x)
+        included = set(filter_fn(list(self._config.include)))
+        included = {name for name in included if self._fn_should_be_included(name)}
+        return {self._get_fn_name(name): self._functions[name] for name in included}
+
+    def get_all_functions(
+        self,
+        filter_fn: Callable[[Sequence[str]], Sequence[str]] | None = None,
+    ) -> dict[str, Function]:
         """
         Returns a dictionary of all functions in the function group, regardless if they are included or excluded.
 
+        If a filter function has been set, the returned functions will additionally be filtered by the callback.
+
+        Parameters
+        ----------
+        filter_fn : Callable[[Sequence[str]], Sequence[str]] | None, optional
+            A callback function to additionally filter the functions in the function group dynamically. If not provided
+            then fall back to the function group's filter function. If no filter function is set for the function group
+            all functions will be returned.
+
         Returns
         -------
         dict[str, Function]
             A dictionary of all functions in the function group.
         """
-        return {self._get_fn_name(name): self._functions[name] for name in self._functions}
+        filter_fn = filter_fn or self._filter_fn or (lambda x: x)
+        included = set(filter_fn(list(self._functions.keys())))
+        included = {name for name in included if self._fn_should_be_included(name)}
+        return {self._get_fn_name(name): self._functions[name] for name in included}
+
+    def set_filter_fn(self, filter_fn: Callable[[Sequence[str]], Sequence[str]]):
+        """
+        Sets the filter function for the function group.
+
+        Parameters
+        ----------
+        filter_fn : Callable[[Sequence[str]], Sequence[str]]
+            The filter function to set for the function group.
+        """
+        self._filter_fn = filter_fn
+
+    def set_per_function_filter_fn(self, name: str, filter_fn: Callable[[str], bool]):
+        """
+        Sets the a per-function filter function for the a function within the function group.
+
+        Parameters
+        ----------
+        name : str
+            The name of the function.
+        filter_fn : Callable[[str], bool]
+            The per-function filter function to set for the function group.
+
+        Raises
+        ------
+        ValueError
+            When the function is not found in the function group.
+        """
+        if name not in self._functions:
+            raise ValueError(f"Function {name} not found in function group {self._instance_name}")
+        self._per_function_filter_fn[name] = filter_fn
+
+    def set_instance_name(self, instance_name: str):
+        """
+        Sets the instance name for the function group.
+
+        Parameters
+        ----------
+        instance_name : str
+            The instance name to set for the function group.
+        """
+        self._instance_name = instance_name
+
+    @property
+    def instance_name(self) -> str:
+        """
+        Returns the instance name for the function group.
+        """
+        return self._instance_name

nat/builder/workflow_builder.py

@@ -415,6 +415,8 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
             raise ValueError("Expected a FunctionGroup object to be returned from the function group builder. "
                              f"Got {type(build_result)}")
 
+        # set the instance name for the function group based on the workflow-provided name
+        build_result.set_instance_name(name)
         return ConfiguredFunctionGroup(config=config, instance=build_result)
 
     @override

nat/cli/entrypoint.py

@@ -30,6 +30,8 @@ import time
 import click
 import nest_asyncio
 
+from nat.utils.log_levels import LOG_LEVELS
+
 from .commands.configure.configure import configure_command
 from .commands.evaluate import eval_command
 from .commands.info.info import info_command
@@ -45,15 +47,6 @@ from .commands.workflow.workflow import workflow_command
 # Apply at the beginning of the file to avoid issues with asyncio
 nest_asyncio.apply()
 
-# Define log level choices
-LOG_LEVELS = {
-    'DEBUG': logging.DEBUG,
-    'INFO': logging.INFO,
-    'WARNING': logging.WARNING,
-    'ERROR': logging.ERROR,
-    'CRITICAL': logging.CRITICAL
-}
-
 
 def setup_logging(log_level: str):
     """Configure logging with the specified level"""

nat/control_flow/register.py

@@ -0,0 +1,20 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# flake8: noqa
+
+# Import any control flows which need to be automatically registered here
+from . import sequential_executor
+from .router_agent import register

nat/{agent → control_flow}/router_agent/agent.py

@@ -31,7 +31,7 @@ from nat.agent.base import AGENT_LOG_PREFIX
 from nat.agent.base import BaseAgent
 
 if typing.TYPE_CHECKING:
-    from nat.agent.router_agent.register import RouterAgentWorkflowConfig
+    from nat.control_flow.router_agent.register import RouterAgentWorkflowConfig
 
 logger = logging.getLogger(__name__)
 
@@ -304,8 +304,8 @@ def create_router_agent_prompt(config: "RouterAgentWorkflowConfig") -> ChatPromp
     Raises:
         ValueError: If the system_prompt or user_prompt validation fails.
     """
-    from nat.agent.router_agent.prompt import SYSTEM_PROMPT
-    from nat.agent.router_agent.prompt import USER_PROMPT
+    from nat.control_flow.router_agent.prompt import SYSTEM_PROMPT
+    from nat.control_flow.router_agent.prompt import USER_PROMPT
     # the Router Agent prompt can be customized via config option system_prompt and user_prompt.
 
     if config.system_prompt:

nat/{agent → control_flow}/router_agent/register.py

@@ -16,35 +16,29 @@
 import logging
 
 from pydantic import Field
-from pydantic import PositiveInt
 
 from nat.builder.builder import Builder
 from nat.builder.framework_enum import LLMFrameworkEnum
 from nat.builder.function_info import FunctionInfo
 from nat.cli.register_workflow import register_function
+from nat.data_models.agent import AgentBaseConfig
 from nat.data_models.component_ref import FunctionRef
-from nat.data_models.component_ref import LLMRef
-from nat.data_models.function import FunctionBaseConfig
 
 logger = logging.getLogger(__name__)
 
 
-class RouterAgentWorkflowConfig(FunctionBaseConfig, name="router_agent"):
+class RouterAgentWorkflowConfig(AgentBaseConfig, name="router_agent"):
     """
     A router agent takes in the incoming message, combines it with a prompt and the list of branches,
     and ask a LLM about which branch to take.
     """
+    description: str = Field(default="Router Agent Workflow", description="Description of this functions use.")
     branches: list[FunctionRef] = Field(default_factory=list,
                                         description="The list of branches to provide to the router agent.")
-    llm_name: LLMRef = Field(description="The LLM model to use with the routing agent.")
-    description: str = Field(default="Router Agent Workflow", description="Description of this functions use.")
     system_prompt: str | None = Field(default=None, description="Provides the system prompt to use with the agent.")
     user_prompt: str | None = Field(default=None, description="Provides the prompt to use with the agent.")
     max_router_retries: int = Field(
         default=3, description="Maximum number of retries if the router agent fails to choose a branch.")
-    detailed_logs: bool = Field(default=False, description="Set the verbosity of the router agent's logging.")
-    log_response_max_chars: PositiveInt = Field(
-        default=1000, description="Maximum number of characters to display in logs when logging branch responses.")
 
 
 @register_function(config_type=RouterAgentWorkflowConfig, framework_wrappers=[LLMFrameworkEnum.LANGCHAIN])
@@ -53,9 +47,9 @@ async def router_agent_workflow(config: RouterAgentWorkflowConfig, builder: Buil
     from langgraph.graph.state import CompiledStateGraph
 
     from nat.agent.base import AGENT_LOG_PREFIX
-    from nat.agent.router_agent.agent import RouterAgentGraph
-    from nat.agent.router_agent.agent import RouterAgentGraphState
-    from nat.agent.router_agent.agent import create_router_agent_prompt
+    from nat.control_flow.router_agent.agent import RouterAgentGraph
+    from nat.control_flow.router_agent.agent import RouterAgentGraphState
+    from nat.control_flow.router_agent.agent import create_router_agent_prompt
 
     prompt = create_router_agent_prompt(config)
     llm = await builder.get_llm(config.llm_name, wrapper_type=LLMFrameworkEnum.LANGCHAIN)
@@ -68,7 +62,7 @@ async def router_agent_workflow(config: RouterAgentWorkflowConfig, builder: Buil
         branches=branches,
         prompt=prompt,
         max_router_retries=config.max_router_retries,
-        detailed_logs=config.detailed_logs,
+        detailed_logs=config.verbose,
         log_response_max_chars=config.log_response_max_chars,
     ).build_graph()
 
@@ -85,7 +79,7 @@ async def router_agent_workflow(config: RouterAgentWorkflowConfig, builder: Buil
 
         except Exception as ex:
             logger.exception("%s Router Agent failed with exception: %s", AGENT_LOG_PREFIX, ex)
-            if config.detailed_logs:
+            if config.verbose:
                 return str(ex)
             return "Router agent failed with exception: %s" % ex
 

nat/control_flow/sequential_executor.py

@@ -0,0 +1,167 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+import typing
+
+from langchain_core.tools.base import BaseTool
+from pydantic import BaseModel
+from pydantic import Field
+
+from nat.builder.builder import Builder
+from nat.builder.framework_enum import LLMFrameworkEnum
+from nat.builder.function import Function
+from nat.builder.function_info import FunctionInfo
+from nat.cli.register_workflow import register_function
+from nat.data_models.component_ref import FunctionRef
+from nat.data_models.function import FunctionBaseConfig
+from nat.utils.type_utils import DecomposedType
+
+logger = logging.getLogger(__name__)
+
+
+class ToolExecutionConfig(BaseModel):
+    """Configuration for individual tool execution within sequential execution."""
+
+    use_streaming: bool = Field(default=False, description="Whether to use streaming output for the tool.")
+
+
+class SequentialExecutorConfig(FunctionBaseConfig, name="sequential_executor"):
+    """Configuration for sequential execution of a list of functions."""
+
+    tool_list: list[FunctionRef] = Field(default_factory=list,
+                                         description="A list of functions to execute sequentially.")
+    tool_execution_config: dict[str, ToolExecutionConfig] = Field(default_factory=dict,
+                                                                  description="Optional configuration for each"
+                                                                  "tool in the sequential execution tool list."
+                                                                  "Keys must match the tool names from the"
+                                                                  "tool_list.")
+    raise_type_incompatibility: bool = Field(
+        default=False,
+        description="Default to False. Check if the adjacent tools are type compatible,"
+        "which means the output type of the previous function is compatible with the input type of the next function."
+        "If set to True, any incompatibility will raise an exception. If set to false, the incompatibility will only"
+        "generate a warning message and the sequential execution will continue.")
+
+
+def _get_function_output_type(function: Function, tool_execution_config: dict[str, ToolExecutionConfig]) -> type:
+    function_config = tool_execution_config.get(function.instance_name, None)
+    if function_config:
+        return function.streaming_output_type if function_config.use_streaming else function.single_output_type
+    else:
+        return function.single_output_type
+
+
+def _validate_function_type_compatibility(src_fn: Function,
+                                          target_fn: Function,
+                                          tool_execution_config: dict[str, ToolExecutionConfig]) -> None:
+    src_output_type = _get_function_output_type(src_fn, tool_execution_config)
+    target_input_type = target_fn.input_type
+    logger.debug(
+        f"The output type of the {src_fn.instance_name} function is {str(src_output_type)}, is not compatible with"
+        f"the input type of the {target_fn.instance_name} function, which is {str(target_input_type)}")
+
+    is_compatible = DecomposedType.is_type_compatible(src_output_type, target_input_type)
+    if not is_compatible:
+        raise ValueError(
+            f"The output type of the {src_fn.instance_name} function is {str(src_output_type)}, is not compatible with"
+            f"the input type of the {target_fn.instance_name} function, which is {str(target_input_type)}")
+
+
+def _validate_tool_list_type_compatibility(sequential_executor_config: SequentialExecutorConfig,
+                                           builder: Builder) -> tuple[type, type]:
+    tool_list = sequential_executor_config.tool_list
+    tool_execution_config = sequential_executor_config.tool_execution_config
+
+    function_list: list[Function] = []
+    for function_ref in tool_list:
+        function_list.append(builder.get_function(function_ref))
+    if not function_list:
+        raise RuntimeError("The function list is empty")
+    input_type = function_list[0].input_type
+
+    if len(function_list) > 1:
+        for src_fn, target_fn in zip(function_list[0:-1], function_list[1:]):
+            try:
+                _validate_function_type_compatibility(src_fn, target_fn, tool_execution_config)
+            except ValueError as e:
+                raise ValueError(f"The sequential tool list has incompatible types: {e}")
+
+    output_type = _get_function_output_type(function_list[-1], tool_execution_config)
+    logger.debug(f"The input type of the sequential executor tool list is {str(input_type)},"
+                 f"the output type is {str(output_type)}")
+
+    return (input_type, output_type)
+
+
+@register_function(config_type=SequentialExecutorConfig, framework_wrappers=[LLMFrameworkEnum.LANGCHAIN])
+async def sequential_execution(config: SequentialExecutorConfig, builder: Builder):
+    logger.debug(f"Initializing sequential executor with tool list: {config.tool_list}")
+
+    tools: list[BaseTool] = builder.get_tools(tool_names=config.tool_list, wrapper_type=LLMFrameworkEnum.LANGCHAIN)
+    tools_dict: dict[str, BaseTool] = {tool.name: tool for tool in tools}
+
+    try:
+        input_type, output_type = _validate_tool_list_type_compatibility(config, builder)
+    except ValueError as e:
+        if config.raise_type_incompatibility:
+            logger.error(f"The sequential executor tool list has incompatible types: {e}")
+            raise
+        else:
+            logger.warning(f"The sequential executor tool list has incompatible types: {e}")
+            input_type = typing.Any
+            output_type = typing.Any
+    except Exception as e:
+        raise ValueError(f"Error with the sequential executor tool list: {e}")
+
+    # The type annotation of _sequential_function_execution is dynamically set according to the tool list
+    async def _sequential_function_execution(initial_tool_input):
+        logger.debug(f"Executing sequential executor with tool list: {config.tool_list}")
+
+        tool_list: list[FunctionRef] = config.tool_list
+        tool_input = initial_tool_input
+        tool_response = None
+
+        for tool_name in tool_list:
+            tool = tools_dict[tool_name]
+            tool_execution_config = config.tool_execution_config.get(tool_name, None)
+            logger.debug(f"Executing tool {tool_name} with input: {tool_input}")
+            try:
+                if tool_execution_config:
+                    if tool_execution_config.use_streaming:
+                        output = ""
+                        async for chunk in tool.astream(tool_input):
+                            output += chunk.content
+                        tool_response = output
+                    else:
+                        tool_response = await tool.ainvoke(tool_input)
+                else:
+                    tool_response = await tool.ainvoke(tool_input)
+            except Exception as e:
+                logger.error(f"Error with tool {tool_name}: {e}")
+                raise
+
+            # The input of the next tool is the response of the previous tool
+            tool_input = tool_response
+
+        return tool_response
+
+    # Dynamically set the annotations for the function
+    _sequential_function_execution.__annotations__ = {"initial_tool_input": input_type, "return": output_type}
+    logger.debug(f"Sequential executor function annotations: {_sequential_function_execution.__annotations__}")
+
+    yield FunctionInfo.from_fn(_sequential_function_execution,
+                               description="Executes a list of functions sequentially."
+                               "The input of the next tool is the response of the previous tool.")