agently 4.0.6.9__py3-none-any.whl → 4.0.6.11__py3-none-any.whl

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/core/TriggerFlow/Chunk.py

@@ -30,16 +30,17 @@ 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)
-        await data.async_emit(self.trigger, result, layer_marks=data.layer_marks.copy())
+        await data.async_emit(self.trigger, result, _layer_marks=data._layer_marks.copy())
         return result
 
     def call(self, data: "TriggerFlowEventData"):
         result = FunctionShifter.syncify(self._handler)(data)
-        data.emit(self.trigger, result, layer_marks=data.layer_marks.copy())
+        data.emit(self.trigger, result, _layer_marks=data._layer_marks.copy())
         return result

agently/core/TriggerFlow/Execution.py

@@ -97,7 +97,7 @@ class TriggerFlowExecution:
         self,
         trigger_event: str,
         value: Any = None,
-        layer_marks: list[str] | None = None,
+        _layer_marks: list[str] | None = None,
         *,
         trigger_type: Literal["event", "runtime_data", "flow_data"] = "event",
     ):
@@ -134,7 +134,7 @@ class TriggerFlowExecution:
                                 trigger_type=trigger_type,
                                 value=value,
                                 execution=self,
-                                layer_marks=layer_marks,
+                                _layer_marks=_layer_marks,
                             )
                         )
                     )

agently/core/TriggerFlow/TriggerFlow.py

@@ -51,6 +51,7 @@ class TriggerFlow:
         self._skip_exceptions = skip_exceptions
         self._executions: dict[str, "TriggerFlowExecution"] = {}
         self._start_process = TriggerFlowProcess(
+            flow_chunk=self.chunk,
             trigger_event="START",
             blue_print=self._blue_print,
             block_data=TriggerFlowBlockData(
@@ -60,6 +61,8 @@ class TriggerFlow:
 
         self.chunks = self._blue_print.chunks
 
+        self.set_settings = self.settings.set_settings
+
         self.get_flow_data = self._flow_data.get
         self.set_flow_data = FunctionShifter.syncify(self.async_set_flow_data)
         self.append_flow_data = FunctionShifter.syncify(self.async_append_flow_data)
@@ -74,10 +77,6 @@ class TriggerFlow:
         self.start_execution = FunctionShifter.syncify(self.async_start_execution)
         self.start = FunctionShifter.syncify(self.async_start)
 
-    def set_settings(self, key: str, value: "SerializableValue"):
-        self.settings.set_settings(key, value)
-        return self
-
     @overload
     def chunk(self, handler_or_name: "TriggerFlowHandler") -> TriggerFlowChunk: ...
 

agently/core/TriggerFlow/process/BaseProcess.py

@@ -17,7 +17,7 @@ import uuid
 from asyncio import Event
 from threading import Lock
 
-from typing import Any, Literal, TYPE_CHECKING, overload
+from typing import Callable, Any, Literal, TYPE_CHECKING, overload, cast
 from typing_extensions import Self
 
 
@@ -31,15 +31,18 @@ from agently.types.trigger_flow import TriggerFlowBlockData
 
 
 class TriggerFlowBaseProcess:
+
     def __init__(
         self,
         *,
+        flow_chunk,
         trigger_event: str,
         blue_print: "TriggerFlowBluePrint",
         block_data: "TriggerFlowBlockData",
         trigger_type: Literal["event", "runtime_data", "flow_data"] = "event",
         **options,
     ):
+        self._flow_chunk = flow_chunk
         self.trigger_event = trigger_event
         self.trigger_type: Literal["event", "runtime_data", "flow_data"] = trigger_type
         self._blue_print = blue_print
@@ -55,6 +58,7 @@ class TriggerFlowBaseProcess:
         **options,
     ):
         return type(self)(
+            flow_chunk=self._flow_chunk,
             trigger_event=trigger_event,
             trigger_type=trigger_type,
             blue_print=blue_print,
@@ -112,8 +116,12 @@ class TriggerFlowBaseProcess:
         if isinstance(trigger_or_triggers, TriggerFlowChunk):
             trigger_or_triggers = trigger_or_triggers.trigger
         if isinstance(trigger_or_triggers, str):
+            if trigger_or_triggers in self._blue_print.chunks:
+                trigger = self._blue_print.chunks[trigger_or_triggers].trigger
+            else:
+                trigger = trigger_or_triggers
             return self._new(
-                trigger_event=trigger_or_triggers,
+                trigger_event=trigger,
                 trigger_type="event",
                 blue_print=self._blue_print,
                 block_data=TriggerFlowBlockData(
@@ -178,7 +186,7 @@ class TriggerFlowBaseProcess:
                                 if mode == "simple_or"
                                 else (data.trigger_type, data.trigger_event, data.value)
                             ),
-                            layer_marks=data.layer_marks.copy(),
+                            _layer_marks=data._layer_marks.copy(),
                         )
                     case "and":
                         if data.trigger_type in values and data.trigger_event in values[trigger_type]:  # type: ignore
@@ -191,7 +199,7 @@ class TriggerFlowBaseProcess:
                         await data.async_emit(
                             when_trigger,
                             values,
-                            layer_marks=data.layer_marks.copy(),
+                            _layer_marks=data._layer_marks.copy(),
                         )
 
             for trigger_type, trigger_event_dict in values.items():
@@ -213,15 +221,22 @@ class TriggerFlowBaseProcess:
 
     def to(
         self,
-        chunk: "TriggerFlowChunk | TriggerFlowHandler | str",
+        chunk: "TriggerFlowChunk | TriggerFlowHandler | str | tuple[str, TriggerFlowHandler]",
         side_branch: bool = False,
+        name: str | None = None,
     ):
         if isinstance(chunk, str):
             if chunk in self._blue_print.chunks:
                 chunk = self._blue_print.chunks[chunk]
             else:
                 raise NotImplementedError(f"Cannot find chunk named '{ chunk }'")
-        chunk = TriggerFlowChunk(chunk) if callable(chunk) else chunk
+        elif isinstance(chunk, tuple):
+            chunk_name = chunk[0]
+            chunk_func = chunk[1]
+            chunk = self._flow_chunk(chunk_name)(chunk_func)
+        else:
+            chunk = self._flow_chunk(name or chunk.__name__)(chunk) if callable(chunk) else chunk
+        assert isinstance(chunk, TriggerFlowChunk)
         self._blue_print.add_handler(
             self.trigger_type,
             self.trigger_event,
@@ -235,34 +250,51 @@ class TriggerFlowBaseProcess:
             **self._options,
         )
 
-    def side_branch(self, chunk: "TriggerFlowChunk | TriggerFlowHandler"):
-        return self.to(chunk, side_branch=True)
+    def side_branch(
+        self,
+        chunk: "TriggerFlowChunk | TriggerFlowHandler",
+        *,
+        name: str | None = None,
+    ):
+        return self.to(
+            chunk,
+            side_branch=True,
+            name=name,
+        )
 
     def batch(
         self,
-        *chunks: "TriggerFlowChunk | TriggerFlowHandler",
+        *chunks: "TriggerFlowChunk | TriggerFlowHandler | tuple[str, TriggerFlowHandler]",
         side_branch: bool = False,
     ):
         batch_trigger = f"Batch-{ uuid.uuid4().hex }"
         results = {}
-        chunks_to_wait = {}
+        triggers_to_wait = {}
+        trigger_to_chunk_name = {}
 
         async def wait_all_chunks(data: "TriggerFlowEventData"):
-            if data.event in chunks_to_wait:
-                results[data.event] = data.value
-                chunks_to_wait[data.event] = True
-            for done in chunks_to_wait.values():
+            if data.event in triggers_to_wait:
+                results[trigger_to_chunk_name[data.event]] = data.value
+                triggers_to_wait[data.event] = True
+            for done in triggers_to_wait.values():
                 if done is False:
                     return
             await data.async_emit(
                 batch_trigger,
                 results,
-                layer_marks=data.layer_marks.copy(),
+                _layer_marks=data._layer_marks.copy(),
             )
 
         for chunk in chunks:
-            chunk = TriggerFlowChunk(chunk) if callable(chunk) else chunk
-            chunks_to_wait[chunk.name] = False
+            if isinstance(chunk, tuple):
+                chunk_name = chunk[0]
+                chunk_func = chunk[1]
+                chunk = self._flow_chunk(chunk_name)(chunk_func)
+            else:
+                chunk = self._flow_chunk(chunk.__name__)(chunk) if callable(chunk) else chunk
+            triggers_to_wait[chunk.trigger] = False
+            trigger_to_chunk_name[chunk.trigger] = chunk.name
+            results[chunk.name] = None
             self._blue_print.add_handler(
                 self.trigger_type,
                 self.trigger_event,
@@ -299,13 +331,13 @@ class TriggerFlowBaseProcess:
                 await data.async_emit(
                     collect_trigger,
                     self._block_data.global_data.get(f"collections.{ collection_name}"),
-                    layer_marks=data.layer_marks.copy(),
+                    _layer_marks=data._layer_marks.copy(),
                 )
             elif mode == "filled_then_empty":
                 await data.async_emit(
                     collect_trigger,
                     self._block_data.global_data.get(f"collections.{ collection_name}"),
-                    layer_marks=data.layer_marks.copy(),
+                    _layer_marks=data._layer_marks.copy(),
                 )
                 del self._block_data.global_data[f"collections.{ collection_name}"]
 

agently/core/TriggerFlow/process/ForEachProcess.py

@@ -49,7 +49,7 @@ class TriggerFlowForEachProcess(TriggerFlowBaseProcess):
                         data.async_emit(
                             send_item_trigger,
                             item,
-                            data.layer_marks.copy(),
+                            data._layer_marks.copy(),
                         )
                     )
                     data.layer_out()
@@ -62,7 +62,7 @@ class TriggerFlowForEachProcess(TriggerFlowBaseProcess):
                 await data.async_emit(
                     send_item_trigger,
                     data.value,
-                    data.layer_marks.copy(),
+                    data._layer_marks.copy(),
                 )
                 data.layer_out()
 
@@ -103,7 +103,7 @@ class TriggerFlowForEachProcess(TriggerFlowBaseProcess):
                 await data.async_emit(
                     end_for_each_trigger,
                     list(for_each_results[for_each_instance_id].values()),
-                    data.layer_marks.copy(),
+                    data._layer_marks.copy(),
                 )
                 for_each_results.delete(for_each_instance_id)
 

agently/core/TriggerFlow/process/MatchCaseProcess.py

@@ -58,7 +58,7 @@ class TriggerFlowMatchCaseProcess(TriggerFlowBaseProcess):
                         await data.async_emit(
                             f"Match-{ match_id }-Case-{ case_id }",
                             data.value,
-                            layer_marks=data.layer_marks.copy(),
+                            _layer_marks=data._layer_marks.copy(),
                         )
                         return
                     elif mode == "hit_all":
@@ -71,7 +71,7 @@ class TriggerFlowMatchCaseProcess(TriggerFlowBaseProcess):
                             data.async_emit(
                                 f"Match-{ match_id }-Case-{ case_id }",
                                 data.value,
-                                layer_marks=data.layer_marks.copy(),
+                                _layer_marks=data._layer_marks.copy(),
                             )
                         )
                         data.layer_out()
@@ -81,13 +81,13 @@ class TriggerFlowMatchCaseProcess(TriggerFlowBaseProcess):
                     await data.async_emit(
                         f"Match-{ match_id }-Else",
                         data.value,
-                        layer_marks=data.layer_marks.copy(),
+                        _layer_marks=data._layer_marks.copy(),
                     )
                 else:
                     await data.async_emit(
                         f"Match-{ match_id }-Result",
                         data.value,
-                        layer_marks=data.layer_marks.copy(),
+                        _layer_marks=data._layer_marks.copy(),
                     )
 
         self.to(match_case)
@@ -164,7 +164,7 @@ class TriggerFlowMatchCaseProcess(TriggerFlowBaseProcess):
                 await data.async_emit(
                     f"Match-{ match_id }-Result",
                     list(match_results.values()),
-                    layer_marks=data.layer_marks.copy(),
+                    _layer_marks=data._layer_marks.copy(),
                 )
                 del data._system_runtime_data[f"match_results.{ data.upper_layer_mark }"]
             else:
@@ -172,7 +172,7 @@ class TriggerFlowMatchCaseProcess(TriggerFlowBaseProcess):
                 await data.async_emit(
                     f"Match-{ match_id }-Result",
                     data.value,
-                    layer_marks=data.layer_marks.copy(),
+                    _layer_marks=data._layer_marks.copy(),
                 )
 
         for trigger in branch_ends:

agently/integrations/chromadb.py

@@ -1,3 +1,18 @@
+# Copyright 2023-2025 AgentEra(Agently.Tech)
+#
+# 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.
+
+
 from agently.utils import LazyImport
 
 LazyImport.import_package("chromadb")

agently/types/data/response.py

@@ -24,7 +24,16 @@ if TYPE_CHECKING:
     from agently.types.data.serializable import SerializableValue
 
 AgentlyModelResponseEvent = Literal[
-    "error", "original_delta", "delta", "tool_calls", "original_done", "done", "meta", "extra"
+    "error",
+    "original_delta",
+    "reasoning_delta",
+    "delta",
+    "tool_calls",
+    "original_done",
+    "reasoning_done",
+    "done",
+    "meta",
+    "extra",
 ]
 
 AgentlyModelResponseMessage: TypeAlias = tuple[AgentlyModelResponseEvent, Any]

agently/types/plugins/ResponseParser.py

@@ -77,29 +77,39 @@ class ResponseParser(AgentlyPlugin, Protocol):
     def get_async_generator(
         self,
         type: Literal["instant", "streaming_parse"],
+        *,
+        specific: list[str] | str | None = None,
     ) -> AsyncGenerator["StreamingData", None]: ...
 
     @overload
     def get_async_generator(
         self,
         type: Literal["all"],
+        *,
+        specific: list[str] | str | None = None,
     ) -> 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 = None,
     ) -> 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 = None,
     ) -> 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 = None,
     ) -> AsyncGenerator:
         """
         'instant' is Agently v3 compatible for 'streaming_parse'
@@ -110,29 +120,39 @@ class ResponseParser(AgentlyPlugin, Protocol):
     def get_generator(
         self,
         type: Literal["instant", "streaming_parse"],
+        *,
+        specific: list[str] | str | None = None,
     ) -> Generator["StreamingData", None, None]: ...
 
     @overload
     def get_generator(
         self,
         type: Literal["all"],
+        *,
+        specific: list[str] | str | None = None,
     ) -> 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 = None,
     ) -> 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 = None,
     ) -> 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 = None,
     ) -> Generator:
         """
         'instant' is Agently v3 compatible for 'streaming_parse'

agently/types/trigger_flow/trigger_flow.py

@@ -43,7 +43,7 @@ class TriggerFlowEventData:
         trigger_type: Literal["event", "runtime_data", "flow_data"],
         value: Any,
         execution: "TriggerFlowExecution",
-        layer_marks: list[str] | None = None,
+        _layer_marks: list[str] | None = None,
     ):
         self.trigger_event = trigger_event
         self.trigger_type = trigger_type
@@ -51,7 +51,7 @@ class TriggerFlowEventData:
         self.type = trigger_type
         self.value = value
         self.execution_id = execution.id
-        self.layer_marks = layer_marks if layer_marks is not None else []
+        self._layer_marks = _layer_marks if _layer_marks is not None else []
         self.settings = execution.settings
 
         self.get_flow_data = execution.get_flow_data
@@ -84,17 +84,17 @@ class TriggerFlowEventData:
 
     @property
     def upper_layer_mark(self):
-        return self.layer_marks[-2] if len(self.layer_marks) > 1 else None
+        return self._layer_marks[-2] if len(self._layer_marks) > 1 else None
 
     @property
     def layer_mark(self):
-        return self.layer_marks[-1] if len(self.layer_marks) > 0 else None
+        return self._layer_marks[-1] if len(self._layer_marks) > 0 else None
 
     def layer_in(self):
-        self.layer_marks.append(uuid.uuid4().hex)
+        self._layer_marks.append(uuid.uuid4().hex)
 
     def layer_out(self):
-        self.layer_marks = self.layer_marks[:-1] if len(self.layer_marks) > 0 else []
+        self._layer_marks = self._layer_marks[:-1] if len(self._layer_marks) > 0 else []
 
 
 TriggerFlowHandler = Callable[[TriggerFlowEventData], Any]