agently 4.0.6.9__tar.gz → 4.0.6.10__tar.gz

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

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

{agently-4.0.6.9 → agently-4.0.6.10}/agently/builtins/hookers/SystemMessageHooker.py

@@ -17,6 +17,32 @@ from typing import TYPE_CHECKING
 
 from agently.types.plugins import EventHooker
 
+COLORS = {
+    "black": 30,
+    "red": 31,
+    "green": 32,
+    "yellow": 33,
+    "blue": 34,
+    "magenta": 35,
+    "cyan": 36,
+    "white": 37,
+    "gray": 90,
+}
+
+
+def color_text(text: str, color: str | None = None, bold: bool = False, underline: bool = False) -> str:
+    codes = []
+    if bold:
+        codes.append("1")
+    if underline:
+        codes.append("4")
+    if color and color in COLORS:
+        codes.append(str(COLORS[color]))
+    if not codes:
+        return text
+    return f"\x1b[{';'.join(codes)}m{text}\x1b[0m"
+
+
 if TYPE_CHECKING:
     from agently.types.data import EventMessage, AgentlySystemEvent
 
@@ -72,12 +98,18 @@ class SystemMessageHooker(EventHooker):
                             and SystemMessageHooker._current_meta["row_id"] == message_data["response_id"]
                             and SystemMessageHooker._current_meta["stage"] == content["stage"]
                         ):
-                            print(content["detail"], end="")
+                            print(color_text(content["detail"], color="gray"), end="", flush=True)
                         else:
-                            print(
-                                f"[Agent-{ message_data['agent_name'] }] - [Request-{ message_data['response_id'] }]\nStage: { content['stage'] }\nDetail:\n{ content['detail'] }",
-                                end="",
+                            header = color_text(
+                                f"[Agent-{ message_data['agent_name'] }] - [Request-{ message_data['response_id'] }]",
+                                color="blue",
+                                bold=True,
                             )
+                            stage_label = color_text("Stage:", color="cyan", bold=True)
+                            stage_val = color_text(content["stage"], color="yellow", underline=True)
+                            detail_label = color_text("Detail:\n", color="cyan", bold=True)
+                            detail = color_text(content["detail"], color="green")
+                            print(f"{header}\n{stage_label} {stage_val}\n{detail_label}{detail}", end="")
                             SystemMessageHooker._current_meta["table_name"] = message_data["agent_name"]
                             SystemMessageHooker._current_meta["row_id"] = message_data["response_id"]
                             SystemMessageHooker._current_meta["stage"] = content["stage"]
@@ -99,28 +131,40 @@ class SystemMessageHooker(EventHooker):
                         },
                     )
                     if settings["runtime.show_model_logs"]:
+                        header = color_text(
+                            f"[Agent-{ message_data['agent_name'] }] - [Response-{ message_data['response_id'] }]",
+                            color="blue",
+                            bold=True,
+                        )
+                        stage_label = color_text("Stage:", color="cyan", bold=True)
+                        stage_val = color_text(content["stage"], color="yellow", underline=True)
+                        detail_label = color_text("Detail:\n", color="cyan", bold=True)
+                        detail = color_text(f"{content['detail']}", color="gray")
                         await event_center.async_emit(
                             "log",
                             {
                                 "level": "INFO",
-                                "content": f"[Agent-{ message_data['agent_name'] }] - [Response-{ message_data['response_id'] }]\nStage: { content['stage'] }\nDetail:\n{ content['detail'] }",
+                                "content": f"{header}\n{stage_label} {stage_val}\n{detail_label}{detail}",
                             },
                         )
             case "TOOL":
                 if settings["runtime.show_tool_logs"]:
+                    tool_title = color_text("[Tool Using Result]:", color="blue", bold=True)
+                    tool_body = color_text(str(message.content["data"]), color="gray")
                     await event_center.async_emit(
                         "log",
                         {
                             "level": "INFO",
-                            "content": f"[Tool Using Result]:\n{ message.content['data'] }",
+                            "content": f"{tool_title}\n{tool_body}",
                         },
                     )
             case "TRIGGER_FLOW":
                 if settings["runtime.show_trigger_flow_logs"]:
+                    trigger = color_text(f"[TriggerFlow] { message.content['data'] }", color="yellow", bold=True)
                     await event_center.async_emit(
                         "log",
                         {
                             "level": "INFO",
-                            "content": f"[TriggerFlow] { message.content['data'] }",
+                            "content": trigger,
                         },
                     )

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

@@ -146,6 +146,10 @@ class OpenAICompatible(ModelRequester):
         self.model_type = cast(str, self.plugin_settings.get("model_type"))
         self._messenger = event_center.create_messenger(self.name)
 
+        # check if has attachment prompt
+        if self.prompt["attachment"]:
+            self.plugin_settings["rich_content"] = True
+
     @staticmethod
     def _on_register():
         pass

{agently-4.0.6.9 → agently-4.0.6.10}/agently/builtins/plugins/PromptGenerator/AgentlyPromptGenerator.py

@@ -725,10 +725,16 @@ class AgentlyPromptGenerator(PromptGenerator):
                             "$type": output_prompt_part[0],
                         }
                     case _:
-                        return {
-                            "$type": output_prompt_part[0],
-                            "$desc": ";".join(output_prompt_part[1:]),
-                        }
+                        desc_text = ";".join([item for item in output_prompt_part[1:] if item])
+                        if desc_text:
+                            return {
+                                "$type": output_prompt_part[0],
+                                "$desc": desc_text,
+                            }
+                        else:
+                            return {
+                                "$type": output_prompt_part[0],
+                            }
             else:
                 return list(output_prompt_part)
 

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

@@ -273,6 +273,19 @@ class BaseAgent:
             self.request.prompt.set("output", prompt, mappings)
         return self
 
+    def attachment(
+        self,
+        prompt: list[dict[str, Any]],
+        mappings: dict[str, Any] | None = None,
+        *,
+        always: bool = False,
+    ):
+        if always:
+            self.agent_prompt.set("attachment", prompt, mappings)
+        else:
+            self.request_prompt.set("attachment", prompt, mappings)
+        return self
+
     def options(
         self,
         options: dict[str, Any],

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

@@ -523,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,

{agently-4.0.6.9 → agently-4.0.6.10}/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-4.0.6.9 → agently-4.0.6.10}/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-4.0.6.9 → agently-4.0.6.10}/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-4.0.6.9 → agently-4.0.6.10}/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-4.0.6.9 → agently-4.0.6.10}/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-4.0.6.9 → agently-4.0.6.10}/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]

{agently-4.0.6.9 → agently-4.0.6.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agently"
-version = "4.0.6.9"
+version = "4.0.6.10"
 description = ""
 authors = [
     {name = "Agently Team",email = "developer@agently.tech"},