ag2ai · rjambrecic · Feb 18, 2025 · Feb 17, 2025 · Feb 17, 2025 · Feb 18, 2025
diff --git a/.secrets.baseline b/.secrets.baseline
@@ -2495,7 +2495,7 @@
         "filename": "test/oai/test_gemini.py",
         "hashed_secret": "7dfe63b6762fc69b8e486a2bafa43b8f7d23b788",
         "is_verified": false,
-        "line_number": 51,
+        "line_number": 50,
         "is_secret": false
       }
     ],
@@ -3116,5 +3116,5 @@
       }
     ]
   },
-  "generated_at": "2025-02-16T23:27:38Z"
+  "generated_at": "2025-02-18T08:58:38Z"
 }
diff --git a/autogen/agents/experimental/websurfer/websurfer.py b/autogen/agents/experimental/websurfer/websurfer.py
@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Any, Literal
+from typing import Any, Literal, Optional
 
 from .... import ConversableAgent
 from ....doc_utils import export_module
@@ -18,8 +18,9 @@
 
     def __init__(
         self,
+        *,
         llm_config: dict[str, Any],
-        *args,
+        web_tool_llm_config: Optional[dict[str, Any]] = None,
         web_tool: Literal["browser_use", "crawl4ai"] = "browser_use",
         web_tool_kwargs: dict[str, Any] = None,
         **kwargs: Any,
@@ -28,17 +29,19 @@
 
         Args:
             llm_config (dict[str, Any]): The LLM configuration.
+            web_tool_llm_config (dict[str, Any], optional): The LLM configuration for the web tool. I not provided, the llm_config will be used.
             web_tool (Literal["browser_use", "crawl4ai"], optional): The web tool to use. Defaults to "browser_use".
             web_tool_kwargs (dict[str, Any], optional): The keyword arguments for the web tool. Defaults to None.
         """
         web_tool_kwargs = web_tool_kwargs if web_tool_kwargs else {}
+        web_tool_llm_config = web_tool_llm_config if web_tool_llm_config else llm_config
         if web_tool == "browser_use":
-            self.tool: Tool = BrowserUseTool(llm_config=llm_config, **web_tool_kwargs)
+            self.tool: Tool = BrowserUseTool(llm_config=web_tool_llm_config, **web_tool_kwargs)
         elif web_tool == "crawl4ai":
-            self.tool = Crawl4AITool(llm_config=llm_config, **web_tool_kwargs)
+            self.tool = Crawl4AITool(llm_config=web_tool_llm_config, **web_tool_kwargs)
         else:
             raise ValueError(f"Unsupported {web_tool=}.")
 
-        super().__init__(*args, llm_config=llm_config, **kwargs)
+        super().__init__(llm_config=llm_config, **kwargs)
 
         self.register_for_llm()(self.tool)
diff --git a/autogen/oai/gemini.py b/autogen/oai/gemini.py
@@ -593,6 +593,20 @@
             return [GeminiClient._convert_type_null_to_nullable(item) for item in schema]
         return schema
 
+    @staticmethod
+    def _unwrap_references(function_parameters: dict[str, Any]) -> dict[str, Any]:
+        if "properties" not in function_parameters:
+            return function_parameters
+
+        function_parameters_copy = copy.deepcopy(function_parameters)
+
+        for property_name, property_value in function_parameters["properties"].items():
+            if "$defs" in property_value:
+                function_parameters_copy["properties"][property_name] = dict(jsonref.replace_refs(property_value))
+                function_parameters_copy["properties"][property_name].pop("$defs")
+
+        return function_parameters_copy
+
     def _tools_to_gemini_tools(self, tools: list[dict[str, Any]]) -> list[Tool]:
         """Create Gemini tools (as typically requires Callables)"""
         functions = []
@@ -601,10 +615,11 @@
                 tool["function"]["parameters"] = GeminiClient._convert_type_null_to_nullable(
                     tool["function"]["parameters"]
                 )
+                function_parameters = GeminiClient._unwrap_references(tool["function"]["parameters"])
                 function = vaiFunctionDeclaration(
                     name=tool["function"]["name"],
                     description=tool["function"]["description"],
-                    parameters=tool["function"]["parameters"],
+                    parameters=function_parameters,
                 )
             else:
                 function = GeminiClient._create_gemini_function_declaration(tool)
@@ -681,8 +696,12 @@
     @staticmethod
     def _create_gemini_function_parameters(function_parameter: dict[str, any]) -> dict[str, any]:
         """Convert function parameters to Gemini format, recursive"""
+        function_parameter = GeminiClient._unwrap_references(function_parameter)
+
         if "type" in function_parameter:
             function_parameter["type"] = function_parameter["type"].upper()
+            # If the schema was created from pydantic BaseModel, it will "title" attribute which needs to be removed
+            function_parameter.pop("title", None)
 
         # Parameter properties and items
         if "properties" in function_parameter:

diff --git a/autogen/tools/experimental/deep_research/deep_research.py b/autogen/tools/experimental/deep_research/deep_research.py
@@ -3,9 +3,9 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import copy
-from typing import Annotated, Any, Callable, Optional
+from typing import Annotated, Any, Callable
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 from ....agentchat import ConversableAgent
 from ....doc_utils import export_module
@@ -16,16 +16,33 @@
 
 
 class Subquestion(BaseModel):
-    question: Annotated[str, "The original question."]
-    answer: Annotated[Optional[str], "The answer to the question."] = None
+    question: Annotated[str, Field(description="The original question.")]
+
+    def format(self) -> str:
+        return f"Question: {self.question}\n"
+
+
+class SubquestionAnswer(Subquestion):
+    answer: Annotated[str, Field(description="The answer to the question.")]
 
     def format(self) -> str:
         return f"Question: {self.question}\n{self.answer}\n"
 
 
 class Task(BaseModel):
-    question: Annotated[str, "The original question."]
-    subquestions: Annotated[list[Subquestion], "The subquestions that need to be answered."]
+    question: Annotated[str, Field(description="The original question.")]
+    subquestions: Annotated[list[Subquestion], Field(description="The subquestions that need to be answered.")]
+
+    def format(self) -> str:
+        return f"Task: {self.question}\n\n" + "\n".join(
+            "Subquestion " + str(i + 1) + ":\n" + subquestion.format()
+            for i, subquestion in enumerate(self.subquestions)
+        )
+
+
+class CompletedTask(BaseModel):
+    question: Annotated[str, Field(description="The original question.")]
+    subquestions: Annotated[list[SubquestionAnswer], Field(description="The subquestions and their answers")]
 
     def format(self) -> str:
         return f"Task: {self.question}\n\n" + "\n".join(
@@ -102,8 +119,15 @@
             llm_config: Annotated[dict[str, Any], Depends(on(llm_config))],
             max_web_steps: Annotated[int, Depends(on(max_web_steps))],
         ) -> str:
-            """
-            Delegate a research task to the agent.
+            """Delegate a research task to the agent.
+
+            Args:
+                task (str): The task to perform a research on.
+                llm_config (dict[str, Any]): The LLM configuration.
+                max_web_steps (int): The maximum number of web steps.
+
+            Returns:
+                str: The answer to the research task.
             """
 
             @self.summarizer_agent.register_for_execution()
@@ -189,7 +213,7 @@
                 human_input_mode="NEVER",
             )
 
-            generate_subquestions = DeepResearchTool.get_generate_subquestions(
+            generate_subquestions = DeepResearchTool._get_generate_subquestions(
                 llm_config=llm_config, max_web_steps=max_web_steps
             )
             decomposition_agent.register_for_execution()(generate_subquestions)
@@ -207,10 +231,20 @@
         return split_question_and_answer_subquestions
 
     @staticmethod
-    def get_generate_subquestions(
+    def _get_generate_subquestions(
         llm_config: dict[str, Any],
         max_web_steps: int,
     ) -> Callable[..., str]:
+        """Get the generate_subquestions method.
+
+        Args:
+            llm_config (dict[str, Any]): The LLM configuration.
+            max_web_steps (int): The maximum number of web steps.
+
+        Returns:
+            Callable[..., str]: The generate_subquestions method.
+        """
+
         def generate_subquestions(
             task: Task,
             llm_config: Annotated[dict[str, Any], Depends(on(llm_config))],
@@ -219,12 +253,16 @@
             if not task.subquestions:
                 task.subquestions = [Subquestion(question=task.question)]
 
+            subquestions_answers: list[SubquestionAnswer] = []
             for subquestion in task.subquestions:
-                subquestion.answer = DeepResearchTool._answer_question(
+                answer = DeepResearchTool._answer_question(
                     subquestion.question, llm_config=llm_config, max_web_steps=max_web_steps
                 )
+                subquestions_answers.append(SubquestionAnswer(question=subquestion.question, answer=answer))
 
-            return f"{DeepResearchTool.SUBQUESTIONS_ANSWER_PREFIX} \n" + task.format()
+            completed_task = CompletedTask(question=task.question, subquestions=subquestions_answers)
+
+            return f"{DeepResearchTool.SUBQUESTIONS_ANSWER_PREFIX} \n" + completed_task.format()
 
         return generate_subquestions
 
@@ -245,7 +283,8 @@
             return (content is not None) and content.startswith(DeepResearchTool.ANSWER_CONFIRMED_PREFIX)
 
         websurfer_agent = WebSurferAgent(
-            llm_config=websurfer_config,
+            llm_config=llm_config,
+            web_tool_llm_config=websurfer_config,
             name="WebSurferAgent",
             system_message=(
                 "You are a web surfer agent responsible for gathering information from the web to provide information for answering a question\n"

diff --git a/pyproject.toml b/pyproject.toml
@@ -179,7 +179,7 @@ gemini = [
     "google-auth",
     "pillow",
     "jsonschema",
-    "jsonref"
+    "jsonref>=1,<2"
 ]
 together = ["together>=1.2"]
 websurfer = ["beautifulsoup4", "markdownify", "pdfminer.six", "pathvalidate"]