refactor: various config cleanups

Author: bassmang

samples/task_centric_memory.py

@@ -1,7 +1,8 @@
 import asyncio
 from autogen_agentchat.ui import Console
 from autogen_ext.models.openai import OpenAIChatCompletionClient
-from magentic_ui import OrchestratorConfig, get_task_team
+from magentic_ui.teams.orchestrator.orchestrator_config import OrchestratorConfig
+from magentic_ui import get_task_team
 from magentic_ui.types import Plan
 from autogen_ext.experimental.task_centric_memory import MemoryController
 from autogen_ext.experimental.task_centric_memory.utils import PageLogger

src/magentic_ui/__init__.py

@@ -1,5 +1,5 @@
 from .task_team import get_task_team
-from .orchestrator_config import OrchestratorConfig
+from .teams.orchestrator.orchestrator_config import OrchestratorConfig
 from .input_func import AsyncInputFunc, InputFuncType, InputRequestType, SyncInputFunc
 from .approval_guard import (
     BaseApprovalGuard,

src/magentic_ui/_cli.py

@@ -11,12 +11,13 @@
 from typing import Any, Optional, Literal, cast
 from autogen_core import EVENT_LOGGER_NAME, CancellationToken
 from autogen_agentchat.ui import Console
-from .orchestrator_config import OrchestratorConfig
 from .task_team import get_task_team
 from loguru import logger
 import logging
 from .utils import LLMCallFilter
 from .types import RunPaths
+from .magentic_ui_config import MagenticUIConfig
+from .endpoint_configs import EndpointConfigs
 
 logging.basicConfig(level=logging.WARNING, handlers=[])
 logger_llm = logging.getLogger(EVENT_LOGGER_NAME)
@@ -84,16 +85,6 @@ async def get_team(
             print(f"Deleting state file: {state_file}")
             os.remove(state_file)
 
-    config = OrchestratorConfig(
-        cooperative_planning=cooperative_planning,
-        autonomous_execution=autonomous_execution,
-        allow_for_replans=True,
-        do_bing_search=False,
-        allow_follow_up_input=False,
-        final_answer_prompt=final_answer_prompt,
-        model_context_token_limit=model_context_token_limit,
-    )
-
     if inside_docker:
         # Use environment variables as fallback if paths not provided
         if internal_workspace_root is None:
@@ -142,23 +133,36 @@ async def get_team(
         with open(client_config, "r") as f:
             client_config_dict = yaml.safe_load(f)
 
-    team = await get_task_team(
-        orchestrator_config=config,
-        input_func=cancellable_input,
-        paths=paths,
+    endpoint_configs = EndpointConfigs(
+        orchestrator=client_config_dict.get("orchestrator_client", None),
+        web_surfer=client_config_dict.get("web_surfer_client", None),
+        coder=client_config_dict.get("coder_client", None),
+        file_surfer=client_config_dict.get("file_surfer_client", None),
+    )
+
+    magentic_ui_config = MagenticUIConfig(
+        endpoint_configs=endpoint_configs,
+        approval_policy=action_policy,
+        cooperative_planning=cooperative_planning,
+        autonomous_execution=autonomous_execution,
+        allow_for_replans=True,
+        do_bing_search=False,
+        model_context_token_limit=model_context_token_limit,
+        allow_follow_up_input=False,
+        final_answer_prompt=final_answer_prompt,
         playwright_port=playwright_port,
         novnc_port=novnc_port,
-        inside_docker=inside_docker,
-        model_context_token_limit=model_context_token_limit,
-        endpoint_config_orch=client_config_dict.get("orchestrator_client", None),
-        endpoint_config_websurfer=client_config_dict.get("web_surfer_client", None),
-        endpoint_config_coder=client_config_dict.get("coder_client", None),
-        endpoint_config_file_surfer=client_config_dict.get("file_surfer_client", None),
-        approval_policy=action_policy,
         user_proxy_type=user_proxy_type,
         task=task_metadata,
         hints=hints,
         answer=answer,
+        inside_docker=inside_docker,
+    )
+
+    team = await get_task_team(
+        magentic_ui_config=magentic_ui_config,
+        input_func=cancellable_input,
+        paths=paths,
     )
 
     try:

src/magentic_ui/backend/teammanager/teammanager.py

@@ -26,7 +26,9 @@
 from autogen_core.logging import LLMCallEvent
 from ...task_team import get_task_team
 from ...teams import GroupChat
-from ...types import SimplifiedConfig, RunPaths
+from ...types import RunPaths
+from ...endpoint_configs import EndpointConfigs
+from ...magentic_ui_config import MagenticUIConfig
 from ...input_func import InputFuncType
 from ...agents import WebSurfer
 
@@ -161,46 +163,42 @@ async def _create_team(
                         logger.error(f"Failed to parse model configurations: {e}")
 
                 # Use model configs from settings if available, otherwise fall back to config
-                endpoint_configs = {
-                    "orchestrator_client": model_configs.get(
+                endpoint_configs = EndpointConfigs(
+                    orchestrator=model_configs.get(
                         "orchestrator_client",
                         self.config.get("orchestrator_client", None),
                     ),
-                    "web_surfer_client": model_configs.get(
+                    web_surfer=model_configs.get(
                         "web_surfer_client",
                         self.config.get("web_surfer_client", None),
                     ),
-                    "coder_client": model_configs.get(
+                    coder=model_configs.get(
                         "coder_client", self.config.get("coder_client", None)
                     ),
-                    "file_surfer_client": model_configs.get(
+                    file_surfer=model_configs.get(
                         "file_surfer_client",
                         self.config.get("file_surfer_client", None),
                     ),
-                    "action_guard_client": model_configs.get(
+                    action_guard=model_configs.get(
                         "action_guard_client",
                         self.config.get("action_guard_client", None),
                     ),
-                }
+                )
+
+                magentic_ui_config = MagenticUIConfig(
+                    **(settings_config or {}),
+                    endpoint_configs=endpoint_configs,
+                    playwright_port=playwright_port,
+                    novnc_port=novnc_port,
+                    inside_docker=self.inside_docker,
+                )
 
                 self.team = cast(
                     Team,
                     await get_task_team(
+                        magentic_ui_config=magentic_ui_config,
                         input_func=input_func,
-                        simplified_config=SimplifiedConfig(**(settings_config or {})),
                         paths=paths,
-                        inside_docker=self.inside_docker,
-                        playwright_port=playwright_port,
-                        novnc_port=novnc_port,
-                        endpoint_config_orch=endpoint_configs["orchestrator_client"],
-                        endpoint_config_websurfer=endpoint_configs["web_surfer_client"],
-                        endpoint_config_coder=endpoint_configs["coder_client"],
-                        endpoint_config_file_surfer=endpoint_configs[
-                            "file_surfer_client"
-                        ],
-                        endpoint_config_action_guard=endpoint_configs[
-                            "action_guard_client"
-                        ],
                     ),
                 )
                 if hasattr(self.team, "_participants"):

src/magentic_ui/endpoint_configs.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass
+from typing import Optional, Union, Dict, Any
+
+from autogen_core import ComponentModel
+
+
+@dataclass
+class EndpointConfigs:
+    """Configuration class for Magentic UI endpoints.
+    Attributes:
+        orchestrator (Optional[Union[ComponentModel, Dict[str, Any]]]): Configuration for the orchestrator component. Default: None.
+        web_surfer (Optional[Union[ComponentModel, Dict[str, Any]]]): Configuration for the web surfer component. Default: None.
+        coder (Optional[Union[ComponentModel, Dict[str, Any]]]): Configuration for the coder component. Default: None.
+        file_surfer (Optional[Union[ComponentModel, Dict[str, Any]]]): Configuration for the file surfer component. Default: None.
+        action_guard (Optional[Union[ComponentModel, Dict[str, Any]]]): Configuration for the action guard component. Default: None.
+    """
+
+    orchestrator: Optional[Union[ComponentModel, Dict[str, Any]]] = None
+    web_surfer: Optional[Union[ComponentModel, Dict[str, Any]]] = None
+    coder: Optional[Union[ComponentModel, Dict[str, Any]]] = None
+    file_surfer: Optional[Union[ComponentModel, Dict[str, Any]]] = None
+    action_guard: Optional[Union[ComponentModel, Dict[str, Any]]] = None

src/magentic_ui/magentic_ui_config.py

@@ -0,0 +1,64 @@
+from pydantic import BaseModel
+from typing import Optional, List, Literal
+from .types import Plan
+from .endpoint_configs import EndpointConfigs
+from pydantic import Field
+
+
+class MagenticUIConfig(BaseModel):
+    """
+    A simplified set of configuration options for Magentic-UI.
+
+    Attributes:
+        endpoint_configs (EndpointConfigs): Configuration for various endpoints.
+        cooperative_planning (bool): Disable co-planning mode (default: enabled), user will not be involved in the planning process. Default: True.
+        autonomous_execution (bool): Enable autonomous execution mode (default: disabled), user will not be involved in the execution. Default: False.
+        allowed_websites (List[str], optional): List of websites that are permitted.
+        max_actions_per_step (int): Maximum number of actions allowed per step. Default: 5.
+        multiple_tools_per_call (bool): Allow multiple tools to be called in a single step. Default: False.
+        max_turns (int): Maximum number of operational turns allowed. Default: 20.
+        plan (Plan, optional): A pre-defined plan. In cooperative planning mode, the plan will be enhanced with user feedback.
+        approval_policy (str, optional): Policy for action approval. Default: "auto-conservative".
+        allow_for_replans (bool): Whether to allow the orchestrator to create a new plan when needed. Default: True.
+        do_bing_search (bool): Flag to determine if Bing search should be used to come up with information for the plan. Default: False.
+        websurfer_loop (bool): Flag to determine if the websurfer should loop through the plan. Default: False.
+        retrieve_relevant_plans (Literal["never", "hint", "reuse"]): Determines if the orchestrator should retrieve relevant plans from memory. Default: `never`.
+        memory_controller_key (str, optional): The key to retrieve the memory_controller for a particular user. Default: None.
+        model_context_token_limit (int, optional): The maximum number of tokens the model can use. Default: 110000.
+        allow_follow_up_input (bool): Flag to determine if new input should be requested after a final answer is given. Default: False.
+        final_answer_prompt (str, optional): Prompt for the final answer. Should be a string that can be formatted with the {task} variable. Default: None.
+        playwright_port (int, optional): Port for the Playwright browser. Default: -1 (auto-assign).
+        novnc_port (int, optional): Port for the noVNC server. Default: -1 (auto-assign).
+        user_proxy_type (str, optional): Type of user proxy agent to use ("dummy", "metadata", or None for default). Default: None.
+        task (str, optional): Task to be performed by the agents. Default: None.
+        hints (str, optional): Helpful hints for the task. Default: None.
+        answer (str, optional): Answer to the task. Default: None.
+        inside_docker (bool, optional): Whether to run inside a docker container. Default: True.
+    """
+
+    endpoint_configs: EndpointConfigs = Field(default_factory=EndpointConfigs)
+    cooperative_planning: bool = True
+    autonomous_execution: bool = False
+    allowed_websites: Optional[List[str]] = None
+    max_actions_per_step: int = 5
+    multiple_tools_per_call: bool = False
+    max_turns: int = 20
+    plan: Optional[Plan] = None
+    approval_policy: Literal[
+        "always", "never", "auto-conservative", "auto-permissive"
+    ] = "auto-conservative"
+    allow_for_replans: bool = True
+    do_bing_search: bool = False
+    websurfer_loop: bool = False
+    retrieve_relevant_plans: Literal["never", "hint", "reuse"] = "never"
+    memory_controller_key: Optional[str] = None
+    model_context_token_limit: int = 110000
+    allow_follow_up_input: bool = True
+    final_answer_prompt: str | None = None
+    playwright_port: int = -1
+    novnc_port: int = -1
+    user_proxy_type: Optional[str] = None
+    task: Optional[str] = None
+    hints: Optional[str] = None
+    answer: Optional[str] = None
+    inside_docker: bool = True