Extremely ugly, super hacky, please don't look at this code

autogen/agentchat/conversable_agent.py

@@ -1126,7 +1126,8 @@ def _append_oai_message(self, message: Union[dict, str], role, conversation_id:
             else:
                 oai_message["name"] = conversation_id.name
 
-        self._oai_messages[conversation_id].append(oai_message)
+        # A weird bug where it doesn't init _oai_messages if you pass them in with chat_messages
+        self._oai_messages[conversation_id] = self._oai_messages.get(conversation_id, []) + [oai_message]
 
         return True
 
@@ -1291,7 +1292,9 @@ def receive(
         self._process_received_message(message, sender, silent)
         if request_reply is False or (request_reply is None and self.reply_at_receive[sender] is False):
             return
-        reply = self.generate_reply(messages=self.chat_messages[sender], sender=sender)
+        messages = [] if sender not in self.chat_messages else self.chat_messages[sender]
+        messages = messages if 'all' not in self.chat_messages else messages + self.chat_messages['all']
+        reply = self.generate_reply(messages=messages, sender=sender)
         if reply is not None:
             self.send(reply, sender, silent=silent)
 

autogen/agents/experimental/reliable/reliable_function_agent.py

@@ -83,7 +83,7 @@ def to_response_str(self):
     def to_message(self):
         return {
             "role": "assistant",
-            "name": self.reliable_agent_name,
+            "name": "all",
             "content": f"""BACKGROUND INFORMATION:
 Task: {self.task}
 Result:
@@ -150,6 +150,7 @@ def __init__(
         # self._runner.register_for_llm()(self._func_or_tool)
 
         self._runner = ConversableAgent(name=name + "-Runner", llm_config=runner_llm_config, **kwargs)
+        self._memory_agent = ConversableAgent(name="memory", llm_config=runner_llm_config, **kwargs)
 
         self._runner.register_for_execution()(self._func)
         self._runner.register_for_llm()(self._func)
@@ -237,7 +238,7 @@ def run_func(self, task: str, messages: list[dict] = [], context_variables: dict
 
         _, final_context_variables, _ = initiate_swarm_chat(
             initial_agent=self._runner,
-            agents=[self._runner, self._validator, self],
+            agents=[self._runner, self._validator, self._memory_agent, self],
             messages=messages
             + [
                 {
@@ -320,7 +321,11 @@ async def wrapper(*args, hypothesis, context_variables: Dict[str, str], **kwargs
     params = list(orig_sig.parameters.values())
 
     # Create new parameters for hypothesis and context_variables.
-    hypothesis_param = inspect.Parameter("hypothesis", kind=inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=str)
+    hypothesis_param = inspect.Parameter("hypothesis", kind=inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=Annotated[
+        str,
+        AG2Field(
+            description=HYPOTHESIS_DEF
+        )])
     context_variables_param = inspect.Parameter(
         "context_variables", kind=inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=Dict[str, str]
     )

autogen/tools/experimental/browser_use/browser_use.py

@@ -4,6 +4,7 @@
 
 from typing import Annotated, Any, Optional, Tuple
 
+from browser_use import BrowserContextConfig
 from pydantic import BaseModel
 
 from ....doc_utils import export_module
@@ -48,7 +49,7 @@ def __init__(  # type: ignore[no-any-unimported]
         self,
         *,
         llm_config: dict[str, Any],
-        planner_llm_config: dict[str, Any] =  None,
+        planner_llm_config: Optional[dict[str, Any]] = None,
         browser: Optional["Browser"] = None,
         agent_kwargs: Optional[dict[str, Any]] = None,
         browser_config: Optional[dict[str, Any]] = None,
@@ -77,9 +78,12 @@ def __init__(  # type: ignore[no-any-unimported]
 
         if browser is None:
             # set default value for headless
+            config = BrowserContextConfig(
+                allowed_domains=['google.com', 'wikipedia.org'],
+            )
             headless = browser_config.pop("headless", True)
 
-            browser_config = BrowserConfig(headless=headless, **browser_config)
+            browser_config = BrowserConfig(headless=headless, new_context_config=config, **browser_config)
             browser = Browser(config=browser_config)
 
         # set default value for generate_gif
@@ -89,28 +93,38 @@ def __init__(  # type: ignore[no-any-unimported]
         async def browser_use(  # type: ignore[no-any-unimported]
             task: Annotated[str, "The task to perform."],
             llm_config: Annotated[dict[str, Any], Depends(on(llm_config))],
-            planner_llm_config: Annotated[dict[str, Any], Depends(on(planner_llm_config))],
             browser: Annotated[Browser, Depends(on(browser))],
             agent_kwargs: Annotated[dict[str, Any], Depends(on(agent_kwargs))],
-            planner_kwargs: Annotated[dict[str, Any], Depends(on(planner_kwargs))]
+            # planner_llm_config: Optional[Annotated[dict[str, Any], Depends(on(planner_llm_config))]],
+            # planner_kwargs: Optional[Annotated[dict[str, Any], Depends(on(planner_kwargs))]]
         ) -> Tuple[BrowserUseResult, str]:
             llm = BrowserUseTool._get_llm(llm_config)
 
-            max_steps = agent_kwargs.pop("max_steps", 5)
+            max_steps = agent_kwargs.pop("max_steps", 100)
 
+            # all of this is super lazy code
             planner_llm = None
             if planner_llm_config is not None:
                 planner_llm = BrowserUseTool._get_llm(planner_llm_config)
-
-            agent = Agent(
-                task=task,
-                llm=llm,
-                browser=browser,
-                controller=BrowserUseTool._get_controller(llm_config, controller_kwargs),
-                planner_llm=planner_llm,
-                **agent_kwargs,
-                **planner_kwargs
-            )
+            if planner_kwargs:
+                agent = Agent(
+                    task=task,
+                    llm=llm,
+                    browser=browser,
+                    controller=BrowserUseTool._get_controller(llm_config, controller_kwargs),
+                    planner_llm=planner_llm,
+                    **agent_kwargs,
+                    **planner_kwargs
+                )
+            else:
+                agent = Agent(
+                    task=task,
+                    llm=llm,
+                    browser=browser,
+                    controller=BrowserUseTool._get_controller(llm_config, controller_kwargs),
+                    planner_llm=planner_llm,
+                    **agent_kwargs
+                )
 
             result = await agent.run(max_steps=max_steps)
 
@@ -166,7 +180,7 @@ def _get_llm(
             raise ValueError(f"llm_config must be a valid config dictionary: {e}")
 
         if api_type == "openai":
-            return ChatOpenAI(model=model, api_key=api_key, base_url=llm_config['config_list'][0]['base_url'])
+            return ChatOpenAI(model=model, api_key=api_key, base_url=None if 'base_url' not in llm_config['config_list'][0] else llm_config['config_list'][0]['base_url'])
         elif api_type == "azure":
             return AzureChatOpenAI(
                 model=model,