Updates to make LLM config dict[str,Any]

.gitignore

@@ -161,4 +161,5 @@ requirements.txt
 Pipfile
 
 # file containing LLM config for the agents
-agents_llm_config.json
+agents_llm_config.json
+ae/testing.py

ae/core/agents_llm_config.py

@@ -31,10 +31,11 @@ class AgentsLLMConfig:
         "model_base_url": "base_url",
     }
 
-    def __init__(self, env_file_path: str = ".env", config_string: Optional[str] = None) -> None:
+    def __init__(self, env_file_path: str = ".env", llm_config: Optional[dict[str,Any] | None] = None) -> None:
         load_dotenv(env_file_path, verbose=True, override=True)
-        if config_string:
-            self.config: dict[str, Any] = self.load_config_from_string(config_string)
+        if llm_config:
+
+            self.config: dict[str, Any] = self.load_config_from_api(llm_config)
         else:
             self.config: dict[str, Any] = self._load_config()
 
@@ -54,8 +55,8 @@ def _load_config(self) -> dict[str, Any]:
                         raw_config = file_config[config_file_ref_key]
 
                         # Process configurations for both planner_agent and browser_nav_agent
-                        planner_config = self._normalize_config_from_file(raw_config.get("planner_agent", {}))
-                        browser_nav_config = self._normalize_config_from_file(raw_config.get("browser_nav_agent", {}))
+                        planner_config = self._normalize_config(raw_config.get("planner_agent", {}))
+                        browser_nav_config = self._normalize_config(raw_config.get("browser_nav_agent", {}))
 
                         config = {
                             "planner_agent": planner_config,
@@ -85,32 +86,32 @@ def _load_config(self) -> dict[str, Any]:
 
         return config
 
-    def load_config_from_string(self, config_string: str) -> dict[str, Any]:
+    def load_config_from_api(self, llm_config: dict[str, Any]) -> dict[str, Any]:
             """
-            Load configuration from a JSON string.
+            Load configuration from a JSON provided during execution.
 
             Parameters
             ----------
-            config_string : str
-                A JSON string representing the configuration.
+            config_string : dict[str,Any]
+                A JSON representing the configuration.
 
             Returns
             -------
             dict[str, Any]
                 The loaded and normalized configuration.
             """
             try:
-                raw_config = json.loads(config_string)
+
                 logger.info("Loading configuration from provided string")
 
                 # Process configurations for both planner_agent and browser_nav_agent
-                planner_config = self._normalize_config_from_file(raw_config.get("planner_agent", {}))
-                browser_nav_config = self._normalize_config_from_file(raw_config.get("browser_nav_agent", {}))
+                planner_config = self._normalize_config(llm_config.get("planner_agent", {}))
+                browser_nav_config = self._normalize_config(llm_config.get("browser_nav_agent", {}))
 
                 config = {
                     "planner_agent": planner_config,
                     "browser_nav_agent": browser_nav_config,
-                    "other_settings": {k: v for k, v in raw_config.items() if k not in ["planner_agent", "browser_nav_agent"]},
+                    "other_settings": {k: v for k, v in llm_config.items() if k not in ["planner_agent", "browser_nav_agent"]},
                 }
 
                 return config
@@ -119,7 +120,7 @@ def load_config_from_string(self, config_string: str) -> dict[str, Any]:
                 logger.error(f"Error decoding JSON string: {e}")
                 raise e
 
-    def _normalize_config_from_file(self, agent_config: dict[str, Any]) -> dict[str, Any]:
+    def _normalize_config(self, agent_config: dict[str, Any]) -> dict[str, Any]:
         """Normalize agent-specific config from a file, grouping keys into model_config_params, llm_config_params, and other_settings."""
         model_config = {}
         llm_config_params = {}

ae/server/api_routes.py

@@ -1,7 +1,9 @@
+from ast import Dict
 import asyncio
 import json
 import logging
 import os
+from typing import Any
 import uuid
 from queue import Empty
 from queue import Queue
@@ -38,7 +40,7 @@
 
 class CommandQueryModel(BaseModel):
     command: str = Field(..., description="The command related to web navigation to execute.")  # Required field with description
-    llm_config: str | None = Field(None, description="The LLM configuration string to use for the agents.")
+    llm_config: dict[str,Any] | None = Field(None, description="The LLM configuration string to use for the agents.")
     clientid: str | None = Field(None, description="Client identifier, optional")
     request_originator: str | None = Field(None, description="Optional id of the request originator")
 
@@ -73,10 +75,11 @@ async def execute_task(request: Request, query_model: CommandQueryModel):
     notification_queue = Queue()  # type: ignore
     transaction_id = str(uuid.uuid4()) if query_model.clientid is None else query_model.clientid
     register_notification_listener(notification_queue)
+    print(f"Config: {transaction_id}")
     return StreamingResponse(run_task(request, transaction_id, query_model.command, browser_manager, notification_queue, query_model.request_originator, query_model.llm_config), media_type="text/event-stream")
 
 
-def run_task(request: Request, transaction_id: str, command: str, playwright_manager: browserManager.PlaywrightManager, notification_queue: Queue, request_originator: str|None = None, llm_config: str|None = None):  # type: ignore
+def run_task(request: Request, transaction_id: str, command: str, playwright_manager: browserManager.PlaywrightManager, notification_queue: Queue, request_originator: str|None = None, llm_config: dict[str,Any]|None = None):  # type: ignore
     """
     Run the task to process the command and generate events.
 
@@ -123,27 +126,30 @@ async def event_generator():
 
 
 
-async def process_command(command: str, playwright_manager: browserManager.PlaywrightManager, config_string:str|None = None):
+async def process_command(command: str, playwright_manager: browserManager.PlaywrightManager, llm_config:dict[str,Any]|None = None):
     """
     Process the command and send notifications.
 
     Args:
         command (str): The command to process.
         playwright_manager (PlaywrightManager): The manager handling browser interactions and notifications.
     """
+    print(f"LLM Config via API : {llm_config}")
     await playwright_manager.go_to_homepage() # Go to the homepage before processing the command
     current_url = await playwright_manager.get_current_url()
     await playwright_manager.notify_user("Processing command", MessageType.INFO)
 
     # Load the configuration using AgentsLLMConfig
-    if config_string is None:
-        llm_config = AgentsLLMConfig()
+    normalized_llm_config = None
+    if llm_config is None:
+        normalized_llm_config = AgentsLLMConfig()
     else:
-        llm_config = AgentsLLMConfig(config_string=config_string)
+        print("Applying LLM Config")
+        normalized_llm_config = AgentsLLMConfig(llm_config=llm_config)
 
     # Retrieve planner agent and browser nav agent configurations
-    planner_agent_config = llm_config.get_planner_agent_config()
-    browser_nav_agent_config = llm_config.get_browser_nav_agent_config()
+    planner_agent_config = normalized_llm_config.get_planner_agent_config()
+    browser_nav_agent_config = normalized_llm_config.get_browser_nav_agent_config()
 
     ag = await AutogenWrapper.create(planner_agent_config, browser_nav_agent_config)
     command_exec_result = await ag.process_command(command, current_url)  # type: ignore