agently 4.0.6.5__py3-none-any.whl → 4.0.6.10__py3-none-any.whl

agently/core/ModelRequest.py

@@ -22,12 +22,13 @@ ContentKindTuple: TypeAlias = Literal["all", "delta", "original"]
 ContentKindStreaming: TypeAlias = Literal["instant", "streaming_parse"]
 
 from agently.core import Prompt, ExtensionHandlers
-from agently.utils import Settings, FunctionShifter, DataFormatter
+from agently.utils import Settings, FunctionShifter, DataFormatter, DataLocator
 
 if TYPE_CHECKING:
     from agently.core import PluginManager
     from agently.types.data import AgentlyModelResponseMessage, PromptStandardSlot, StreamingData, SerializableValue
     from agently.types.plugins import ModelRequester, ResponseParser
+    from pydantic import BaseModel
 
 
 class ModelResponseResult:
@@ -39,6 +40,7 @@ class ModelResponseResult:
         response_generator: AsyncGenerator["AgentlyModelResponseMessage", None],
         plugin_manager: "PluginManager",
         settings: Settings,
+        extension_handlers: ExtensionHandlers,
     ):
         self.agent_name = agent_name
         self.plugin_manager = plugin_manager
@@ -50,19 +52,145 @@ class ModelResponseResult:
                 str(self.settings["plugins.ResponseParser.activate"]),
             ),
         )
-        _response_parser = ResponseParser(agent_name, response_id, prompt, response_generator, self.settings)
+        self._response_id = response_id
+        self._extension_handlers = extension_handlers
+        self._response_parser = ResponseParser(agent_name, response_id, prompt, response_generator, self.settings)
         self.prompt = prompt
-        self.full_result_data = _response_parser.full_result_data
-        self.get_meta = _response_parser.get_meta
-        self.async_get_meta = _response_parser.async_get_meta
-        self.get_text = _response_parser.get_text
-        self.async_get_text = _response_parser.async_get_text
-        self.get_data = _response_parser.get_data
-        self.async_get_data = _response_parser.async_get_data
-        self.get_data_object = _response_parser.get_data_object
-        self.async_get_data_object = _response_parser.async_get_data_object
-        self.get_generator = _response_parser.get_generator
-        self.get_async_generator = _response_parser.get_async_generator
+        self.full_result_data = self._response_parser.full_result_data
+        self.get_meta = self._response_parser.get_meta
+        self.async_get_meta = self._response_parser.async_get_meta
+        self.get_text = self._response_parser.get_text
+        self.async_get_text = self._response_parser.async_get_text
+        # self.get_data = self._response_parser.get_data
+        # self.async_get_data = self._response_parser.async_get_data
+        # self.get_data_object = self._response_parser.get_data_object
+        # self.async_get_data_object = self._response_parser.async_get_data_object
+        self.get_data = FunctionShifter.syncify(self.async_get_data)
+        self.get_data_object = FunctionShifter.syncify(self.async_get_data_object)
+        self.get_generator = self._response_parser.get_generator
+        self.get_async_generator = self._response_parser.get_async_generator
+
+    @overload
+    async def async_get_data(
+        self,
+        *,
+        type: Literal['parsed'],
+        ensure_keys: list[str],
+        key_style: Literal["dot", "slash"] = "dot",
+        max_retries: int = 3,
+        raise_ensure_failure: bool = True,
+        _retry_count: int = 0,
+    ) -> dict[str, Any]: ...
+
+    @overload
+    async def async_get_data(
+        self,
+        *,
+        type: Literal['original', 'parsed', 'all'] = "parsed",
+        ensure_keys: list[str] | None = None,
+        key_style: Literal["dot", "slash"] = "dot",
+        max_retries: int = 3,
+        raise_ensure_failure: bool = True,
+        _retry_count: int = 0,
+    ) -> Any: ...
+
+    async def async_get_data(
+        self,
+        *,
+        type: Literal['original', 'parsed', 'all'] = "parsed",
+        ensure_keys: list[str] | None = None,
+        key_style: Literal["dot", "slash"] = "dot",
+        max_retries: int = 3,
+        raise_ensure_failure: bool = True,
+        _retry_count: int = 0,
+    ) -> Any:
+        if type == "parsed" and ensure_keys:
+            try:
+                data = await self._response_parser.async_get_data(type=type)
+                for ensure_key in ensure_keys:
+                    EMPTY = object()
+                    if DataLocator.locate_path_in_dict(data, ensure_key, key_style, default=EMPTY) is EMPTY:
+                        raise
+                return data
+            except:
+                from agently.base import async_system_message
+
+                await async_system_message(
+                    "MODEL_REQUEST",
+                    {
+                        "agent_name": self.agent_name,
+                        "response_id": self._response_id,
+                        "content": {
+                            "stage": "No Target Data in Response, Preparing Retry",
+                            "detail": f"\n[Response]: { await self.async_get_text() }\n"
+                            f"[Retried Times]: { _retry_count }",
+                        },
+                    },
+                    self.settings,
+                )
+
+                if _retry_count < max_retries:
+                    return await ModelResponse(
+                        self.agent_name,
+                        self.plugin_manager,
+                        self.settings,
+                        self.prompt,
+                        self._extension_handlers,
+                    ).result.async_get_data(
+                        type=type,
+                        ensure_keys=ensure_keys,
+                        key_style=key_style,
+                        max_retries=max_retries,
+                        raise_ensure_failure=raise_ensure_failure,
+                        _retry_count=_retry_count + 1,
+                    )
+                else:
+                    if raise_ensure_failure:
+                        raise ValueError(
+                            f"Can not generate ensure keys { ensure_keys } within { max_retries } retires."
+                        )
+                    else:
+                        return await self._response_parser.async_get_data(type=type)
+        return await self._response_parser.async_get_data(type=type)
+
+    @overload
+    async def async_get_data_object(
+        self,
+        *,
+        ensure_keys: list[str],
+        key_style: Literal["dot", "slash"] = "dot",
+        max_retries: int = 3,
+        raise_ensure_failure: bool = True,
+    ) -> "BaseModel": ...
+
+    @overload
+    async def async_get_data_object(
+        self,
+        *,
+        ensure_keys: None,
+        key_style: Literal["dot", "slash"] = "dot",
+        max_retries: int = 3,
+        raise_ensure_failure: bool = True,
+    ) -> "BaseModel | None": ...
+
+    async def async_get_data_object(
+        self,
+        *,
+        ensure_keys: list[str] | None = None,
+        key_style: Literal["dot", "slash"] = "dot",
+        max_retries: int = 3,
+        raise_ensure_failure: bool = True,
+    ):
+        if ensure_keys:
+            await self.async_get_data(
+                ensure_keys=ensure_keys,
+                key_style=key_style,
+                max_retries=max_retries,
+                _retry_count=0,
+                raise_ensure_failure=raise_ensure_failure,
+            )
+            return await self._response_parser.async_get_data_object()
+        return await self._response_parser.async_get_data_object()
 
 
 class ModelResponse:
@@ -98,8 +226,8 @@ class ModelResponse:
             self._get_response_generator(),
             self.plugin_manager,
             self.settings,
+            self.extension_handlers,
         )
-        self.get_result = self.result
         self.get_meta = self.result.get_meta
         self.async_get_meta = self.result.async_get_meta
         self.get_text = self.result.get_text
@@ -395,6 +523,15 @@ class ModelRequest:
         self.prompt.set("output", prompt, mappings)
         return self
 
+    def attachment(
+        self,
+        prompt: list[dict[str, Any]],
+        mappings: dict[str, Any] | None = None,
+    ):
+        self.prompt.set("attachment", prompt, mappings)
+        return self
+
+    # Response & Result
     def get_response(self):
         response = ModelResponse(
             self.agent_name,
@@ -406,7 +543,7 @@ class ModelRequest:
         self.prompt.clear()
         return response
 
-    async def get_result(self):
+    def get_result(self):
         return self.get_response().result
 
     async def async_get_meta(self):
@@ -419,11 +556,35 @@ class ModelRequest:
         self,
         *,
         type: Literal['original', 'parsed', 'all'] = "parsed",
+        ensure_keys: list[str] | None = None,
+        key_style: Literal["dot", "slash"] = "dot",
+        max_retries: int = 3,
+        raise_ensure_failure: bool = True,
     ):
-        return await self.get_response().async_get_data(type=type)
+        response = self.get_response()
+        return await response.async_get_data(
+            type=type,
+            ensure_keys=ensure_keys,
+            key_style=key_style,
+            max_retries=max_retries,
+            raise_ensure_failure=raise_ensure_failure,
+        )
 
-    async def async_get_data_object(self):
-        return await self.get_response().async_get_data_object()
+    async def async_get_data_object(
+        self,
+        *,
+        ensure_keys: list[str] | None = None,
+        key_style: Literal["dot", "slash"] = "dot",
+        max_retries: int = 3,
+        raise_ensure_failure: bool = True,
+    ):
+        response = self.get_response()
+        return await response.async_get_data_object(
+            ensure_keys=ensure_keys,
+            key_style=key_style,
+            max_retries=max_retries,
+            raise_ensure_failure=raise_ensure_failure,
+        )
 
     @overload
     def get_generator(

agently/core/Prompt.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import re
+from textwrap import dedent
 from typing import Any, Literal, Mapping, Sequence, TYPE_CHECKING, cast, overload, TypeVar
 
 from agently.utils import RuntimeData, Settings
@@ -98,6 +99,9 @@ class Prompt(RuntimeData):
         self.to_messages = self.prompt_generator.to_messages
         self.to_prompt_object = self.prompt_generator.to_prompt_object
         self.to_output_model = self.prompt_generator.to_output_model
+        self.to_serializable_prompt_data = self.prompt_generator.to_serializable_prompt_data
+        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):
@@ -157,6 +161,8 @@ class Prompt(RuntimeData):
         value: Any,
         mappings: dict[str, Any] | None = None,
     ):
+        if isinstance(value, str):
+            value = dedent(value.strip())
         if mappings is not None:
             super().set(
                 self._substitute_placeholder(key, mappings),
@@ -183,6 +189,8 @@ class Prompt(RuntimeData):
         value: Any,
         mappings: dict[str, Any] | None = None,
     ):
+        if isinstance(value, str):
+            value = dedent(value.strip())
         if mappings is not None:
             super().append(
                 self._substitute_placeholder(key, mappings),

agently/core/TriggerFlow/Chunk.py

@@ -36,10 +36,10 @@ class TriggerFlowChunk:
 
     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/process/BaseProcess.py

@@ -178,7 +178,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 +191,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 +213,21 @@ 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 = TriggerFlowChunk(chunk_func, name=chunk_name)
+        else:
+            chunk = TriggerFlowChunk(chunk, name=name) if callable(chunk) else chunk
         self._blue_print.add_handler(
             self.trigger_type,
             self.trigger_event,
@@ -235,34 +241,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 = TriggerFlowChunk(chunk_func, name=chunk_name)
+            else:
+                chunk = TriggerFlowChunk(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 +322,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: