agentUniverse 0.0.10.dev1__tar.gz → 0.0.11.dev1__tar.gz

{agentuniverse-0.0.10.dev1 → agentuniverse-0.0.11.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: agentUniverse
-Version: 0.0.10.dev1
+Version: 0.0.11.dev1
 Summary: agentUniverse is a framework for developing applications powered by multi-agent base on large language model.
 Home-page: https://github.com/alipay/agentUniverse
 Author: AntGroup

{agentuniverse-0.0.10.dev1 → agentuniverse-0.0.11.dev1}/agentuniverse/agent/default/executing_agent/executing_agent.py

@@ -76,7 +76,8 @@ class ExecutingAgent(Agent):
         framework = agent_input.get('framework', [])
         futures = []
         for task in framework:
-            agent_input_copy: dict = copy.deepcopy(agent_input)
+            # note: agent input shallow copy.
+            agent_input_copy: dict = dict(agent_input)
             agent_input_copy['input'] = task
             planner: Planner = PlannerManager().get_instance_obj(self.agent_model.plan.get('planner').get('name'))
             futures.append(
@@ -99,7 +100,8 @@ class ExecutingAgent(Agent):
         # get agent toolsets.
         action: dict = self.agent_model.action or dict()
         tools: list = action.get('tool') or list()
-        input_object_copy: InputObject = copy.deepcopy(input_object)
+        # note: input object shallow copy.
+        input_object_copy: InputObject = InputObject(input_object.to_dict())
         # wrap input_object for agent knowledge.
         input_object_copy.add_data(planner_input_key, subtask)
         # wrap input_object for agent toolsets.

{agentuniverse-0.0.10.dev1 → agentuniverse-0.0.11.dev1}/agentuniverse/agent/memory/chat_memory.py

@@ -50,17 +50,18 @@ class ChatMemory(Memory):
                                                      max_token_limit=self.max_tokens, messages=self.messages,
                                                      prompt_version=self.prompt_version)
 
-    def set_by_agent_model(self, **kwargs) -> None:
+    def set_by_agent_model(self, **kwargs):
         """ Assign values of parameters to the ChatMemory model in the agent configuration."""
-        super().set_by_agent_model(**kwargs)
+        copied_obj = super().set_by_agent_model(**kwargs)
         if 'messages' in kwargs and kwargs['messages']:
-            self.messages = kwargs['messages']
+            copied_obj.messages = kwargs['messages']
         if 'llm' in kwargs and kwargs['llm']:
-            self.llm = kwargs['llm']
+            copied_obj.llm = kwargs['llm']
         if 'input_key' in kwargs and kwargs['input_key']:
-            self.input_key = kwargs['input_key']
+            copied_obj.input_key = kwargs['input_key']
         if 'output_key' in kwargs and kwargs['output_key']:
-            self.output_key = kwargs['output_key']
+            copied_obj.output_key = kwargs['output_key']
+        return copied_obj
 
     def initialize_by_component_configer(self, component_configer: MemoryConfiger) -> 'ChatMemory':
         """Initialize the chat memory by the ComponentConfiger object.

{agentuniverse-0.0.10.dev1 → agentuniverse-0.0.11.dev1}/agentuniverse/agent/memory/memory.py

@@ -40,12 +40,15 @@ class Memory(ComponentBase):
         """Convert the agentUniverse(aU) memory class to the langchain memory class."""
         pass
 
-    def set_by_agent_model(self, **kwargs) -> None:
+    def set_by_agent_model(self, **kwargs):
         """ Assign values of parameters to the Memory model in the agent configuration."""
+        # note: default shallow copy
+        copied_obj = self.model_copy()
         if 'memory_key' in kwargs and kwargs['memory_key']:
-            self.memory_key = kwargs['memory_key']
+            copied_obj.memory_key = kwargs['memory_key']
         if 'max_tokens' in kwargs and kwargs['max_tokens']:
-            self.max_tokens = kwargs['max_tokens']
+            copied_obj.max_tokens = kwargs['max_tokens']
+        return copied_obj
 
     def get_instance_code(self) -> str:
         """Return the full name of the memory."""

{agentuniverse-0.0.10.dev1 → agentuniverse-0.0.11.dev1}/agentuniverse/agent/plan/planner/expressing_planner/expressing_planner.py

@@ -51,8 +51,8 @@ class ExpressingPlanner(Planner):
             history_messages_key="chat_history",
             input_messages_key=self.input_key,
         ) | StrOutputParser()
-        res = asyncio.run(
-            chain_with_history.ainvoke(input=planner_input, config={"configurable": {"session_id": "unused"}}))
+
+        res = self.invoke_chain(agent_model, chain_with_history, planner_input, chat_history, input_object)
         return {**planner_input, self.output_key: res, 'chat_history': generate_memories(chat_history)}
 
     def handle_prompt(self, agent_model: AgentModel, planner_input: dict) -> Prompt:

{agentuniverse-0.0.10.dev1 → agentuniverse-0.0.11.dev1}/agentuniverse/agent/plan/planner/peer_planner/peer_planner.py

@@ -42,7 +42,7 @@ class PeerPlanner(Planner):
         """
         planner_config = agent_model.plan.get('planner')
         sub_agents = self.generate_sub_agents(planner_config)
-        return self.agents_run(sub_agents, planner_config, planner_input, input_object)
+        return self.agents_run(agent_model, sub_agents, planner_config, planner_input, input_object)
 
     @staticmethod
     def generate_sub_agents(planner_config: dict) -> dict:
@@ -79,7 +79,8 @@ class PeerPlanner(Planner):
             elif context:
                 input_object.add_data('expert_framework', context)
 
-    def agents_run(self, agents: dict, planner_config: dict, agent_input: dict, input_object: InputObject) -> dict:
+    def agents_run(self, agent_mode: AgentModel, agents: dict, planner_config: dict, agent_input: dict,
+                   input_object: InputObject) -> dict:
         """Planner agents run.
 
         Args:
@@ -125,6 +126,10 @@ class PeerPlanner(Planner):
                 for index, one_framework in enumerate(planning_result.get_data('framework')):
                     logger_info += f"[{index + 1}] {one_framework} \n"
                 LOGGER.info(logger_info)
+                self.stream_output(input_object, {"data": {
+                    'output': planning_result.to_dict(),
+                    "agent_info": agent_mode.info
+                }, "type": "planning"})
 
             if not executing_result or jump_step in ["planning", "executing"]:
                 if not executingAgent:
@@ -143,6 +148,10 @@ class PeerPlanner(Planner):
                         one_exec_log_info += f"[{index + 1}] output: {one_exec_res['output']}\n"
                         logger_info += one_exec_log_info
                 LOGGER.info(logger_info)
+                self.stream_output(input_object, {"data": {
+                    'output': executing_result.to_dict(),
+                    "agent_info": agent_mode.info
+                }, "type": "executing"})
 
             if not expressing_result or jump_step in ["planning", "executing", "expressing"]:
                 if not expressingAgent:
@@ -157,6 +166,10 @@ class PeerPlanner(Planner):
                 logger_info = f"\nExpressing agent execution result is :\n"
                 logger_info += f"{expressing_result.get_data('output')}"
                 LOGGER.info(logger_info)
+                self.stream_output(input_object, {"data": {
+                    'output': expressing_result.get_data('output'),
+                    "agent_info": agent_mode.info
+                }, "type": "expressing"})
 
             if not reviewing_result or jump_step in ["planning", "executing", "expressing", "reviewing"]:
                 if not reviewingAgent:
@@ -172,6 +185,7 @@ class PeerPlanner(Planner):
                 else:
                     LOGGER.info(f"Starting reviewing agent.")
                     reviewing_result = reviewingAgent.run(**input_object.to_dict())
+
                     input_object.add_data('reviewing_result', reviewing_result)
 
                     # add reviewing agent log info
@@ -179,7 +193,7 @@ class PeerPlanner(Planner):
                     reviewing_info_str = f"review suggestion: {reviewing_result.get_data('suggestion')} \n"
                     reviewing_info_str += f"review score: {reviewing_result.get_data('score')} \n"
                     LOGGER.info(logger_info + reviewing_info_str)
-
+                    self.stream_output(input_object, {"data": reviewing_result.to_dict(), "type": "reviewing"})
                     if reviewing_result.get_data('score') and reviewing_result.get_data('score') >= eval_threshold:
                         loopResults.append({
                             "planning_result": planning_result,

{agentuniverse-0.0.10.dev1 → agentuniverse-0.0.11.dev1}/agentuniverse/agent/plan/planner/planner.py

@@ -6,15 +6,18 @@
 # @FileName: planner.py
 """Base class for Planner."""
 from abc import abstractmethod
-import copy
 import logging
-from typing import Optional, List
+from queue import Queue
+from typing import Optional, List, Any
+
+from langchain_core.runnables import RunnableSerializable
 
 from agentuniverse.agent.action.knowledge.knowledge import Knowledge
 from agentuniverse.agent.action.knowledge.knowledge_manager import KnowledgeManager
 from agentuniverse.agent.action.knowledge.store.document import Document
 from agentuniverse.agent.action.knowledge.store.query import Query
 from agentuniverse.agent.action.tool.tool_manager import ToolManager
+from agentuniverse.agent.agent_manager import AgentManager
 from agentuniverse.agent.agent_model import AgentModel
 from agentuniverse.agent.input_object import InputObject
 from agentuniverse.agent.memory.chat_memory import ChatMemory
@@ -27,7 +30,7 @@ from agentuniverse.base.config.component_configer.configers.planner_configer imp
 from agentuniverse.llm.llm import LLM
 from agentuniverse.llm.llm_manager import LLMManager
 from agentuniverse.prompt.prompt import Prompt
-from agentuniverse.base.util.memory_util import generate_messages
+from agentuniverse.base.util.memory_util import generate_messages, generate_memories
 
 logging.getLogger().setLevel(logging.ERROR)
 
@@ -84,11 +87,10 @@ class Planner(ComponentBase):
         params['input_key'] = self.input_key
         params['output_key'] = self.output_key
 
-        memory: ChatMemory = MemoryManager().get_instance_obj(component_instance_name=memory_name, new_instance=True)
+        memory: ChatMemory = MemoryManager().get_instance_obj(component_instance_name=memory_name)
         if memory is None:
             return None
-        memory.set_by_agent_model(**params)
-        return memory
+        return memory.set_by_agent_model(**params)
 
     def run_all_actions(self, agent_model: AgentModel, planner_input: dict, input_object: InputObject):
         """Tool and knowledge processing.
@@ -101,6 +103,7 @@ class Planner(ComponentBase):
         action: dict = agent_model.action or dict()
         tools: list = action.get('tool') or list()
         knowledge: list = action.get('knowledge') or list()
+        agents: list = action.get('agent') or list()
 
         action_result: list = list()
 
@@ -120,6 +123,16 @@ class Planner(ComponentBase):
             for document in knowledge_res:
                 action_result.append(document.text)
 
+        for agent_name in agents:
+            agent = AgentManager().get_instance_obj(agent_name)
+            if agent is None:
+                continue
+            agent_input = {key: input_object.get_data(key) for key in agent.input_keys()}
+            output_object = agent.run(**agent_input)
+            action_result.append("\n".join([output_object.get_data(key)
+                                            for key in agent.output_keys()
+                                            if output_object.get_data(key) is not None]))
+
         planner_input['background'] = planner_input['background'] or '' + "\n".join(action_result)
 
     def handle_prompt(self, agent_model: AgentModel, planner_input: dict):
@@ -142,9 +155,8 @@ class Planner(ComponentBase):
             LLM: The language model.
         """
         llm_name = agent_model.profile.get('llm_model').get('name')
-        llm: LLM = LLMManager().get_instance_obj(component_instance_name=llm_name, new_instance=True)
-        llm.set_by_agent_model(**agent_model.profile.get('llm_model'))
-        return llm
+        llm: LLM = LLMManager().get_instance_obj(component_instance_name=llm_name)
+        return llm.set_by_agent_model(**agent_model.profile.get('llm_model'))
 
     def initialize_by_component_configer(self, component_configer: PlannerConfiger) -> 'Planner':
         """Initialize the planner by the PlannerConfiger object.
@@ -159,3 +171,35 @@ class Planner(ComponentBase):
         self.input_key = component_configer.input_key or self.input_key
         self.output_key = component_configer.output_key or self.output_key
         return self
+
+    @staticmethod
+    def stream_output(input_object: InputObject, data: dict):
+        """Stream output.
+
+        Args:
+            input_object (InputObject): Agent input object.
+            data (dict): The data to be streamed.
+        """
+        output_stream: Queue = input_object.get_data('output_stream', None)
+        if output_stream is None:
+            return
+        output_stream.put_nowait(data)
+
+    def invoke_chain(self, agent_model: AgentModel, chain: RunnableSerializable[Any, str], planner_input: dict, chat_history,
+               input_object: InputObject):
+
+        if not input_object.get_data('output_stream'):
+            res = chain.invoke(input=planner_input, config={"configurable": {"session_id": "unused"}})
+            return res
+        result = []
+        for token in chain.stream(input=planner_input, config={"configurable": {"session_id": "unused"}}):
+            self.stream_output(input_object, {
+                'type': 'token',
+                'data': {
+                    'chunk': token,
+                    'agent_info': agent_model.info
+                }
+            })
+            result.append(token)
+        return "".join(result)
+

{agentuniverse-0.0.10.dev1 → agentuniverse-0.0.11.dev1}/agentuniverse/agent/plan/planner/planning_planner/planning_planner.py

@@ -52,8 +52,7 @@ class PlanningPlanner(Planner):
             history_messages_key="chat_history",
             input_messages_key=self.input_key,
         ) | StrOutputParser()
-        res = asyncio.run(
-            chain_with_history.ainvoke(input=planner_input, config={"configurable": {"session_id": "unused"}}))
+        res = self.invoke_chain(agent_model, chain_with_history, planner_input, chat_history, input_object)
         return {**planner_input, self.output_key: res, 'chat_history': generate_memories(chat_history)}
 
     def handle_prompt(self, agent_model: AgentModel, planner_input: dict) -> Prompt:

{agentuniverse-0.0.10.dev1 → agentuniverse-0.0.11.dev1}/agentuniverse/agent/plan/planner/rag_planner/rag_planner.py

@@ -5,7 +5,6 @@
 # @Email   : lc299034@antgroup.com
 # @FileName: rag_planner.py
 """Rag planner module."""
-import asyncio
 
 from langchain_core.chat_history import InMemoryChatMessageHistory
 from langchain_core.output_parsers import StrOutputParser
@@ -55,8 +54,7 @@ class RagPlanner(Planner):
             history_messages_key="chat_history",
             input_messages_key=self.input_key,
         ) | StrOutputParser()
-        res = asyncio.run(
-            chain_with_history.ainvoke(input=planner_input, config={"configurable": {"session_id": "unused"}}))
+        res = self.invoke_chain(agent_model, chain_with_history, planner_input, chat_history, input_object)
         return {**planner_input, self.output_key: res, 'chat_history': generate_memories(chat_history)}
 
     def handle_prompt(self, agent_model: AgentModel, planner_input: dict) -> ChatPrompt:

{agentuniverse-0.0.10.dev1 → agentuniverse-0.0.11.dev1}/agentuniverse/agent/plan/planner/react_planner/react_planner.py

@@ -64,14 +64,14 @@ class ReActPlanner(Planner):
                                        max_iterations=agent_model.plan.get('planner').get("max_iterations", 15))
 
         return agent_executor.invoke(input=planner_input, memory=memory.as_langchain() if memory else None,
-                                     chat_history=chat_history, config=self.get_run_config(input_object))
+                                     chat_history=chat_history, config=self.get_run_config(agent_model, input_object))
 
     @staticmethod
-    def get_run_config(input_object: InputObject) -> RunnableConfig:
+    def get_run_config(agent_model: AgentModel, input_object: InputObject) -> RunnableConfig:
         config = RunnableConfig()
         callbacks = []
         output_stream = input_object.get_data('output_stream')
-        callbacks.append(StreamOutPutCallbackHandler(output_stream))
+        callbacks.append(StreamOutPutCallbackHandler(output_stream, agent_info=agent_model.info))
         config.setdefault("callbacks", callbacks)
         return config
 

{agentuniverse-0.0.10.dev1 → agentuniverse-0.0.11.dev1}/agentuniverse/agent/plan/planner/react_planner/stream_callback.py

@@ -16,10 +16,13 @@ from langchain_core.callbacks import BaseCallbackHandler
 class StreamOutPutCallbackHandler(BaseCallbackHandler):
     """Callback Handler that prints to std out."""
 
-    def __init__(self, queue_stream: asyncio.Queue, color: Optional[str] = None) -> None:
+    def __init__(self, queue_stream: asyncio.Queue, color: Optional[str] = None, agent_info: dict = None) -> None:
         """Initialize callback handler."""
         self.queueStream = queue_stream
         self.color = color
+        if agent_info is None:
+            agent_info = {}
+        self.agent_info = agent_info
 
     def on_chain_start(
             self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
@@ -32,7 +35,13 @@ class StreamOutPutCallbackHandler(BaseCallbackHandler):
     def on_agent_action(
             self, action: AgentAction, color: Optional[str] = None, **kwargs: Any
     ) -> Any:
-        self.queueStream.put_nowait("Thought:"+action.log)
+        self.queueStream.put_nowait({
+            "type": "ReAct",
+            "data": {
+                "output": "\nThought:" + action.log,
+                "agent_info": self.agent_info
+            }
+        })
 
     def on_tool_end(
             self,
@@ -44,9 +53,21 @@ class StreamOutPutCallbackHandler(BaseCallbackHandler):
     ) -> None:
         """If not the final action, print out observation."""
         if observation_prefix is not None:
-            self.queueStream.put_nowait(observation_prefix + output)
+            self.queueStream.put_nowait({
+                "type": "ReAct",
+                "data": {
+                    "output": '\n' + observation_prefix + output,
+                    "agent_info": self.agent_info
+                }
+            })
         else:
-            self.queueStream.put_nowait('Observation:'+output)
+            self.queueStream.put_nowait({
+                "type": "ReAct",
+                "data": {
+                    "output": '\n Observation:' + output,
+                    "agent_info": self.agent_info
+                }
+            })
 
     def on_text(
             self,
@@ -61,4 +82,10 @@ class StreamOutPutCallbackHandler(BaseCallbackHandler):
             self, finish: AgentFinish, color: Optional[str] = None, **kwargs: Any
     ) -> None:
         """Run on agent end."""
-        self.queueStream.put_nowait("Thought:" + finish.log + "\n")
+        self.queueStream.put_nowait({
+            "type": "ReAct",
+            "data": {
+                "output": '\nThought:' + finish.output,
+                "agent_info": self.agent_info
+            }
+        })

{agentuniverse-0.0.10.dev1 → agentuniverse-0.0.11.dev1}/agentuniverse/agent/plan/planner/reviewing_planner/reviewing_planner.py

@@ -51,8 +51,7 @@ class ReviewingPlanner(Planner):
             history_messages_key="chat_history",
             input_messages_key=self.input_key,
         ) | StrOutputParser()
-        res = asyncio.run(
-            chain_with_history.ainvoke(input=planner_input, config={"configurable": {"session_id": "unused"}}))
+        res = self.invoke_chain(agent_model, chain_with_history, planner_input, chat_history, input_object)
         return {**planner_input, self.output_key: res, 'chat_history': generate_memories(chat_history)}
 
     def handle_prompt(self, agent_model: AgentModel, planner_input: dict) -> Prompt:

{agentuniverse-0.0.10.dev1 → agentuniverse-0.0.11.dev1}/agentuniverse/agent_serve/web/request_task.py

@@ -73,8 +73,13 @@ class RequestTask:
                                        ensure_ascii=False) + "\n\n"
         if self.canceled():
             return
-        yield "data:" + json.dumps({"result": self.thread.result()},
-                                   ensure_ascii=False) + "\n\n"
+        try:
+            result = self.thread.result()
+            yield "data:" + json.dumps({"result": result},
+                                       ensure_ascii=False) + "\n\n "
+        except Exception as e:
+            LOGGER.error("request task execute Fail: " + str(e))
+            yield "data:" + json.dumps({"error": {"error_msg": str(e)}}) + "\n\n "
 
     def append_steps(self):
         """Tracing async service running state and update it to database."""
@@ -225,7 +230,7 @@ class RequestTask:
         self.__request_do__.state = TaskStateEnum.FINISHED.value
 
     @staticmethod
-    def query_request_state(request_id: str) -> dict|None:
+    def query_request_state(request_id: str) -> dict | None:
         """Query the request data in database by given request_id.
 
         Args:

{agentuniverse-0.0.10.dev1 → agentuniverse-0.0.11.dev1}/agentuniverse/agent_serve/web/thread_with_result.py

@@ -30,6 +30,9 @@ class ThreadWithReturnValue(Thread):
                 self._return = self.target(*self.args, **self.kwargs)
             except Exception as e:
                 self.error = e
+            finally:
+                if 'output_stream' in self.kwargs:
+                    self.kwargs['output_stream'].put('{"type": "EOF"}')
 
     def result(self):
         """Wait for target func finished, then return the result or raise an

{agentuniverse-0.0.10.dev1 → agentuniverse-0.0.11.dev1}/agentuniverse/base/annotation/trace.py

@@ -128,11 +128,8 @@ def trace_agent(func):
 
         # invoke function
         result = func(*args, **kwargs)
-        # serialize agent input and output dict
-        agent_input = serialize_agent_invocation(agent_input)
-        agent_output = serialize_agent_invocation(result)
         # add agent invocation info to monitor
-        Monitor().trace_agent_invocation(source=source, agent_input=agent_input, agent_output=agent_output)
+        Monitor().trace_agent_invocation(source=source, agent_input=agent_input, agent_output=result)
         return result
 
     # sync function
@@ -145,16 +142,3 @@ def _get_agent_input(func, *args, **kwargs) -> dict:
     bound_args = sig.bind(*args, **kwargs)
     bound_args.apply_defaults()
     return {k: v for k, v in bound_args.arguments.items()}
-
-
-def default_serializer(obj):
-    if isinstance(obj, InputObject):
-        return obj.to_dict()
-    elif isinstance(obj, OutputObject):
-        return obj.to_dict()
-    raise TypeError(f"Object of type {type(obj).__name__} is not JSON serializable")
-
-
-def serialize_agent_invocation(agent_invocation):
-    agent_invocation_serialized = json.loads(json.dumps(agent_invocation, default=default_serializer))
-    return agent_invocation_serialized

{agentuniverse-0.0.10.dev1 → agentuniverse-0.0.11.dev1}/agentuniverse/base/component/component_manager_base.py

@@ -38,7 +38,7 @@ class ComponentManagerBase(Generic[ComponentTypeVar]):
         self._instance_obj_map.pop(component_instance_name)
 
     def get_instance_obj(self, component_instance_name: str,
-                         appname: str = None, new_instance: bool = None) -> ComponentTypeVar:
+                         appname: str = None, new_instance: bool = False) -> ComponentTypeVar:
         """Return the component instance object."""
         appname = appname or ApplicationConfigManager().app_configer.base_info_appname
         instance_code = f'{appname}.{self._component_type.value.lower()}.{component_instance_name}'

{agentuniverse-0.0.10.dev1 → agentuniverse-0.0.11.dev1}/agentuniverse/base/util/monitor/monitor.py

@@ -12,6 +12,8 @@ from typing import Union, Optional
 
 from pydantic import BaseModel
 
+from agentuniverse.agent.input_object import InputObject
+from agentuniverse.agent.output_object import OutputObject
 from agentuniverse.base.annotation.singleton import singleton
 from agentuniverse.base.config.configer import Configer
 
@@ -57,12 +59,6 @@ class Monitor(BaseModel):
             with jsonlines.open(path_save, 'a') as writer:
                 writer.write(llm_invocation)
 
-    def _get_or_create_subdir(self, subdir: str) -> str:
-        """Get or create a subdirectory if it doesn't exist in the monitor directory."""
-        path = os.path.join(self.dir, subdir)
-        os.makedirs(path, exist_ok=True)
-        return path
-
     def trace_agent_invocation(self, source: str, agent_input: Union[str, dict],
                                agent_output: Union[str, dict]) -> None:
         """Trace the agent invocation and save it to the monitor jsonl file."""
@@ -78,8 +74,8 @@ class Monitor(BaseModel):
             agent_invocation = {
                 "source": source,
                 "date": date.strftime("%Y-%m-%d %H:%M:%S"),
-                "agent_input": agent_input,
-                "agent_output": agent_output,
+                "agent_input": self.serialize_obj(agent_input),
+                "agent_output": self.serialize_obj(agent_output),
             }
             # files are stored in hours
             filename = f"agent_{source}_{date.strftime('%Y-%m-%d-%H')}.jsonl"
@@ -90,3 +86,52 @@ class Monitor(BaseModel):
             with jsonlines.open(path_save, 'a') as writer:
                 writer.write(agent_invocation)
 
+    def _get_or_create_subdir(self, subdir: str) -> str:
+        """Get or create a subdirectory if it doesn't exist in the monitor directory."""
+        path = os.path.join(self.dir, subdir)
+        os.makedirs(path, exist_ok=True)
+        return path
+
+    @staticmethod
+    def default_serializer(obj):
+        """Default serializer for objects."""
+        if isinstance(obj, InputObject):
+            return obj.to_dict()
+        elif isinstance(obj, OutputObject):
+            return obj.to_dict()
+        elif isinstance(obj, BaseModel):
+            try:
+                return obj.dict()
+            except TypeError:
+                raise TypeError(f"Object of type {type(obj).__name__} is not JSON serializable")
+        else:
+            raise TypeError(f"Object of type {type(obj).__name__} is not JSON serializable")
+
+    def serialize_obj(self, obj):
+        """Serialize an object and filter out non-serializable values."""
+        filtered_obj = self.filter_and_serialize(obj)
+        return json.loads(json.dumps(filtered_obj, default=self.default_serializer))
+
+    def filter_and_serialize(self, obj):
+        """Recursively filter out non-serializable values from an object."""
+
+        def is_json_serializable(value):
+            """Check if value is a JSON serializable object."""
+            try:
+                json.dumps(value, default=self.default_serializer)
+                return True
+            except (TypeError, OverflowError):
+                return False
+
+        def filter_dict(d):
+            return {k: v for k, v in d.items() if is_json_serializable(v)}
+
+        def recursive_filter(o):
+            if isinstance(o, dict):
+                return filter_dict({k: recursive_filter(v) for k, v in o.items()})
+            elif isinstance(o, list):
+                return [recursive_filter(i) for i in o if is_json_serializable(i)]
+            else:
+                return o
+
+        return recursive_filter(obj)

{agentuniverse-0.0.10.dev1 → agentuniverse-0.0.11.dev1}/agentuniverse/llm/llm.py

@@ -107,22 +107,25 @@ class LLM(ComponentBase):
             self._max_context_length = component_configer.configer.value['max_context_length']
         return self
 
-    def set_by_agent_model(self, **kwargs) -> None:
+    def set_by_agent_model(self, **kwargs):
         """ Assign values of parameters to the LLM model in the agent configuration."""
+        # note: default shallow copy
+        copied_obj = self.model_copy()
         if 'model_name' in kwargs and kwargs['model_name']:
-            self.model_name = kwargs['model_name']
+            copied_obj.model_name = kwargs['model_name']
         if 'temperature' in kwargs and kwargs['temperature']:
-            self.temperature = kwargs['temperature']
+            copied_obj.temperature = kwargs['temperature']
         if 'request_timeout' in kwargs and kwargs['request_timeout']:
-            self.request_timeout = kwargs['request_timeout']
+            copied_obj.request_timeout = kwargs['request_timeout']
         if 'max_tokens' in kwargs and kwargs['max_tokens']:
-            self.max_tokens = kwargs['max_tokens']
+            copied_obj.max_tokens = kwargs['max_tokens']
         if 'max_retries' in kwargs and kwargs['max_retries']:
-            self.max_retries = kwargs['max_retries']
+            copied_obj.max_retries = kwargs['max_retries']
         if 'streaming' in kwargs and kwargs['streaming']:
-            self.streaming = kwargs['streaming']
+            copied_obj.streaming = kwargs['streaming']
         if 'max_context_length' in kwargs and kwargs['max_context_length']:
-            self._max_context_length = kwargs['max_context_length']
+            copied_obj._max_context_length = kwargs['max_context_length']
+        return copied_obj
 
     def max_context_length(self) -> int:
         """Max context length.

{agentuniverse-0.0.10.dev1 → agentuniverse-0.0.11.dev1}/agentuniverse/llm/openai_llm.py

@@ -93,8 +93,7 @@ class OpenAILLM(LLM):
             **kwargs: Arbitrary keyword arguments.
         """
         streaming = kwargs.pop("streaming") if "streaming" in kwargs else self.streaming
-        if self.client is None:
-            self.client = self._new_client()
+        self.client = self._new_client()
         chat_completion = self.client.chat.completions.create(
             messages=messages,
             model=kwargs.pop('model', self.model_name),
@@ -116,8 +115,7 @@ class OpenAILLM(LLM):
             **kwargs: Arbitrary keyword arguments.
         """
         streaming = kwargs.pop("streaming") if "streaming" in kwargs else self.streaming
-        if self.async_client is None:
-            self.async_client = self._new_async_client()
+        self.async_client = self._new_async_client()
         chat_completion = await self.async_client.chat.completions.create(
             messages=messages,
             model=kwargs.pop('model', self.model_name),
@@ -135,17 +133,18 @@ class OpenAILLM(LLM):
         """Convert the agentUniverse(aU) openai llm class to the langchain openai llm class."""
         return LangchainOpenAI(self)
 
-    def set_by_agent_model(self, **kwargs) -> None:
+    def set_by_agent_model(self, **kwargs):
         """ Assign values of parameters to the OpenAILLM model in the agent configuration."""
-        super().set_by_agent_model(**kwargs)
+        copied_obj = super().set_by_agent_model(**kwargs)
         if 'openai_api_key' in kwargs and kwargs['openai_api_key']:
-            self.openai_api_key = kwargs['openai_api_key']
+            copied_obj.openai_api_key = kwargs['openai_api_key']
         if 'openai_api_base' in kwargs and kwargs['openai_api_base']:
-            self.openai_api_base = kwargs['openai_api_base']
+            copied_obj.openai_api_base = kwargs['openai_api_base']
         if 'openai_proxy' in kwargs and kwargs['openai_proxy']:
-            self.openai_proxy = kwargs['openai_proxy']
+            copied_obj.openai_proxy = kwargs['openai_proxy']
         if 'openai_client_args' in kwargs and kwargs['openai_client_args']:
-            self.openai_client_args = kwargs['openai_client_args']
+            copied_obj.openai_client_args = kwargs['openai_client_args']
+        return copied_obj
 
     def max_context_length(self) -> int:
         """Max context length.