Fix passing of client configs in settings (#309)

Author: husseinmozannar

frontend/src/components/settings.tsx

@@ -136,7 +136,7 @@ def run_ui(
         appdir (str, optional): Path to the app directory where files are stored. Defaults to ~/.magentic_ui.
         database_uri (str, optional): Database URI to connect to. Defaults to None.
         upgrade_database (bool, optional): Whether to upgrade the database schema. Defaults to False.
-        config (str, optional): Path to the config file. Defaults to config.yaml if present.
+        config (str, optional): Path to the LLM config file. Defaults to config.yaml if present.
         run_without_docker (bool, optional): Run without docker. This will remove coder and filesurfer agents and disale live browser view. Defaults to False.
     """
     # Display a green, bold "Starting Magentic-UI" message

src/magentic_ui/backend/cli.py

@@ -189,7 +189,7 @@ class Settings(SQLModel, table=True):
         default_factory=datetime.now,
         sa_column=Column(DateTime(timezone=True), onupdate=func.now()),
     )  # pylint: disable=not-callable
-    user_id: Optional[str] = None
+    user_id: Optional[str] = Field(default=None, unique=True)
     version: Optional[str] = "0.0.1"
     config: Union[SettingsConfig, dict[str, Any]] = Field(
         default_factory=lambda: SettingsConfig().model_dump(), sa_column=Column(JSON)

src/magentic_ui/backend/datamodel/db.py

@@ -5,7 +5,7 @@
 from autogen_agentchat.base import TaskResult
 from autogen_agentchat.messages import BaseChatMessage, BaseTextChatMessage
 from autogen_core import ComponentModel
-from pydantic import BaseModel, Field, field_serializer
+from pydantic import BaseModel, field_serializer
 
 
 class MessageConfig(BaseModel):
@@ -87,9 +87,8 @@ class UISettings(BaseModel):
 
 
 class SettingsConfig(BaseModel):
-    # Backend-specific settings only
-    environment: List[EnvironmentVariable] = []
-    ui: UISettings = Field(default_factory=UISettings)
+    # empty starting point
+    pass
 
 
 # web request/response data models

src/magentic_ui/backend/datamodel/types.py

@@ -17,15 +17,12 @@
     Sequence,
     Union,
 )
-import aiofiles
-import yaml
 from loguru import logger
 from autogen_agentchat.base import ChatAgent, TaskResult, Team
 from autogen_agentchat.messages import AgentEvent, ChatMessage, TextMessage
 from autogen_core import EVENT_LOGGER_NAME, CancellationToken, ComponentModel
 from autogen_core.logging import LLMCallEvent
 from ...task_team import get_task_team
-from ...teams import GroupChat
 from ...types import RunPaths
 from ...magentic_ui_config import MagenticUIConfig, ModelClientConfigs
 from ...input_func import InputFuncType
@@ -73,17 +70,9 @@ def __init__(
     @staticmethod
     async def load_from_file(path: Union[str, Path]) -> Dict[str, Any]:
         """Load team configuration from JSON/YAML file"""
-        path = Path(path)
-        if not path.exists():
-            raise FileNotFoundError(f"Config file not found: {path}")
-
-        async with aiofiles.open(path) as f:  # type: ignore
-            content = await f.read()
-            if path.suffix == ".json":
-                return json.loads(content)
-            elif path.suffix in (".yml", ".yaml"):
-                return yaml.safe_load(content)
-            raise ValueError(f"Unsupported file format: {path.suffix}")
+        raise NotImplementedError(
+            "This method should be implemented in a subclass or replaced with actual loading logic."
+        )
 
     def prepare_run_paths(
         self,
@@ -178,19 +167,9 @@ def add_uploaded_files(self, file_names: set[str]) -> None:
     @staticmethod
     async def load_from_directory(directory: Union[str, Path]) -> List[Dict[str, Any]]:
         """Load all team configurations from a directory"""
-        directory = Path(directory)
-        configs: List[Dict[str, Any]] = []
-        valid_extensions = {".json", ".yaml", ".yml"}
-
-        for path in directory.iterdir():
-            if path.is_file() and path.suffix.lower() in valid_extensions:
-                try:
-                    config = await TeamManager.load_from_file(path)
-                    configs.append(config)
-                except Exception as e:
-                    logger.error(f"Failed to load {path}: {e}")
-
-        return configs
+        raise NotImplementedError(
+            "This method should be implemented in a subclass or replaced with actual loading logic."
+        )
 
     async def _create_team(
         self,
@@ -212,123 +191,86 @@ async def _create_team(
             playwright_port = -1
 
         try:
-            if not self.load_from_config:
-                # The settings_config dictionary provides the Model configs in a key `model_configs`
-                # But MagenticUIConfig expects `model_client_configs` so we need to update that here
-                settings_model_configs: Dict[str, Any] = {}
-                if "model_configs" in settings_config:
-                    try:
-                        settings_model_configs = yaml.safe_load(
-                            settings_config["model_configs"]
-                        )
-                    except Exception as e:
-                        logger.warning(
-                            f"Error loading model configs from UI. Using defaults. Inner exception: {e}"
-                        )
+            # Logic here: we first see if the config file passed to magentic-ui has valid configs for all clients
+            # If Yes: this takes precedent over the UI LLM config and is passed to magentic-ui team
+            # If No: we disregard it and use the UI LLM config
+            model_client_from_config_file = ModelClientConfigs(
+                orchestrator=self.config.get("orchestrator_client", None),
+                web_surfer=self.config.get("web_surfer_client", None),
+                coder=self.config.get("coder_client", None),
+                file_surfer=self.config.get("file_surfer_client", None),
+                action_guard=self.config.get("action_guard_client", None),
+            )
+            is_complete_config_from_file = all(
+                [
+                    model_client_from_config_file.orchestrator,
+                    model_client_from_config_file.web_surfer,
+                    model_client_from_config_file.coder,
+                    model_client_from_config_file.file_surfer,
+                    model_client_from_config_file.action_guard,
+                ]
+            )
 
-                # Use settings_config values if available, otherwise fall back to instance defaults (self.config)
-                model_client_configs = ModelClientConfigs(
-                    orchestrator=settings_model_configs.get(
-                        "orchestrator_client",
-                        self.config.get("orchestrator_client", None),
-                    ),
-                    web_surfer=settings_model_configs.get(
-                        "web_surfer_client",
-                        self.config.get("web_surfer_client", None),
-                    ),
-                    coder=settings_model_configs.get(
-                        "coder_client", self.config.get("coder_client", None)
-                    ),
-                    file_surfer=settings_model_configs.get(
-                        "file_surfer_client",
-                        self.config.get("file_surfer_client", None),
-                    ),
-                    action_guard=settings_model_configs.get(
-                        "action_guard_client",
-                        self.config.get("action_guard_client", None),
-                    ),
+            # Common configuration parameters
+            config_params = {
+                **settings_config,  # type: ignore,
+                # These must always be set to the values computed above
+                "playwright_port": playwright_port,
+                "novnc_port": novnc_port,
+                # Defer to self for inside_docker
+                "inside_docker": self.inside_docker,
+            }
+
+            # Override client configs if complete config from file is available
+            if is_complete_config_from_file:
+                config_params["model_client_configs"] = model_client_from_config_file
+            else:
+                logger.warning(
+                    "Using LLM client configurations from UI settings (default is OpenAI) since no config file passed or config file incomplete."
                 )
-
-                config_params = {
-                    # Lowest priority defaults
-                    **self.config,  # type: ignore
-                    # Provided settings override defaults
-                    **settings_config,  # type: ignore,
-                    "model_client_configs": model_client_configs,
-                    # These must always be set to the values computed above
-                    "playwright_port": playwright_port,
-                    "novnc_port": novnc_port,
-                    # Defer to self for inside_docker
-                    "inside_docker": self.inside_docker,
-                }
-                if self.run_without_docker:
-                    config_params["run_without_docker"] = True
-                    # Allow browser_headless to be set by settings_config
+            if self.run_without_docker:
+                config_params["run_without_docker"] = True
+                # Allow browser_headless to be set by settings_config
+            else:
+                if settings_config.get("run_without_docker", False):
+                    # Allow settings_config to set browser_headless
+                    pass
                 else:
-                    if settings_config.get("run_without_docker", False):
-                        # Allow settings_config to set browser_headless
+                    config_params["browser_headless"] = False
+            magentic_ui_config = MagenticUIConfig(**config_params)  # type: ignore
+            self.team = cast(
+                Team,
+                await get_task_team(
+                    magentic_ui_config=magentic_ui_config,
+                    input_func=input_func,
+                    paths=paths,
+                ),
+            )
+            if hasattr(self.team, "_participants"):
+                for agent in cast(list[ChatAgent], self.team._participants):  # type: ignore
+                    if isinstance(agent, WebSurfer):
+                        novnc_port = agent.novnc_port
+                        playwright_port = agent.playwright_port
+
+            if state:
+                if isinstance(state, str):
+                    # Check if the string is empty or whitespace only
+                    if not state.strip():
+                        # Skip loading if state is empty
                         pass
                     else:
-                        config_params["browser_headless"] = False
-                magentic_ui_config = MagenticUIConfig(**config_params)  # type: ignore
-
-                self.team = cast(
-                    Team,
-                    await get_task_team(
-                        magentic_ui_config=magentic_ui_config,
-                        input_func=input_func,
-                        paths=paths,
-                    ),
-                )
-                if hasattr(self.team, "_participants"):
-                    for agent in cast(list[ChatAgent], self.team._participants):  # type: ignore
-                        if isinstance(agent, WebSurfer):
-                            novnc_port = agent.novnc_port
-                            playwright_port = agent.playwright_port
-
-                if state:
-                    if isinstance(state, str):
-                        # Check if the string is empty or whitespace only
-                        if not state.strip():
-                            # Skip loading if state is empty
-                            pass
-                        else:
-                            try:
-                                state_dict = json.loads(state)
-                                await self.team.load_state(state_dict)
-                            except json.JSONDecodeError as json_error:
-                                # Log error and skip loading invalid JSON state
-                                logger.warning(
-                                    f"Warning: Failed to load state - invalid JSON: {json_error}"
-                                )
-
-                    else:
-                        await self.team.load_state(state)
-
-                return self.team, novnc_port, playwright_port
-
-            if isinstance(team_config, (str, Path)):
-                config = await self.load_from_file(team_config)
-            elif isinstance(team_config, dict):
-                config = team_config
-            else:
-                config = team_config.model_dump()
-
-            # Load env vars into environment if provided
-            if env_vars:
-                logger.info("Loading environment variables")
-                for var in env_vars:
-                    os.environ[var.name] = var.value
+                        try:
+                            state_dict = json.loads(state)
+                            await self.team.load_state(state_dict)
+                        except json.JSONDecodeError as json_error:
+                            # Log error and skip loading invalid JSON state
+                            logger.warning(
+                                f"Warning: Failed to load state - invalid JSON: {json_error}"
+                            )
 
-            self.team = cast(Team, GroupChat.load_component(config))
+                else:
+                    await self.team.load_state(state)
 
-            if hasattr(self.team, "_participants"):
-                for agent in cast(list[ChatAgent], self.team._participants):  # type: ignore
-                    if hasattr(agent, "input_func"):
-                        agent.input_func = input_func  # type: ignore
-                    if isinstance(agent, WebSurfer):
-                        novnc_port = agent.novnc_port or -1
-                        playwright_port = agent.playwright_port or -1
             return self.team, novnc_port, playwright_port
         except Exception as e:
             logger.error(f"Error creating team: {e}")

src/magentic_ui/backend/teammanager/teammanager.py

@@ -82,11 +82,6 @@ async def init_managers(
         _db_manager = DatabaseManager(engine_uri=database_uri, base_dir=app_root)
         _db_manager.initialize_database(auto_upgrade=settings.UPGRADE_DATABASE)
 
-        # init default team config
-        await _db_manager.import_teams_from_directory(
-            config_dir, settings.DEFAULT_USER_ID, check_exists=True
-        )
-
         # Initialize connection manager
         _websocket_manager = WebSocketManager(
             db_manager=_db_manager,

src/magentic_ui/backend/web/deps.py

@@ -30,7 +30,6 @@
     Run,
     RunStatus,
     Settings,
-    SettingsConfig,
     TeamResult,
 )
 from ...teammanager import TeamManager
@@ -157,13 +156,7 @@ async def start_stream(
             assert run is not None, f"Run {run_id} not found in database"
             assert run.user_id is not None, f"Run {run_id} has no user ID"
 
-            # Get user Settings
-            user_settings = await self._get_settings(run.user_id)
-            env_vars = (
-                SettingsConfig(**user_settings.config).environment  # type: ignore
-                if user_settings
-                else None
-            )
+            env_vars = None
 
             settings_config["memory_controller_key"] = run.user_id
 

src/magentic_ui/backend/web/managers/connection.py

@@ -11,27 +11,43 @@
 router = APIRouter()
 
 
+def _get_or_create_settings(user_id: str, db) -> Settings:
+    """Get existing settings or create default ones for user_id"""
+    response = db.get(Settings, filters={"user_id": user_id})
+    if response.status and response.data:
+        return response.data[0]
+
+    # Create default settings
+    default_settings = Settings(user_id=user_id)
+    upsert_response = db.upsert(default_settings)
+    if not upsert_response.status:
+        raise HTTPException(status_code=500, detail=upsert_response.message)
+
+    return upsert_response.data
+
+
 @router.get("/")
 async def get_settings(user_id: str, db=Depends(get_db)) -> Dict:
     try:
-        response = db.get(Settings, filters={"user_id": user_id})
-        if not response.status or not response.data:
-            # create a default settings - let the model use its default factory
-            default_settings = Settings(user_id=user_id)
-            db.upsert(default_settings)
-            response = db.get(Settings, filters={"user_id": user_id})
-        # print(response.data[0])
-        return {"status": True, "data": response.data[0]}
+        settings = _get_or_create_settings(user_id, db)
+        return {"status": True, "data": settings}
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e)) from e
 
 
 @router.put("/")
 async def update_settings(settings: Settings, db=Depends(get_db)) -> Dict:
-    response = db.upsert(settings)
-    if not response.status:
-        raise HTTPException(status_code=400, detail=response.message)
-    return {"status": True, "data": response.data}
+    try:
+        # Get existing settings to preserve the id
+        existing = _get_or_create_settings(settings.user_id, db)
+        settings.id = existing.id if hasattr(existing, "id") else existing["id"]
+
+        response = db.upsert(settings)
+        if not response.status:
+            raise HTTPException(status_code=400, detail=response.message)
+        return {"status": True, "data": response.data}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e)) from e
 
 
 @router.get("/config-info")

src/magentic_ui/backend/web/routes/settingsroute.py

@@ -1,3 +1,3 @@
-VERSION = "0.1.1"
+VERSION = "0.1.2"
 __version__ = VERSION
 APP_NAME = "Magentic-UI"