agently 4.0.6.10__tar.gz → 4.0.7__tar.gz

{agently-4.0.6.10 → agently-4.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agently
-Version: 4.0.6.10
+Version: 4.0.7
 Summary: 
 License: Apache-2.0
 License-File: LICENSE

{agently-4.0.6.10 → agently-4.0.7}/agently/base.py

@@ -14,7 +14,7 @@
 
 from typing import Any, Literal, Type, TYPE_CHECKING, TypeVar, Generic, cast
 
-from agently.utils import Settings, create_logger, FunctionShifter
+from agently.utils import Settings, create_logger, FunctionShifter, DataFormatter
 from agently.core import PluginManager, EventCenter, Tool, Prompt, ModelRequest, BaseAgent
 from agently._default_init import _load_default_settings, _load_default_plugins, _hook_default_event_handlers
 
@@ -117,6 +117,8 @@ class AgentlyMain(Generic[A]):
         self.tool = tool
         self.AgentType = AgentType
 
+        self.set_settings = self.settings.set_settings
+
     def set_debug_console(self, debug_console_status: Literal["ON", "OFF"]):
         match debug_console_status:
             case "OFF":
@@ -130,10 +132,6 @@ class AgentlyMain(Generic[A]):
         self.logger.setLevel(log_level)
         return self
 
-    def set_settings(self, key: str, value: "SerializableValue"):
-        self.settings.set_settings(key, value)
-        return self
-
     def create_prompt(self, name: str = "agently_prompt") -> Prompt:
         return Prompt(
             self.plugin_manager,

{agently-4.0.6.10 → agently-4.0.7}/agently/builtins/agent_extensions/ConfigurePromptExtension.py

@@ -21,6 +21,7 @@ from typing import Any
 from json import JSONDecodeError
 
 from agently.core import BaseAgent
+from agently.utils import DataLocator
 
 
 class ConfigurePromptExtension(BaseAgent):
@@ -168,46 +169,74 @@ class ConfigurePromptExtension(BaseAgent):
                                 variable_mappings,
                             )
 
-    def load_yaml_prompt(self, path_or_content: str, mappings: dict[str, Any] | None = None):
+    def load_yaml_prompt(
+        self,
+        path_or_content: str | Path,
+        mappings: dict[str, Any] | None = None,
+        *,
+        prompt_key_path: str | None = None,
+        encoding: str | None = "utf-8",
+    ):
         path = Path(path_or_content)
         if path.exists() and path.is_file():
             try:
-                with path.open("r", encoding="utf-8") as file:
+                with path.open("r", encoding=encoding) as file:
                     prompt = yaml.safe_load(file)
             except yaml.YAMLError as e:
                 raise ValueError(f"Cannot load YAML file '{ path_or_content }'.\nError: { e }")
         else:
             try:
-                prompt = yaml.safe_load(path_or_content)
+                prompt = yaml.safe_load(str(path_or_content))
             except yaml.YAMLError as e:
                 raise ValueError(f"Cannot load YAML content or file path not existed.\nError: { e }")
+        if not isinstance(prompt, dict):
+            raise TypeError(
+                "Cannot execute YAML prompt configures, expect prompt configures as a dictionary data but got:"
+                f"{ prompt }"
+            )
+        if prompt_key_path is not None:
+            prompt = DataLocator.locate_path_in_dict(prompt, prompt_key_path)
         if isinstance(prompt, dict):
             self._execute_prompt_configure(prompt, mappings)
         else:
             raise TypeError(
-                "Cannot execute YAML prompt configures, expect prompt configures as a dictionary data but got:"
+                f"Cannot execute YAML prompt configures, expect prompt configures{ ' from [' + prompt_key_path + '] ' if prompt_key_path is not None else '' } as a dictionary data but got:"
                 f"{ prompt }"
             )
         return self
 
-    def load_json_prompt(self, path_or_content: str, mappings: dict[str, Any] | None = None):
+    def load_json_prompt(
+        self,
+        path_or_content: str | Path,
+        mappings: dict[str, Any] | None = None,
+        *,
+        prompt_key_path: str | None = None,
+        encoding: str | None = "utf-8",
+    ):
         path = Path(path_or_content)
         if path.exists() and path.is_file():
             try:
-                with path.open("r", encoding="utf-8") as file:
+                with path.open("r", encoding=encoding) as file:
                     prompt = json5.load(file)
             except JSONDecodeError as e:
                 raise ValueError(f"Cannot load JSON file '{ path_or_content }'.\nError: { e }")
         else:
             try:
-                prompt = json5.loads(path_or_content)
-            except yaml.YAMLError as e:
+                prompt = json5.loads(str(path_or_content))
+            except JSONDecodeError as e:
                 raise ValueError(f"Cannot load JSON content or file path not existed.\nError: { e }")
+        if not isinstance(prompt, dict):
+            raise TypeError(
+                "Cannot execute JSON prompt configures, expect prompt configures as a dictionary data but got:"
+                f"{ prompt }"
+            )
+        if prompt_key_path is not None:
+            prompt = DataLocator.locate_path_in_dict(prompt, prompt_key_path)
         if isinstance(prompt, dict):
             self._execute_prompt_configure(prompt, mappings)
         else:
             raise TypeError(
-                "Cannot execute JSON prompt configures, expect prompt configures as a dictionary data but got:"
+                f"Cannot execute JSON prompt configures, expect prompt configures{ ' from [' + prompt_key_path + '] ' if prompt_key_path is not None else '' }as a dictionary data but got:"
                 f"{ prompt }"
             )
         return self

{agently-4.0.6.10 → agently-4.0.7}/agently/builtins/plugins/ModelRequester/OpenAICompatible.py

@@ -45,6 +45,7 @@ if TYPE_CHECKING:
 class ContentMapping(TypedDict):
     id: str | None
     role: str | None
+    reasoning: str | None
     delta: str | None
     tool_calls: str | None
     done: str | None
@@ -114,6 +115,7 @@ class OpenAICompatible(ModelRequester):
         "content_mapping": {
             "id": "id",
             "role": "choices[0].delta.role",
+            "reasoning": "choices[0].delta.reasoning_content",
             "delta": "choices[0].delta.content",
             "tool_calls": "choices[0].delta.tool_calls",
             "done": None,
@@ -124,6 +126,7 @@ class OpenAICompatible(ModelRequester):
             },
             "extra_done": None,
         },
+        "yield_extra_content_separately": True,
         "content_mapping_style": "dot",
         "timeout": {
             "connect": 30.0,
@@ -505,6 +508,7 @@ class OpenAICompatible(ModelRequester):
     async def broadcast_response(self, response_generator: AsyncGenerator) -> "AgentlyResponseGenerator":
         meta = {}
         message_record = {}
+        reasoning_buffer = ""
         content_buffer = ""
 
         content_mapping = cast(
@@ -516,6 +520,7 @@ class OpenAICompatible(ModelRequester):
         )
         id_mapping = content_mapping["id"]
         role_mapping = content_mapping["role"]
+        reasoning_mapping = content_mapping["reasoning"]
         delta_mapping = content_mapping["delta"]
         tool_calls_mapping = content_mapping["tool_calls"]
         done_mapping = content_mapping["done"]
@@ -523,6 +528,7 @@ class OpenAICompatible(ModelRequester):
         finish_reason_mapping = content_mapping["finish_reason"]
         extra_delta_mapping = content_mapping["extra_delta"]
         extra_done_mapping = content_mapping["extra_done"]
+        yield_extra_content_separately = self.plugin_settings.get("yield_extra_content_separately", True)
 
         content_mapping_style = str(self.plugin_settings.get("content_mapping_style"))
         if content_mapping_style not in ("dot", "slash"):
@@ -552,6 +558,15 @@ class OpenAICompatible(ModelRequester):
                     )
                     if role:
                         meta.update({"role": role})
+                if reasoning_mapping:
+                    reasoning = DataLocator.locate_path_in_dict(
+                        loaded_message,
+                        reasoning_mapping,
+                        style=content_mapping_style,
+                    )
+                    if reasoning:
+                        reasoning_buffer += str(reasoning)
+                        yield "reasoning_delta", reasoning
                 if delta_mapping:
                     delta = DataLocator.locate_path_in_dict(
                         loaded_message,
@@ -578,6 +593,8 @@ class OpenAICompatible(ModelRequester):
                         )
                         if extra_value:
                             yield "extra", {extra_key: extra_value}
+                            if yield_extra_content_separately:
+                                yield extra_key, extra_value  # type: ignore
             else:
                 done_content = None
                 if self.model_type == "embeddings" and done_mapping is None:
@@ -593,6 +610,17 @@ class OpenAICompatible(ModelRequester):
                     yield "done", done_content
                 else:
                     yield "done", content_buffer
+                reasoning_content = None
+                if reasoning_mapping:
+                    reasoning_content = DataLocator.locate_path_in_dict(
+                        message_record,
+                        reasoning_mapping,
+                        style=content_mapping_style,
+                    )
+                if reasoning_content:
+                    yield "reasoning_done", reasoning_content
+                else:
+                    yield "reasoning_done", reasoning_buffer
                 match self.model_type:
                     case "embeddings":
                         yield "original_done", message_record

{agently-4.0.6.10 → agently-4.0.7}/agently/builtins/plugins/ResponseParser/AgentlyResponseParser.py

@@ -282,8 +282,10 @@ class AgentlyResponseParser(ResponseParser):
 
     async def get_async_generator(
         self,
-        type: Literal['all', 'delta', 'typed_delta', 'original', 'instant', 'streaming_parse'] | None = "delta",
-        content: Literal['all', 'delta', 'typed_delta', 'original', 'instant', 'streaming_parse'] | None = "delta",
+        type: Literal['all', 'delta', 'specific', 'original', 'instant', 'streaming_parse'] | None = "delta",
+        content: Literal['all', 'delta', 'specific', 'original', 'instant', 'streaming_parse'] | None = "delta",
+        *,
+        specific: list[str] | str | None = ["reasoning_delta", "delta", "reasoning_done", "done", "tool_calls"],
     ) -> AsyncGenerator:
         await self._ensure_consumer()
         parsed_generator = cast(GeneratorConsumer, self._response_consumer).get_async_generator()
@@ -300,11 +302,13 @@ class AgentlyResponseParser(ResponseParser):
                 case "delta":
                     if event == "delta":
                         yield data
-                case "typed_delta":
-                    if event == "delta":
-                        yield "delta", data
-                    elif event == "tool_calls":
-                        yield "tool_calls", data
+                case "specific":
+                    if specific is None:
+                        specific = ["delta"]
+                    elif isinstance(specific, str):
+                        specific = [specific]
+                    if event in specific:
+                        yield event, data
                 case "instant" | "streaming_parse":
                     if self._streaming_json_parser is not None:
                         streaming_parsed = None
@@ -325,8 +329,10 @@ class AgentlyResponseParser(ResponseParser):
 
     def get_generator(
         self,
-        type: Literal['all', 'delta', 'typed_delta', 'original', 'instant', 'streaming_parse'] | None = "delta",
-        content: Literal['all', 'delta', 'typed_delta', 'original', 'instant', 'streaming_parse'] | None = "delta",
+        type: Literal['all', 'delta', 'specific', 'original', 'instant', 'streaming_parse'] | None = "delta",
+        content: Literal['all', 'delta', 'specific', 'original', 'instant', 'streaming_parse'] | None = "delta",
+        *,
+        specific: list[str] | str | None = ["reasoning_delta", "delta", "reasoning_done", "done", "tool_calls"],
     ) -> Generator:
         asyncio.run(self._ensure_consumer())
         parsed_generator = cast(GeneratorConsumer, self._response_consumer).get_generator()
@@ -343,11 +349,13 @@ class AgentlyResponseParser(ResponseParser):
                 case "delta":
                     if event == "delta":
                         yield data
-                case "typed_delta":
-                    if event == "delta":
-                        yield "delta", data
-                    elif event == "tool_calls":
-                        yield "tool_calls", data
+                case "specific":
+                    if specific is None:
+                        specific = ["delta"]
+                    elif isinstance(specific, str):
+                        specific = [specific]
+                    if event in specific:
+                        yield event, data
                 case "instant" | "streaming_parse":
                     if self._streaming_json_parser is not None:
                         streaming_parsed = None

{agently-4.0.6.10 → agently-4.0.7}/agently/core/Agent.py

@@ -66,6 +66,8 @@ class BaseAgent:
         self.request_prompt = self.request.prompt
         self.prompt = self.request_prompt
 
+        self.set_settings = self.settings.set_settings
+
         self.get_response = self.request.get_response
         self.get_result = self.request.get_result
         self.get_meta = self.request.get_meta
@@ -83,10 +85,6 @@ class BaseAgent:
         self.async_start = self.async_get_data
 
     # Basic Methods
-    def set_settings(self, key: str, value: "SerializableValue"):
-        self.settings.set_settings(key, value)
-        return self
-
     def set_agent_prompt(
         self,
         key: "PromptStandardSlot | str",

{agently-4.0.6.10 → agently-4.0.7}/agently/core/ModelRequest.py

@@ -425,13 +425,15 @@ class ModelRequest:
             parent=parent_extension_handlers,
         )
 
+        self.set_settings = self.settings.set_settings
+
         self.get_meta = FunctionShifter.syncify(self.async_get_meta)
         self.get_text = FunctionShifter.syncify(self.async_get_text)
         self.get_data = FunctionShifter.syncify(self.async_get_data)
         self.get_data_object = FunctionShifter.syncify(self.async_get_data_object)
 
-    def set_settings(self, key: str, value: "SerializableValue"):
-        self.settings.set_settings(key, value)
+        self.start = self.get_data
+        self.async_start = self.async_get_data
 
     def set_prompt(
         self,
@@ -590,58 +592,84 @@ class ModelRequest:
     def get_generator(
         self,
         type: Literal["instant", "streaming_parse"],
+        *,
+        specific: list[str] | str | None = ["reasoning_delta", "delta", "reasoning_done", "done", "tool_calls"],
     ) -> Generator["StreamingData", None, None]: ...
 
     @overload
     def get_generator(
         self,
         type: Literal["all"],
+        *,
+        specific: list[str] | str | None = ["reasoning_delta", "delta", "reasoning_done", "done", "tool_calls"],
     ) -> Generator[tuple[str, Any], None, None]: ...
 
     @overload
     def get_generator(
         self,
-        type: Literal["delta", "typed_delta", "original"],
+        type: Literal["delta", "specific", "original"],
+        *,
+        specific: list[str] | str | None = ["reasoning_delta", "delta", "reasoning_done", "done", "tool_calls"],
     ) -> Generator[str, None, None]: ...
 
     @overload
     def get_generator(
         self,
-        type: Literal["all", "original", "delta", "typed_delta", "instant", "streaming_parse"] | None = "delta",
+        type: Literal["all", "original", "delta", "specific", "instant", "streaming_parse"] | None = "delta",
+        *,
+        specific: list[str] | str | None = ["reasoning_delta", "delta", "reasoning_done", "done", "tool_calls"],
     ) -> Generator: ...
 
     def get_generator(
         self,
-        type: Literal["all", "original", "delta", "typed_delta", "instant", "streaming_parse"] | None = "delta",
+        type: Literal["all", "original", "delta", "specific", "instant", "streaming_parse"] | None = "delta",
+        *,
+        specific: list[str] | str | None = ["reasoning_delta", "delta", "reasoning_done", "done", "tool_calls"],
     ) -> Generator:
-        return self.get_response().get_generator(type=type)
+        return self.get_response().get_generator(
+            type=type,
+            specific=specific,
+        )
 
     @overload
     def get_async_generator(
         self,
         type: Literal["instant", "streaming_parse"],
+        *,
+        specific: list[str] | str | None = ["reasoning_delta", "delta", "reasoning_done", "done", "tool_calls"],
     ) -> AsyncGenerator["StreamingData", None]: ...
 
     @overload
     def get_async_generator(
         self,
         type: Literal["all"],
+        *,
+        specific: list[str] | str | None = ["reasoning_delta", "delta", "reasoning_done", "done", "tool_calls"],
     ) -> AsyncGenerator[tuple[str, Any], None]: ...
 
     @overload
     def get_async_generator(
         self,
-        type: Literal["delta", "typed_delta", "original"],
+        type: Literal["delta", "specific", "original"],
+        *,
+        specific: list[str] | str | None = ["reasoning_delta", "delta", "reasoning_done", "done", "tool_calls"],
     ) -> AsyncGenerator[str, None]: ...
 
     @overload
     def get_async_generator(
         self,
-        type: Literal["all", "original", "delta", "typed_delta", "instant", "streaming_parse"] | None = "delta",
+        type: Literal["all", "original", "delta", "specific", "instant", "streaming_parse"] | None = "delta",
+        *,
+        specific: list[str] | str | None = ["reasoning_delta", "delta", "reasoning_done", "done", "tool_calls"],
     ) -> AsyncGenerator: ...
 
     def get_async_generator(
         self,
-        type: Literal["all", "original", "delta", "typed_delta", "instant", "streaming_parse"] | None = "delta",
+        type: Literal["all", "original", "delta", "specific", "instant", "streaming_parse"] | None = "delta",
+        *,
+        specific: list[str] | str | None = ["reasoning_delta", "delta", "reasoning_done", "done", "tool_calls"],
     ) -> AsyncGenerator:
-        return self.get_response().get_async_generator(type=type)
+        return self.get_response().get_async_generator(
+            type=type,
+            specific=specific,
+        )

{agently-4.0.6.10 → agently-4.0.7}/agently/core/PluginManager.py

@@ -36,6 +36,8 @@ class PluginManager:
             parent=parent.plugins if parent is not None else None,
         )
 
+        self.set_settings = self.settings.set_settings
+
     def register(
         self,
         plugin_type: AgentlyPluginType,

{agently-4.0.6.10 → agently-4.0.7}/agently/core/Prompt.py

@@ -14,9 +14,9 @@
 
 import re
 from textwrap import dedent
-from typing import Any, Literal, Mapping, Sequence, TYPE_CHECKING, cast, overload, TypeVar
+from typing import Any, Literal, TYPE_CHECKING, cast, overload, TypeVar
 
-from agently.utils import RuntimeData, Settings
+from agently.utils import RuntimeData, Settings, DataFormatter
 
 if TYPE_CHECKING:
     from agently.types.data.prompt import ChatMessage, PromptStandardSlot
@@ -80,8 +80,6 @@ class Prompt(RuntimeData):
     ):
         super().__init__(prompt_dict, parent=parent_prompt, name=name)
 
-        self._placeholder_pattern = re.compile(r"\$\{\s*([^}]+?)\s*\}")
-
         self.settings = Settings(
             name="Prompt-Settings",
             parent=parent_settings,
@@ -103,42 +101,6 @@ class Prompt(RuntimeData):
         self.to_json_prompt = self.prompt_generator.to_json_prompt
         self.to_yaml_prompt = self.prompt_generator.to_yaml_prompt
 
-    def _substitute_placeholder(self, obj: T, variable_mappings: dict[str, Any]) -> T | Any:
-        if not isinstance(variable_mappings, dict):
-            raise TypeError(f"Variable mappings require a dictionary but got: { variable_mappings }")
-
-        if isinstance(obj, str):
-            full_match = self._placeholder_pattern.fullmatch(obj)
-            if full_match:
-                key = full_match.group(1).strip()
-                return variable_mappings.get(key, obj)
-            else:
-
-                def replacer(match):
-                    key = match.group(1).strip()
-                    return str(variable_mappings.get(key, match.group(0)))
-
-                return self._placeholder_pattern.sub(replacer, obj)
-
-        if isinstance(obj, Mapping):
-            return {
-                self._substitute_placeholder(key, variable_mappings): self._substitute_placeholder(
-                    value, variable_mappings
-                )
-                for key, value in obj.items()
-            }
-
-        if isinstance(obj, Sequence) and not isinstance(obj, (str, bytes, bytearray)):
-            if isinstance(obj, tuple):
-                return tuple(self._substitute_placeholder(value, variable_mappings) for value in obj)
-            else:
-                return [self._substitute_placeholder(value, variable_mappings) for value in obj]
-
-        if isinstance(obj, set):
-            return {self._substitute_placeholder(value, variable_mappings) for value in obj}
-
-        return obj
-
     @overload
     def set(
         self,
@@ -165,8 +127,8 @@ class Prompt(RuntimeData):
             value = dedent(value.strip())
         if mappings is not None:
             super().set(
-                self._substitute_placeholder(key, mappings),
-                self._substitute_placeholder(value, mappings),
+                DataFormatter.substitute_placeholder(key, mappings),
+                DataFormatter.substitute_placeholder(value, mappings),
             )
         else:
             super().set(key, value)
@@ -178,7 +140,7 @@ class Prompt(RuntimeData):
     ):
         if mappings is not None:
             super().update(
-                self._substitute_placeholder(new, mappings),
+                DataFormatter.substitute_placeholder(new, mappings),
             )
         else:
             super().update(new)
@@ -193,8 +155,8 @@ class Prompt(RuntimeData):
             value = dedent(value.strip())
         if mappings is not None:
             super().append(
-                self._substitute_placeholder(key, mappings),
-                self._substitute_placeholder(value, mappings),
+                DataFormatter.substitute_placeholder(key, mappings),
+                DataFormatter.substitute_placeholder(value, mappings),
             )
         else:
             super().append(key, value)

{agently-4.0.6.10 → agently-4.0.7}/agently/core/TriggerFlow/BluePrint.py

@@ -132,6 +132,7 @@ class TriggerFlowBluePrint:
         *,
         execution_id: str | None = None,
         skip_exceptions: bool = False,
+        concurrency: int | None = None,
     ):
         handlers_snapshot: TriggerFlowAllHandlers = {
             "event": {k: v.copy() for k, v in self._handlers["event"].items()},
@@ -143,6 +144,7 @@ class TriggerFlowBluePrint:
             trigger_flow=trigger_flow,
             id=execution_id,
             skip_exceptions=skip_exceptions,
+            concurrency=concurrency,
         )
 
     def copy(self, *, name: str | None = None):

{agently-4.0.6.10 → agently-4.0.7}/agently/core/TriggerFlow/Chunk.py

@@ -30,9 +30,10 @@ class TriggerFlowChunk:
         *,
         name: str | None = None,
     ):
-        self.name = name if name is not None else uuid.uuid4().hex
+        self.id = uuid.uuid4().hex
+        self.name = name if name is not None else self.id
         self._handler = handler
-        self.trigger = f"Chunk[{ handler.__name__ }]-{ self.name }"
+        self.trigger = f"Chunk[{ handler.__name__ }]-{ self.id }"
 
     async def async_call(self, data: "TriggerFlowEventData"):
         result = await FunctionShifter.asyncify(self._handler)(data)

{agently-4.0.6.10 → agently-4.0.7}/agently/core/TriggerFlow/Execution.py

@@ -16,6 +16,7 @@
 import uuid
 import asyncio
 import warnings
+from contextvars import ContextVar
 
 from typing import Any, Literal, TYPE_CHECKING
 
@@ -37,6 +38,7 @@ class TriggerFlowExecution:
         trigger_flow: "TriggerFlow",
         id: str | None = None,
         skip_exceptions: bool = False,
+        concurrency: int | None = None,
     ):
         # Basic Attributions
         self.id = id if id is not None else uuid.uuid4().hex
@@ -45,6 +47,11 @@ class TriggerFlowExecution:
         self._runtime_data = RuntimeData()
         self._system_runtime_data = RuntimeData()
         self._skip_exceptions = skip_exceptions
+        self._concurrency_semaphore = asyncio.Semaphore(concurrency) if concurrency and concurrency > 0 else None
+        self._concurrency_depth = ContextVar(
+            f"trigger_flow_execution_concurrency_depth_{ self.id }",
+            default=0,
+        )
 
         # Settings
         self.settings = Settings(
@@ -126,19 +133,29 @@ class TriggerFlowExecution:
                     },
                     self.settings,
                 )
-                tasks.append(
-                    asyncio.ensure_future(
-                        FunctionShifter.asyncify(handler)(
-                            TriggerFlowEventData(
-                                trigger_event=trigger_event,
-                                trigger_type=trigger_type,
-                                value=value,
-                                execution=self,
-                                _layer_marks=_layer_marks,
-                            )
-                        )
+                async def run_handler(handler_func):
+                    if self._concurrency_semaphore is None:
+                        return await handler_func
+                    depth = self._concurrency_depth.get()
+                    token = self._concurrency_depth.set(depth + 1)
+                    try:
+                        if depth > 0:
+                            return await handler_func
+                        async with self._concurrency_semaphore:
+                            return await handler_func
+                    finally:
+                        self._concurrency_depth.reset(token)
+
+                handler_task = FunctionShifter.asyncify(handler)(
+                    TriggerFlowEventData(
+                        trigger_event=trigger_event,
+                        trigger_type=trigger_type,
+                        value=value,
+                        execution=self,
+                        _layer_marks=_layer_marks,
                     )
                 )
+                tasks.append(asyncio.ensure_future(run_handler(handler_task)))
 
         if tasks:
             await asyncio.gather(*tasks, return_exceptions=self._skip_exceptions)