quantalogic 0.59.3__py3-none-any.whl → 0.60.0__py3-none-any.whl

quantalogic/agent.py

@@ -23,6 +23,7 @@ from quantalogic.utils import get_environment
 from quantalogic.utils.ask_user_validation import console_ask_for_user_validation
 from quantalogic.xml_parser import ToleranceXMLParser
 from quantalogic.xml_tool_parser import ToolParser
+import uuid
 
 # Maximum ratio occupancy of the occupied memory
 MAX_OCCUPANCY = 90.0
@@ -78,7 +79,7 @@ class Agent(BaseModel):
     config: AgentConfig
     task_to_solve: str
     task_to_solve_summary: str = ""
-    ask_for_user_validation: Callable[[str, str], Awaitable[bool]] = console_ask_for_user_validation
+    ask_for_user_validation: Callable[[str, str], bool] = console_ask_for_user_validation
     last_tool_call: dict[str, Any] = {}  # Stores the last tool call information
     total_tokens: int = 0  # Total tokens in the conversation
     current_iteration: int = 0
@@ -91,6 +92,8 @@ class Agent(BaseModel):
     _model_name: str = PrivateAttr(default="")
     chat_system_prompt: str  # Base persona prompt for chat mode
     tool_mode: Optional[str] = None  # Tool or toolset to prioritize in chat mode
+    tracked_files: list[str] = []  # List to track files created or modified during execution
+    agent_mode: str = "react"  # Default mode is ReAct
 
     def __init__(
         self,
@@ -98,7 +101,7 @@ class Agent(BaseModel):
         memory: AgentMemory = AgentMemory(),
         variable_store: VariableMemory = VariableMemory(),
         tools: list[Tool] = [TaskCompleteTool()],
-        ask_for_user_validation: Callable[[str, str], Awaitable[bool]] = console_ask_for_user_validation,
+        ask_for_user_validation: Callable[[str, str], bool] = console_ask_for_user_validation,
         task_to_solve: str = "",
         specific_expertise: str = "General AI assistant with coding and problem-solving capabilities",
         get_environment: Callable[[], str] = get_environment,
@@ -107,6 +110,7 @@ class Agent(BaseModel):
         event_emitter: EventEmitter | None = None,
         chat_system_prompt: str | None = None,
         tool_mode: Optional[str] = None,
+        agent_mode: str = "react",
     ):
         """Initialize the agent with model, memory, tools, and configurations.
 
@@ -124,6 +128,7 @@ class Agent(BaseModel):
             event_emitter: EventEmitter instance for event handling
             chat_system_prompt: Optional base system prompt for chat mode persona
             tool_mode: Optional tool or toolset to prioritize in chat mode
+            agent_mode: Mode to use ("react" or "chat")
         """
         try:
             logger.debug("Initializing agent...")
@@ -140,8 +145,9 @@ class Agent(BaseModel):
             tools_markdown = tool_manager.to_markdown()
             logger.debug(f"Tools Markdown: {tools_markdown}")
 
+            logger.info(f"Agent mode: {agent_mode}")
             system_prompt_text = system_prompt(
-                tools=tools_markdown, environment=environment, expertise=specific_expertise
+                tools=tools_markdown, environment=environment, expertise=specific_expertise, agent_mode=agent_mode
             )
             logger.debug(f"System prompt: {system_prompt_text}")
 
@@ -151,7 +157,7 @@ class Agent(BaseModel):
                 system_prompt=system_prompt_text,
             )
 
-            chat_system_prompt = chat_system_prompt or (
+            chat_system_prompt = chat_system_prompt or specific_expertise or (
                 "You are a friendly, helpful AI assistant. Engage in natural conversation, "
                 "answer questions, and use tools when explicitly requested or when they enhance your response."
             )
@@ -178,6 +184,7 @@ class Agent(BaseModel):
                 max_tokens_working_memory=max_tokens_working_memory,
                 chat_system_prompt=chat_system_prompt,
                 tool_mode=tool_mode,
+                agent_mode=agent_mode,
             )
 
             self._model_name = model_name
@@ -301,7 +308,11 @@ class Agent(BaseModel):
                 current_prompt = result.next_prompt
 
                 if result.executed_tool == "task_complete":
-                    self._emit_event("task_complete", {"response": result.answer})
+                    self._emit_event("task_complete", {
+                        "response": result.answer,
+                        "message": "Task execution completed",
+                        "tracked_files": self.tracked_files if self.tracked_files else []
+                    })
                     answer = result.answer or ""
                     done = True
 
@@ -316,7 +327,12 @@ class Agent(BaseModel):
                 answer = f"Error: {str(e)}"
                 done = True
 
-        self._emit_event("task_solve_end")
+        task_solve_end_data = {
+            "result": answer,
+            "message": "Task execution completed",
+            "tracked_files": self.tracked_files if self.tracked_files else []
+        }
+        self._emit_event("task_solve_end", task_solve_end_data)
         return answer
 
     def chat(
@@ -374,6 +390,7 @@ class Agent(BaseModel):
 
         # Prepare chat system prompt with tool information
         tools_prompt = self._get_tools_names_prompt()
+        logger.debug(tools_prompt)
         if self.tool_mode:
             tools_prompt += f"\nPrioritized tool mode: {self.tool_mode}. Prefer tools related to {self.tool_mode} when applicable."
 
@@ -472,6 +489,170 @@ class Agent(BaseModel):
         self._emit_event("chat_response", {"response": response_content})
         return response_content
 
+
+    def chat_news_specific(
+        self,
+        message: str,
+        streaming: bool = False,
+        clear_memory: bool = False,
+        auto_tool_call: bool = True,
+    ) -> str:
+        """Engage in a conversational chat_news_specific with the user (synchronous version).
+
+        Ideal for synchronous applications. For asynchronous contexts, use `async_chat_news_specific`.
+
+        Args:
+            message: The user's input message
+            streaming: Whether to stream the response
+            clear_memory: Whether to clear memory before starting
+            auto_tool_call: Whether to automatically execute detected tool calls and interpret results
+
+        Returns:
+            The assistant's response
+        """
+        logger.debug(f"chat_news_specificting synchronously with message: {message}, auto_tool_call: {auto_tool_call}")
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+        return loop.run_until_complete(self.async_chat_news_specific(message, streaming, clear_memory, auto_tool_call))
+
+    async def async_chat_news_specific(
+        self,
+        message: str,
+        streaming: bool = False,
+        clear_memory: bool = False,
+        auto_tool_call: bool = True,
+    ) -> str:
+        """Engage in a conversational chat with the user (asynchronous version).
+
+        Ideal for asynchronous applications. For synchronous contexts, use `chat`.
+
+        Args:
+            message: The user's input message
+            streaming: Whether to stream the response
+            clear_memory: Whether to clear memory before starting
+            auto_tool_call: Whether to automatically execute detected tool calls and interpret results
+
+        Returns:
+            The assistant's response
+        """
+        logger.debug(f"Chatting asynchronously with message: {message}, auto_tool_call: {auto_tool_call}")
+        if clear_memory:
+            self.clear_memory()
+
+        # Prepare chat system prompt with tool information
+        tools_prompt = self._get_tools_names_prompt()
+        logger.debug(tools_prompt)
+        if self.tool_mode:
+            tools_prompt += f"\nPrioritized tool mode: {self.tool_mode}. Prefer tools related to {self.tool_mode} when applicable."
+
+        full_chat_prompt = self._render_template(
+            'chat_system_prompt.j2',
+            persona=self.chat_system_prompt,
+            tools_prompt=tools_prompt
+        )
+
+        if not self.memory.memory or self.memory.memory[0].role != "system":
+            self.memory.add(Message(role="system", content=full_chat_prompt))
+
+        self._emit_event("chat_start", {"message": message})
+
+        # Add user message to memory
+        self.memory.add(Message(role="user", content=message))
+        self._update_total_tokens(self.memory.memory, "")
+
+        # Iterative tool usage with auto-execution
+        current_prompt = message
+        response_content = ""
+        max_tool_iterations = 5  # Prevent infinite tool loops
+        tool_iteration = 0
+
+        while tool_iteration < max_tool_iterations:
+            try:
+                if streaming:
+                    content = ""
+                    # When streaming is enabled, the GenerativeModel._async_stream_response method
+                    # already emits the stream_chunk events, so we don't need to emit them again here
+                    async_stream = await self.model.async_generate_with_history(
+                        messages_history=self.memory.memory,
+                        prompt=current_prompt,
+                        streaming=True,
+                    )
+                    # Just collect the chunks without re-emitting events
+                    async for chunk in async_stream:
+                        content += chunk
+                    response = ResponseStats(
+                        response=content,
+                        usage=TokenUsage(prompt_tokens=0, completion_tokens=0, total_tokens=0),
+                        model=self.model.model,
+                        finish_reason="stop",
+                    )
+                else:
+                    response = await self.model.async_generate_with_history(
+                        messages_history=self.memory.memory,
+                        prompt=current_prompt,
+                        streaming=False,
+                    )
+                    content = response.response
+
+                self.total_tokens = response.usage.total_tokens if not streaming else self.total_tokens
+
+                # Observe response for tool calls
+                observation = await self._async_observe_response(content)
+                if observation.executed_tool and auto_tool_call: 
+                    print("observation.executed_tool : ", observation.executed_tool)
+                    # If any news tool is used, return immediately
+                    if "googlenews" in observation.executed_tool.lower() or \
+                       "duckduckgo" in observation.executed_tool.lower() or \
+                       "duckduckgosearch" in observation.executed_tool.lower(): 
+                        self._emit_event("chat_response", {"response": observation.next_prompt})
+                        return observation.next_prompt
+                    # Tool was executed; process result and continue
+                    current_prompt = observation.next_prompt
+                    
+                    # In chat mode, format the response with clear tool call visualization
+                    if not self.task_to_solve.strip():  # We're in chat mode
+                        # Format the response to clearly show the tool call and result
+                        # Use a format that task_runner.py can parse and display nicely
+                        
+                        # For a cleaner look, insert a special delimiter that task_runner.py can recognize
+                        # to separate tool call from result
+                        response_content = f"{content}\n\n__TOOL_RESULT_SEPARATOR__{observation.executed_tool}__\n{observation.next_prompt}"
+                    else:
+                        # In task mode, keep the original behavior
+                        response_content = observation.next_prompt
+                    
+                    tool_iteration += 1
+                    self.memory.add(Message(role="assistant", content=content))  # Original tool call
+                    self.memory.add(Message(role="user", content=observation.next_prompt))  # Tool result
+                    logger.debug(f"Tool executed: {observation.executed_tool}, iteration: {tool_iteration}")
+                elif not observation.executed_tool and "<action>" in content and auto_tool_call:
+                    # Detected malformed tool call attempt; provide feedback and exit loop
+                    response_content = (
+                        f"{content}\n\n⚠️ Error: Invalid tool call format detected. "
+                        "Please use the exact XML structure as specified in the system prompt:\n"
+                        "```xml\n<action>\n<tool_name>\n  <parameter_name>value</parameter_name>\n</tool_name>\n</action>\n```"
+                    )
+                    break
+                else:
+                    # No tool executed or auto_tool_call is False; final response
+                    response_content = content
+                    break
+
+            except Exception as e:
+                logger.error(f"Error during async chat: {str(e)}")
+                response_content = f"Error: {str(e)}"
+                break
+
+        self._update_session_memory(message, response_content)
+        self._emit_event("chat_response", {"response": response_content})
+        return response_content
+
+
+
     def _observe_response(self, content: str, iteration: int = 1) -> ObserveResponseResult:
         """Analyze the assistant's response and determine next steps (synchronous wrapper).
 
@@ -535,11 +716,16 @@ class Agent(BaseModel):
                 if not executed_tool:
                     return self._handle_tool_execution_failure(response)
 
+                # Track files when write_file_tool or writefile is used
+                if (tool_name in ["write_file_tool", "writefile", "edit_whole_content", "replace_in_file", "replaceinfile", "EditWholeContent"]) and "file_path" in arguments_with_values:
+                    self._track_file(arguments_with_values["file_path"], tool_name)
+
                 variable_name = self.variable_store.add(response)
                 new_prompt = self._format_observation_response(response, executed_tool, variable_name, iteration)
 
                 # In chat mode, don't set answer; in task mode, set answer only for task_complete
                 is_task_complete_answer = executed_tool == "task_complete" and not is_chat_mode
+                
                 return ObserveResponseResult(
                     next_prompt=new_prompt,
                     executed_tool=executed_tool,
@@ -586,12 +772,12 @@ class Agent(BaseModel):
             logger.info(f"Tool '{tool_name}' requires validation.")
             validation_id = str(uuid.uuid4())
             logger.info(f"Validation ID: {validation_id}")
-
+            
             self._emit_event(
                 "tool_execute_validation_start",
                 {
                     "validation_id": validation_id,
-                    "tool_name": tool_name,
+                    "tool_name": tool_name, 
                     "arguments": arguments_with_values
                 },
             )
@@ -602,7 +788,7 @@ class Agent(BaseModel):
                 + "\n".join([f"    <{key}>{value}</{key}>" for key, value in arguments_with_values.items()])
                 + "\n</arguments>\nYes or No"
             )
-            permission_granted = await self.ask_for_user_validation(validation_id=validation_id, question=question_validation)
+            permission_granted = await self.ask_for_user_validation(validation_id, question_validation)
 
             self._emit_event(
                 "tool_execute_validation_end",
@@ -639,13 +825,14 @@ class Agent(BaseModel):
                 response = tool.execute(**converted_args)
                 
             # Post-process tool response if needed
-            response = self._post_process_tool_response(tool_name, response)
+            if (tool.need_post_process):
+                response = self._post_process_tool_response(tool_name, response) 
                     
             executed_tool = tool.name
         except Exception as e:
             response = f"Error executing tool: {tool_name}: {str(e)}\n"
             executed_tool = ""
-
+ 
         self._emit_event(
             "tool_execution_end", {"tool_name": tool_name, "arguments": arguments_with_values, "response": response}
         )
@@ -1311,21 +1498,45 @@ class Agent(BaseModel):
                                         
                                     required = "(required)" if param_info.get("required", False) else "(optional)"
                                     default = f" default: {param_info['default']}" if "default" in param_info else ""
-                                    param_desc = f"{param_name} {required}{default}"
+                                    param_type = param_info.get("type", "string")
+                                    param_desc = f"{param_name} ({param_type}) {required}{default}"
                                     params.append(param_desc)
                     except Exception as e:
                         logger.debug(f"Error parsing schema for {tool_name}: {str(e)}")
-                    
-                    # Special case for duckduckgo_tool
-                    if tool_name == "duckduckgo_tool" and not any(p.startswith("max_results ") for p in params):
-                        params.append("max_results (required) default: 5")
-                    
-                    # Special case for other search tools that might need max_results
-                    if "search" in tool_name.lower() and not any(p.startswith("max_results ") for p in params):
-                        params.append("max_results (optional) default: 5")
-                        
-                    param_str = ", ".join(params) if params else "No parameters required"
-                    tool_descriptions.append(f"{tool_name}: {param_str}")
+
+                    # Enhanced tool-specific parameter descriptions
+                    if tool_name == "googlenews":
+                        params = [
+                            "query (string, required) - The search query string",
+                            "language (string, optional) default: en - Language code (e.g., en, fr, es)",
+                            "period (string, optional) default: 7d - Time period (1d, 7d, 30d)",
+                            "max_results (integer, required) default: 5 - Number of results to return",
+                            "country (string, optional) default: US - Country code (e.g., US, GB, FR)",
+                            "sort_by (string, optional) default: relevance - Sort by (relevance, date)",
+                            "analyze (boolean, optional) default: False - Whether to analyze results"
+                        ]
+                    elif tool_name == "duckduckgosearch":
+                        params = [
+                            "query (string, required) - The search query string",
+                            "max_results (integer, required) default: 5 - Number of results to return",
+                            "time_period (string, optional) default: d - Time period (d: day, w: week, m: month)",
+                            "region (string, optional) default: wt-wt - Region code for search results"
+                        ]
+                    elif tool_name == "llm":
+                        params = [
+                            "system_prompt (string, required) - The persona or system prompt to guide the language model's behavior",
+                            "prompt (string, required) - The question to ask the language model. Supports interpolation with $var$ syntax",
+                            "temperature (float, required) default: 0.5 - Sampling temperature between 0.0 (no creativity) and 1.0 (full creativity)"
+                        ]
+                    elif tool_name == "task_complete":
+                        params = [
+                            "answer (string, required) - Your final answer or response to complete the task"
+                        ]
+                    elif "search" in tool_name.lower() and not params:
+                        params.append("max_results (integer, optional) default: 5 - Number of results to return")
+
+                    param_str = "\n  - ".join(params) if params else "No parameters required"
+                    tool_descriptions.append(f"{tool_name}:\n  - {param_str}")
                 except Exception as e:
                     logger.debug(f"Error processing tool {tool_name}: {str(e)}")
                     # Still include the tool in the list, but with minimal info
@@ -1468,4 +1679,37 @@ class Agent(BaseModel):
             return template.render(**kwargs)
         except Exception as e:
             logger.error(f"Error rendering template {template_name}: {str(e)}")
-            raise
+            raise
+
+    def _track_file(self, file_path: str, tool_name: str) -> None:
+        """Track files created or modified by tools.
+        
+        Args:
+            file_path: Path to the file to track
+            tool_name: Name of the tool that created/modified the file
+        """
+        try:
+            # Handle /tmp directory for write tools
+            if tool_name in ["write_file_tool", "writefile", "edit_whole_content", "replace_in_file", "replaceinfile", "EditWholeContent"]:
+                if not file_path.startswith("/tmp/"):
+                    file_path = os.path.join("/tmp", file_path.lstrip("/"))
+            
+            # For other tools, ensure we have absolute path
+            elif not os.path.isabs(file_path):
+                file_path = os.path.abspath(os.path.join(os.getcwd(), file_path))
+            
+            # Resolve any . or .. in the path
+            tracked_path = os.path.realpath(file_path)
+            
+            # For write tools, ensure path is in /tmp
+            if tool_name in ["write_file_tool", "writefile"] and not tracked_path.startswith("/tmp/"):
+                logger.warning(f"Attempted to track file outside /tmp: {tracked_path}")
+                return
+                
+            # Add to tracked files if not already present
+            if tracked_path not in self.tracked_files:
+                self.tracked_files.append(tracked_path)
+                logger.debug(f"Added {tracked_path} to tracked files")
+                
+        except Exception as e:
+            logger.error(f"Error tracking file {file_path}: {str(e)}")

quantalogic/create_custom_agent.py

@@ -10,11 +10,15 @@ from quantalogic.console_print_token import console_print_token
 from quantalogic.event_emitter import EventEmitter
 from quantalogic.tools.tool import Tool
 
-# Configure loguru to output debug messages
+# Configure loguru to output only INFO and above
 logger.remove()  # Remove default handler
-logger.add(sink=lambda msg: print(msg, end=""), level="DEBUG")  # Add a new handler that prints to console
-
+logger.add(
+    sink=lambda msg: print(msg, end=""),
+    level="INFO",
+    format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>"
+)
 
+# Helper function to import tool classes
 def _import_tool(module_path: str, class_name: str) -> Type[Tool]:
     """
     Import a tool class from a module path using standard Python imports.
@@ -78,6 +82,7 @@ TOOL_IMPORTS = {
     # File Tools
     "download_http_file": lambda: _import_tool("quantalogic.tools.utilities", "PrepareDownloadTool"),
     "write_file": lambda: _import_tool("quantalogic.tools.write_file_tool", "WriteFileTool"),
+    "file_tracker": lambda: _import_tool("quantalogic.tools.file_tracker_tool", "FileTrackerTool"),
     "edit_whole_content": lambda: _import_tool("quantalogic.tools", "EditWholeContentTool"),
     "read_file_block": lambda: _import_tool("quantalogic.tools", "ReadFileBlockTool"),
     "read_file": lambda: _import_tool("quantalogic.tools", "ReadFileTool"),
@@ -128,14 +133,15 @@ TOOL_IMPORTS = {
     # Product Hunt Tools
     "product_hunt_tool": lambda: _import_tool("quantalogic.tools.product_hunt", "ProductHuntTool"),
     
-    # RAG Tools
-    "rag_tool": lambda: _import_tool("quantalogic.tools.rag_tool", "RagTool"),
+    # RAG Tools 
+    "rag_tool_hf": lambda: _import_tool("quantalogic.tools.rag_tool", "RagToolHf"),
     
     # Utility Tools
     "task_complete": lambda: _import_tool("quantalogic.tools.task_complete_tool", "TaskCompleteTool"),
     "input_question": lambda: _import_tool("quantalogic.tools.utilities", "InputQuestionTool"),
     "markitdown": lambda: _import_tool("quantalogic.tools.utilities", "MarkitdownTool"),
-    "read_html": lambda: _import_tool("quantalogic.tools.utilities", "ReadHTMLTool"),
+    "read_html": lambda: _import_tool("quantalogic.tools.read_html_tool", "ReadHTMLTool"),
+    "oriented_llm_tool": lambda: _import_tool("quantalogic.tools.utilities", "OrientedLLMTool"),
     "presentation_llm": lambda: _import_tool("quantalogic.tools.presentation_tools", "PresentationLLMTool"),
     "sequence": lambda: _import_tool("quantalogic.tools.utilities", "SequenceTool"),
     "csv_processor": lambda: _import_tool("quantalogic.tools.utilities", "CSVProcessorTool"),
@@ -152,7 +158,8 @@ def create_custom_agent(
     max_tokens_working_memory: Optional[int] = None,
     specific_expertise: str = "",
     tools: Optional[list[dict[str, Any]]] = None,
-    memory: Optional[AgentMemory] = None
+    memory: Optional[AgentMemory] = None,
+    agent_mode: str = "react"
 ) -> Agent:
     """Create an agent with lazy-loaded tools and graceful error handling.
 
@@ -169,6 +176,8 @@ def create_custom_agent(
     Returns:
         Agent: Configured agent instance
     """
+    logger.info("Creating custom agent with model: {}".format(model_name))
+    logger.info("tools: {}".format(tools))
     # Create storage directory for RAG
     storage_dir = os.path.join(os.path.dirname(__file__), "storage", "rag")
     os.makedirs(storage_dir, exist_ok=True)
@@ -188,8 +197,9 @@ def create_custom_agent(
     tool_configs = {
         # LLM Tools with shared parameters
         "llm": lambda params: create_tool_instance(TOOL_IMPORTS["llm"](), **get_llm_params(params)),
+        "oriented_llm_tool": lambda params: create_tool_instance(TOOL_IMPORTS["oriented_llm_tool"](), **get_llm_params(params)),
         "llm_vision": lambda params: create_tool_instance(TOOL_IMPORTS["llm_vision"](),
-            model_name=params.get("vision_model_name") or vision_model_name,
+            model_name=params.get("vision_model_name") or "gpt-4-vision",
             on_token=console_print_token if not no_stream else None,
             event_emitter=event_emitter
         ) if vision_model_name else None,
@@ -203,6 +213,7 @@ def create_custom_agent(
         "download_http_file": lambda _: create_tool_instance(TOOL_IMPORTS["download_http_file"]()),
         "duck_duck_go_search": lambda _: create_tool_instance(TOOL_IMPORTS["duck_duck_go_search"]()),
         "write_file": lambda _: create_tool_instance(TOOL_IMPORTS["write_file"]()),
+        "file_tracker": lambda _: create_tool_instance(TOOL_IMPORTS["file_tracker"]()),
         "task_complete": lambda _: create_tool_instance(TOOL_IMPORTS["task_complete"]()),
         "edit_whole_content": lambda _: create_tool_instance(TOOL_IMPORTS["edit_whole_content"]()),
         "execute_bash_command": lambda _: create_tool_instance(TOOL_IMPORTS["execute_bash_command"]()),
@@ -296,11 +307,12 @@ def create_custom_agent(
         "nasa_apod_tool": lambda _: create_tool_instance(TOOL_IMPORTS["nasa_apod_tool"]()),
         "product_hunt_tool": lambda _: create_tool_instance(TOOL_IMPORTS["product_hunt_tool"]()),
         
-        # RAG tool
-        "rag_tool": lambda params: create_tool_instance(TOOL_IMPORTS["rag_tool"](),
-            vector_store=params.get("vector_store", "chroma"),
-            embedding_model=params.get("embedding_model", "openai"),
-            persist_dir=storage_dir,
+        # Multilingual RAG tool
+        "rag_tool_hf": lambda params: create_tool_instance(TOOL_IMPORTS["rag_tool_hf"](),
+            persist_dir=params.get("persist_dir", "./storage/multilingual_rag"),
+            use_ocr_for_pdfs=params.get("use_ocr_for_pdfs", False),
+            ocr_model=params.get("ocr_model", "openai/gpt-4o-mini"),
+            embed_model=params.get("embed_model", "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"),
             document_paths=params.get("document_paths", [])
         ),
         
@@ -357,26 +369,6 @@ def create_custom_agent(
             else:
                 logger.warning(f"Unknown tool type: {tool_type} - Skipping")
 
-    # Add download tool if any write tool is present
-    if has_write_tool:
-        try:
-            # Get the tool class first
-            download_tool_class = TOOL_IMPORTS["download_file_tool"]()
-            if download_tool_class:
-                # Create an instance with the name 'download'
-                download_tool = create_tool_instance(download_tool_class, name="download")
-                if download_tool:
-                    agent_tools.append(download_tool)
-                    logger.info("Added download tool automatically due to write tool presence")
-                else:
-                    logger.warning("Failed to instantiate download tool")
-            else:
-                logger.warning("Download tool class not found")
-        except ImportError as e:
-            logger.warning(f"Failed to load download tool: Required library missing - {str(e)}")
-        except Exception as e:
-            logger.error(f"Failed to add download tool: {str(e)}")
-
 
     # Create and return the agent
     try:
@@ -388,52 +380,8 @@ def create_custom_agent(
             max_tokens_working_memory=max_tokens_working_memory,
             specific_expertise=specific_expertise,
             memory=memory if memory else AgentMemory(),
+            agent_mode=agent_mode
         )
     except Exception as e:
         logger.error(f"Failed to create agent: {str(e)}")
         raise
-
-if __name__ == "__main__":
-    # Example usage
-    tools_config = [
-        {"type": "duck_duck_go_search", "parameters": {}},
-    ]
-    
-    agent = create_custom_agent(
-        model_name="openrouter/openai/gpt-4o-mini",
-        specific_expertise="General purpose assistant",
-        tools=tools_config
-    )
-    print(f"Created agent with {len(agent.tools.tool_names())} tools")
-    
-    # Display all tool names
-    print("Agent Tools:")
-    for tool_name in agent.tools.tool_names():
-        print(f"- {tool_name}")
-
-    # Set up event monitoring to track agent's lifecycle
-    # The event system provides:
-    # 1. Real-time observability into the agent's operations
-    # 2. Debugging and performance monitoring
-    # 3. Support for future analytics and optimization efforts
-    agent.event_emitter.on(
-        event=[
-            "task_complete",
-            "task_think_start",
-            "task_think_end",
-            "tool_execution_start",
-            "tool_execution_end",
-            "error_max_iterations_reached",
-            "memory_full",
-            "memory_compacted",
-            "memory_summary",
-        ],
-        listener=console_print_events,
-    )
-
-    # Enable token streaming for detailed output
-    agent.event_emitter.on(event=["stream_chunk"], listener=console_print_token)
-
-    # Solve task with streaming enabled
-    result = agent.solve_task("Who is the Prime Minister of France in 2025 ?", max_iterations=10, streaming=True)
-    print(result)

quantalogic/prompts/chat_system_prompt.j2

@@ -22,13 +22,17 @@ Tools must be called using the following XML format, with NO additional text:
 
 #### Examples of Correct Tool Usage
 
-**Example 1 - Search Tool:**
+**Example 1 - Duck Duck Go search tool:**
 ```xml
 <action>
-<duckduckgo_tool>
-  <query>search query text</query>
-  <max_results>5</max_results>  <!-- Always include max_results for search -->
-</duckduckgo_tool>
+<duckduckgosearch>
+  <query>machine learning</query>
+  <max_results>20</max_results>
+  <search_type>images</search_type>
+  <region>us-en</region>
+  <safesearch>moderate</safesearch>
+  <timelimit>d</timelimit>
+</duckduckgosearch>
 </action>
 ```
 
@@ -50,5 +54,4 @@ Tools must be called using the following XML format, with NO additional text:
 **Tools Available**: None
 {% endif %}
 
-Don't invent tools that are not listed.
-
+Don't invent tools that are not listed.