Upload 5 files

aworld/runners/hook/agent_hooks.py

@@ -0,0 +1,35 @@
+# coding: utf-8
+# Copyright (c) 2025 inclusionAI.
+import abc
+from typing import AsyncGenerator
+from aworld.core.context.base import Context, AgentContext
+from aworld.core.event.base import Message
+from aworld.runners.hook.hook_factory import HookFactory
+from aworld.runners.hook.hooks import PostLLMCallHook, PreLLMCallHook
+from aworld.utils.common import convert_to_snake
+
+@HookFactory.register(name="PreLLMCallContextProcessHook",
+                      desc="PreLLMCallContextProcessHook")
+class PreLLMCallContextProcessHook(PreLLMCallHook):
+    """Process in the hook point of the pre_llm_call."""
+    __metaclass__ = abc.ABCMeta
+
+    def name(self):
+        return convert_to_snake("PreLLMCallContextProcessHook")
+    
+    async def exec(self, message: Message, context: Context = None) -> Message:
+        ''' context.get_agent_context(message.sender) ''' # get agent context
+        # and do something
+
+@HookFactory.register(name="PostLLMCallContextProcessHook",
+                      desc="PostLLMCallContextProcessHook")
+class PostLLMCallContextProcessHook(PostLLMCallHook):
+    """Process in the hook point of the post_llm_call."""
+    __metaclass__ = abc.ABCMeta
+
+    def name(self):
+        return convert_to_snake("PostLLMCallContextProcessHook")
+
+    async def exec(self, message: Message, context: Context = None) -> Message:
+        '''context.get_agent_context(message.sender)''' # get agent context
+        

aworld/runners/hook/hook_factory.py

@@ -0,0 +1,44 @@
+# coding: utf-8
+# Copyright (c) 2025 inclusionAI.
+import sys
+from typing import Dict, List
+
+from aworld.core.factory import Factory
+from aworld.logs.util import logger
+from aworld.runners.hook.hooks import Hook, StartHook, HookPoint
+
+
+class HookManager(Factory):
+    def __init__(self, type_name: str = None):
+        super(HookManager, self).__init__(type_name)
+
+    def __call__(self, name: str, **kwargs):
+        if name is None:
+            raise ValueError("hook name is None")
+
+        try:
+            if name in self._cls:
+                act = self._cls[name](**kwargs)
+            else:
+                raise RuntimeError("The hook was not registered.\nPlease confirm the package has been imported.")
+        except Exception:
+            err = sys.exc_info()
+            logger.warning(f"Failed to create hook with name {name}:\n{err[1]}")
+            act = None
+        return act
+
+    def hooks(self, name: str = None) -> Dict[str, List[Hook]]:
+        vals = list(filter(lambda s: not s.startswith('__'), dir(HookPoint)))
+        results = {val.lower(): [] for val in vals}
+
+        for k, v in self._cls.items():
+            hook = v()
+            if name and hook.point() != name:
+               continue
+
+            results.get(hook.point(), []).append(hook)
+
+        return results
+
+
+HookFactory = HookManager("hook_type")

aworld/runners/hook/hooks.py

@@ -0,0 +1,64 @@
+# coding: utf-8
+# Copyright (c) 2025 inclusionAI.
+import abc
+from typing import AsyncGenerator
+from aworld.core.context.base import Context, AgentContext
+from aworld.core.event.base import Message
+
+
+class HookPoint:
+    START = "start"
+    FINISHED = "finished"
+    ERROR = "error"
+    PRE_LLM_CALL = "pre_llm_call"
+    POST_LLM_CALL = "post_llm_call"
+
+class Hook:
+    """Runner hook."""
+    __metaclass__ = abc.ABCMeta
+
+    @abc.abstractmethod
+    def point(self):
+        """Hook point."""
+
+    @abc.abstractmethod
+    async def exec(self, message: Message, context: Context = None) -> Message:
+        """Execute hook function."""
+
+
+class StartHook(Hook):
+    """Process in the hook point of the start."""
+    __metaclass__ = abc.ABCMeta
+
+    def point(self):
+        return HookPoint.START
+
+
+class FinishedHook(Hook):
+    """Process in the hook point of the finished."""
+    __metaclass__ = abc.ABCMeta
+
+    def point(self):
+        return HookPoint.FINISHED
+
+
+class ErrorHook(Hook):
+    """Process in the hook point of the error."""
+    __metaclass__ = abc.ABCMeta
+
+    def point(self):
+        return HookPoint.ERROR
+
+class PreLLMCallHook(Hook):
+    """Process in the hook point of the pre_llm_call."""
+    __metaclass__ = abc.ABCMeta
+
+    def point(self):
+        return HookPoint.PRE_LLM_CALL
+        
+class PostLLMCallHook(Hook):
+    """Process in the hook point of the post_llm_call."""
+    __metaclass__ = abc.ABCMeta
+
+    def point(self):
+        return HookPoint.POST_LLM_CALL

aworld/runners/hook/template.py

@@ -0,0 +1,41 @@
+# coding: utf-8
+# Copyright (c) 2025 inclusionAI.
+
+HOOK_TEMPLATE = """
+import traceback
+
+from aworld.core.context.base import Context
+
+from aworld.core.event.base import Message, Constants, TopicType
+from aworld.runners.hook.hooks import *
+from aworld.runners.hook.hook_factory import HookFactory
+from aworld.logs.util import logger
+
+from aworld.utils.common import convert_to_snake
+
+
+@HookFactory.register(name="{name}",
+                      desc="{desc}")
+class {name}({point}Hook):
+    def name(self):
+        return convert_to_snake("{name}")
+
+    async def exec(self, message: Message) -> Message:
+        {func_import}import {func}
+        try:
+            res = {func}(message)
+            if not res:
+                raise ValueError(f"{func} no result return.")
+            return Message(payload=res,
+                           session_id=Context.instance().session_id,
+                           sender="{name}",
+                           category=Constants.TASK,
+                           topic="{topic}")
+        except Exception as e:
+            logger.error(traceback.format_exc())
+            return Message(payload=str(e),
+                           session_id=Context.instance().session_id,
+                           sender="{name}",
+                           category=Constants.TASK,
+                           topic=TopicType.ERROR)
+"""

aworld/runners/hook/utils.py

@@ -0,0 +1,55 @@
+# coding: utf-8
+# Copyright (c) 2025 inclusionAI.
+
+import importlib
+import inspect
+import os
+from typing import Callable, Any
+
+from aworld.runners.hook.template import HOOK_TEMPLATE
+from aworld.utils.common import snake_to_camel
+
+
+def hook(hook_point: str, name: str = None):
+    """Hook decorator.
+
+    NOTE: Hooks can be annotated, but they need to comply with the protocol agreement.
+    The input parameter of the hook function is `Message` type, and the @hook needs to specify `hook_point`.
+
+    Examples:
+        >>> @hook(hook_point=HookPoint.ERROR)
+        >>> def error_process(message: Message) -> Message | None:
+        >>>     print("process error")
+    The function `error_process` will be executed when an error message appears in the task,
+    you can choose return nothing or return a message.
+
+    Args:
+        hook_point: Hook point that wants to process the message.
+        name: Hook name.
+    """
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        # converts python function into a hoop with associated hoop point
+        func_import = func.__module__
+        if func_import == '__main__':
+            path = inspect.getsourcefile(func)
+            package = path.replace(os.getcwd(), '').replace('.py', '')
+            if package[0] == '/':
+                package = package[1:]
+            func_import = f"from {package} "
+        else:
+            func_import = f"from {func_import} "
+
+        real_name = name if name else func.__name__
+        con = HOOK_TEMPLATE.format(func_import=func_import,
+                                   func=func.__name__,
+                                   point=snake_to_camel(hook_point),
+                                   name=real_name,
+                                   topic=hook_point,
+                                   desc='')
+        with open(f"{real_name}.py", 'w+') as write:
+            write.writelines(con)
+        importlib.import_module(real_name)
+        return func
+
+    return decorator