mindroot.coreplugins.admin package

Submodules

mindroot.coreplugins.admin.agent_importer module

mindroot.coreplugins.admin.agent_importer.download_github_files(repo_path: str, tag: str = None) → tuple[str, str]

Download GitHub repo files to temp directory

mindroot.coreplugins.admin.agent_importer.import_agent(agent_name: str, agent_info: Dict, scope: str) → None

mindroot.coreplugins.admin.agent_importer.import_github_agent(repo_path: str, scope: str, tag: str = None) → Dict[str, any]

Import an agent from a GitHub repository

mindroot.coreplugins.admin.agent_importer.import_persona(persona_name: str, source_dir: Path, scope: str) → None

mindroot.coreplugins.admin.agent_importer.scan_and_import_agents(directory: Path, scope: str) → Dict[str, List[str]]

mindroot.coreplugins.admin.agent_importer.scan_for_agents(directory: Path) → Dict[str, Dict]

mindroot.coreplugins.admin.agent_importer.validate_agent_structure(agent_data: Dict) → bool

mindroot.coreplugins.admin.agent_router module

class mindroot.coreplugins.admin.agent_router.GitHubImportRequest(*, repo_path: str, scope: str, tag: str = None)

Bases: BaseModel

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

repo_path: str

scope: str

tag: str

class mindroot.coreplugins.admin.agent_router.ScanDirectoryRequest(*, directory: str, scope: str)

Bases: BaseModel

directory: str

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

scope: str

mindroot.coreplugins.admin.agent_router.create_agent(scope: str, agent: str = Form(PydanticUndefined))

mindroot.coreplugins.admin.agent_router.export_agent_zip(scope: str, name: str)

Export an agent as a zip file

mindroot.coreplugins.admin.agent_router.get_agent_ownership_info()

Get cached ownership information for all agents

mindroot.coreplugins.admin.agent_router.get_command_providers()

Get all available providers for each command

async mindroot.coreplugins.admin.agent_router.get_full_agent_data(scope: str, name: str)

Get complete agent data including persona

async mindroot.coreplugins.admin.agent_router.import_agent_zip(scope: str, file: UploadFile = File(PydanticUndefined))

Import an agent from a zip file

mindroot.coreplugins.admin.agent_router.import_github_agent_endpoint(request: GitHubImportRequest)

mindroot.coreplugins.admin.agent_router.list_agents(scope: str)

async mindroot.coreplugins.admin.agent_router.load_agent_data(agent_name: str) → dict

Load agent data from local or shared directory

async mindroot.coreplugins.admin.agent_router.load_persona_data(persona_name: str) → dict

Load persona data from local or shared directory

mindroot.coreplugins.admin.agent_router.read_agent(scope: str, name: str)

mindroot.coreplugins.admin.agent_router.refresh_agent_ownership_cache()

Force refresh of the agent ownership cache

mindroot.coreplugins.admin.agent_router.scan_agent_ownership() → Dict[str, Any]

Scan all agents and build ownership information

mindroot.coreplugins.admin.agent_router.scan_and_import_agents_endpoint(request: ScanDirectoryRequest)

mindroot.coreplugins.admin.agent_router.update_agent(scope: str, name: str, agent: str = Form(PydanticUndefined))

mindroot.coreplugins.admin.asset_manager module

class mindroot.coreplugins.admin.asset_manager.AssetManager(base_dir: str = 'registry_assets')

Bases: object

Manages deduplicated asset storage for personas

calculate_content_hash(content: bytes) → str

Calculate SHA256 hash of content bytes

calculate_file_hash(file_path: Path) → str

Calculate SHA256 hash of a file

decrement_reference_count(file_hash: str) → bool

Decrement reference count and delete if zero. Returns True if deleted.

get_asset_metadata(file_hash: str) → Dict | None

Get metadata for an asset

get_asset_path(file_hash: str) → Path | None

Get the path to an asset by hash

get_stats() → Dict

Get storage statistics

store_asset(source_path: Path, asset_type: str = 'image') → Tuple[str, bool]

Store an asset and return (hash, was_new)

store_content(content: bytes, filename: str, asset_type: str = 'image') → Tuple[str, bool]

Store content bytes and return (hash, was_new)

mindroot.coreplugins.admin.command_router module

async mindroot.coreplugins.admin.command_router.check_recommended_plugins(agent_name: str)

Check which recommended plugins are not installed.

async mindroot.coreplugins.admin.command_router.command_plugin_mapping()

Get mapping of commands to plugins that provide them.

async mindroot.coreplugins.admin.command_router.install_agent_recommended_plugins(agent_name: str)

Install plugins recommended for an agent.

async mindroot.coreplugins.admin.command_router.install_queued_plugins()

Install all queued plugins.

async mindroot.coreplugins.admin.command_router.missing_commands(agent_name: str)

Get commands mentioned in agent instructions but not available.

async mindroot.coreplugins.admin.command_router.queue_plugin_install(plugin_name: str, source: str, source_path: str, remote_source: str = None)

Queue a plugin for installation.

async mindroot.coreplugins.admin.command_router.stream_install_recommended_plugins(agent_name: str)

SSE endpoint that installs all recommended plugins for agent_name and streams stdout/stderr lines back to the browser. It finishes by sending a JSON summary and the literal string ‘END’.

mindroot.coreplugins.admin.mcp_catalog_routes module

async mindroot.coreplugins.admin.mcp_catalog_routes.get_catalog_server_info(server_name: str)

Get detailed information about a specific server from the catalog.

async mindroot.coreplugins.admin.mcp_catalog_routes.get_mcp_catalog()

Get the MCP server catalog/directory.

async mindroot.coreplugins.admin.mcp_catalog_routes.get_mcp_categories()

Get available MCP server categories.

async mindroot.coreplugins.admin.mcp_catalog_routes.install_from_catalog(server_name: str)

Install an MCP server from the catalog.

async mindroot.coreplugins.admin.mcp_catalog_routes.refresh_catalog_status()

Refresh the running status of all servers in the catalog.

async mindroot.coreplugins.admin.mcp_catalog_routes.search_mcp_catalog(query: str = '', category: str | None = None)

Search the MCP server catalog.

mindroot.coreplugins.admin.mcp_publish_routes module

class mindroot.coreplugins.admin.mcp_publish_routes.McpCompleteOAuthRequest(*, server_name: str, code: str, state: str | None = None)

Bases: BaseModel

code: str

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

server_name: str

state: str | None

class mindroot.coreplugins.admin.mcp_publish_routes.McpServerPublishRequest(*, name: str, description: str, server_type: str, tools: List[Dict[str, Any]], command: str | None = None, args: List[str] | None = None, env: Dict[str, str] | None = None, url: str | None = None)

Bases: BaseModel

args: List[str] | None

command: str | None

description: str

env: Dict[str, str] | None

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

server_type: str

tools: List[Dict[str, Any]]

url: str | None

class mindroot.coreplugins.admin.mcp_publish_routes.McpTestLocalRequest(*, name: str, command: str, args: List[str] = [], env: Dict[str, str] = {})

Bases: BaseModel

args: List[str]

command: str

env: Dict[str, str]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

class mindroot.coreplugins.admin.mcp_publish_routes.McpTestRemoteRequest(*, url: str, name: str | None = None)

Bases: BaseModel

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

url: str

async mindroot.coreplugins.admin.mcp_publish_routes.complete_oauth_flow(request: McpCompleteOAuthRequest)

Complete OAuth flow for MCP server testing.

async mindroot.coreplugins.admin.mcp_publish_routes.get_oauth_status(server_name: str)

Get OAuth flow status for a server.

async mindroot.coreplugins.admin.mcp_publish_routes.publish_mcp_server(request: McpServerPublishRequest)

Publish an MCP server to the registry.

async mindroot.coreplugins.admin.mcp_publish_routes.test_direct_connection(url: str)

Test direct connection to MCP server without OAuth to check if auth is required.

async mindroot.coreplugins.admin.mcp_publish_routes.test_local_mcp_server(request: McpTestLocalRequest)

Test connection to a local MCP server and list its capabilities.

async mindroot.coreplugins.admin.mcp_publish_routes.test_remote_mcp_server(request: McpTestRemoteRequest)

Test connection to a remote MCP server and list its tools using MCP manager OAuth flow.

mindroot.coreplugins.admin.mcp_registry_routes module

MCP Registry Integration Routes

Handles browsing and installing MCP servers from the registry.

class mindroot.coreplugins.admin.mcp_registry_routes.RegistryBrowseRequest(*, category: str | None = None, search: str | None = None, page: int = 1, limit: int = 20)

Bases: BaseModel

category: str | None

limit: int

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

page: int

search: str | None

class mindroot.coreplugins.admin.mcp_registry_routes.RegistryServerInstallRequest(*, registry_id: str, server_name: str | None = None)

Bases: BaseModel

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

registry_id: str

server_name: str | None

async mindroot.coreplugins.admin.mcp_registry_routes.browse_registry_servers(category: str | None = None, search: str | None = None, page: int = 1, limit: int = 20)

Browse MCP servers from the registry.

async mindroot.coreplugins.admin.mcp_registry_routes.complete_registry_oauth(server_name: str, code: str, state: str | None = None)

Complete OAuth flow for registry server installation.

async mindroot.coreplugins.admin.mcp_registry_routes.get_installation_status()

Get installation status of all registry servers.

async mindroot.coreplugins.admin.mcp_registry_routes.get_registry_categories()

Get available MCP server categories from the registry.

async mindroot.coreplugins.admin.mcp_registry_routes.get_registry_server_details(registry_id: str)

Get detailed information about a specific registry server.

async mindroot.coreplugins.admin.mcp_registry_routes.install_registry_server(request: RegistryServerInstallRequest)

Install an MCP server from the registry.

async mindroot.coreplugins.admin.mcp_registry_routes.mark_server_installed(server_name: str, registry_id: str = None)

Manually mark a server as installed (for testing/fixing).

mindroot.coreplugins.admin.mcp_routes module

class mindroot.coreplugins.admin.mcp_routes.McpConnectRequest(*, server_name: str, secrets: Dict[str, str] | None = None)

Bases: BaseModel

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

secrets: Dict[str, str] | None

server_name: str

class mindroot.coreplugins.admin.mcp_routes.McpLocalTestRequest(*, name: str, command: str, args: List[str] = [], env: Dict[str, str] = {}, secrets: Dict[str, str] | None = None)

Bases: BaseModel

args: List[str]

command: str

env: Dict[str, str]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

secrets: Dict[str, str] | None

class mindroot.coreplugins.admin.mcp_routes.McpOAuthCallbackRequest(*, server_name: str, code: str, state: str | None = None)

Bases: BaseModel

code: str

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

server_name: str

state: str | None

class mindroot.coreplugins.admin.mcp_routes.McpServerAddRequest(*, name: str, description: str, command: str | None = None, args: List[str] = [], env: dict = {}, transport: str = 'stdio', url: str | None = None, provider_url: str | None = None, transport_url: str | None = None, transport_type: str | None = None, auth_type: str = 'none', auth_headers: Dict[str, str] = {}, authorization_server_url: str | None = None, client_id: str | None = None, client_secret: str | None = None, scopes: List[str] = [], redirect_uri: str | None = None)

Bases: BaseModel

args: List[str]

auth_headers: Dict[str, str]

auth_type: str

authorization_server_url: str | None

client_id: str | None

client_secret: str | None

command: str | None

description: str

env: dict

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

provider_url: str | None

redirect_uri: str | None

scopes: List[str]

transport: str

transport_type: str | None

transport_url: str | None

url: str | None

class mindroot.coreplugins.admin.mcp_routes.McpServerRequest(*, server_name: str)

Bases: BaseModel

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

server_name: str

async mindroot.coreplugins.admin.mcp_routes.add_mcp_server(server_request: McpServerAddRequest)

Add a new MCP server configuration.

async mindroot.coreplugins.admin.mcp_routes.connect_mcp_server(request: McpConnectRequest)

Connect to an MCP server.

async mindroot.coreplugins.admin.mcp_routes.disconnect_mcp_server(request: McpServerRequest)

Disconnect from an MCP server.

async mindroot.coreplugins.admin.mcp_routes.list_mcp_servers()

List all configured MCP servers.

async mindroot.coreplugins.admin.mcp_routes.remove_mcp_server(request: McpServerRequest)

Remove an MCP server configuration.

mindroot.coreplugins.admin.mod module

async mindroot.coreplugins.admin.mod.get_git_version_info(context=None)

Get git commit hash and date of last commit.

Returns a dictionary with commit hash and date, or None if not in a git repo.

Example: { “get_git_version_info”: {} }

mindroot.coreplugins.admin.oauth_callback_router module

OAuth callback router for MCP servers.

This router contains public routes that do not require authentication, as external OAuth providers need to be able to redirect to these endpoints.

async mindroot.coreplugins.admin.oauth_callback_router.mcp_oauth_callback(request: Request)

Handle OAuth callback for MCP servers.

This endpoint must be publicly accessible as external OAuth providers will redirect to it without any authentication.

mindroot.coreplugins.admin.persona_handler module

mindroot.coreplugins.admin.persona_handler.handle_persona_import(persona_data: dict, scope: str, owner: str = None) → str

Handle importing a persona from embedded data in agent configuration. Returns the persona name to be used in agent configuration.

Parameters:

• persona_data – Dictionary containing persona data or string with persona name

• scope – ‘local’ or ‘shared’

Returns:

Name of the persona to reference in agent config

Return type:

str

mindroot.coreplugins.admin.persona_handler.import_persona_from_index(index: str, persona: str)

Import a persona from the persona index. :param index: Path to the persona index file :param persona: Name of the persona to import

mindroot.coreplugins.admin.persona_router module

mindroot.coreplugins.admin.persona_router.create_persona(scope: str, persona: str = Form(PydanticUndefined), faceref: UploadFile = File(None), avatar: UploadFile = File(None))

mindroot.coreplugins.admin.persona_router.create_registry_persona(persona: str = Form(PydanticUndefined), owner: str = Form(PydanticUndefined))

Create a registry persona with owner namespace

mindroot.coreplugins.admin.persona_router.create_registry_persona_with_assets(persona: str = Form(PydanticUndefined), owner: str = Form(PydanticUndefined), faceref: UploadFile = File(None), avatar: UploadFile = File(None))

Create a registry persona with deduplicated asset storage

mindroot.coreplugins.admin.persona_router.list_personas(scope: str)

mindroot.coreplugins.admin.persona_router.read_persona(scope: str, name: str)

mindroot.coreplugins.admin.persona_router.read_persona_by_path(persona_path: str)

Read persona by full path (supports registry/owner/name format)

mindroot.coreplugins.admin.persona_router.serve_asset(asset_hash: str)

Serve a deduplicated asset by hash

mindroot.coreplugins.admin.persona_router.update_persona(scope: str, name: str, persona: str = Form(PydanticUndefined), faceref: UploadFile = File(None), avatar: UploadFile = File(None))

mindroot.coreplugins.admin.plugin_manager module

class mindroot.coreplugins.admin.plugin_manager.DirectoryRequest(*, directory: str)

Bases: BaseModel

directory: str

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class mindroot.coreplugins.admin.plugin_manager.GitHubPluginRequest(*, plugin: str, url: str | None = None, github_url: str | None = None)

Bases: BaseModel

github_url: str | None

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

plugin: str

url: str | None

class mindroot.coreplugins.admin.plugin_manager.InstallFromIndexRequest(*, plugin: str, index_name: str)

Bases: BaseModel

index_name: str

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

plugin: str

class mindroot.coreplugins.admin.plugin_manager.PluginMetadata(*, description: str | None = None, commands: List[str] | None = None, services: List[str] | None = None, dependencies: List[str] | None = None)

Bases: BaseModel

commands: List[str] | None

dependencies: List[str] | None

description: str | None

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

services: List[str] | None

class mindroot.coreplugins.admin.plugin_manager.PluginRequest(*, plugin: str)

Bases: BaseModel

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

plugin: str

class mindroot.coreplugins.admin.plugin_manager.StreamInstallRequest(*, plugin: str, source: str, source_path: str = None)

Bases: BaseModel

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

plugin: str

source: str

source_path: str

class mindroot.coreplugins.admin.plugin_manager.TogglePluginRequest(*, plugin: str, enabled: bool)

Bases: BaseModel

enabled: bool

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

plugin: str

mindroot.coreplugins.admin.plugin_manager.discover_plugins(directory)

async mindroot.coreplugins.admin.plugin_manager.get_all_plugins()

async mindroot.coreplugins.admin.plugin_manager.install_from_index(request: InstallFromIndexRequest)

async mindroot.coreplugins.admin.plugin_manager.install_github_plugin(request: GitHubPluginRequest)

async mindroot.coreplugins.admin.plugin_manager.install_local_plugin(request: PluginRequest)

async mindroot.coreplugins.admin.plugin_manager.publish_plugin_from_github(repo: str, registry_token: str, registry_url: str)

Fetches plugin_info.json from a GitHub repo and publishes it to the registry.

async mindroot.coreplugins.admin.plugin_manager.scan_directory(request: DirectoryRequest)

async mindroot.coreplugins.admin.plugin_manager.stream_install_plugin(request: StreamInstallRequest)

Stream the installation process of a plugin using SSE (POST method).

async mindroot.coreplugins.admin.plugin_manager.stream_install_plugin_get(request: Request)

Stream the installation process of a plugin using SSE (GET method).

async mindroot.coreplugins.admin.plugin_manager.toggle_plugin(request: TogglePluginRequest)

mindroot.coreplugins.admin.plugin_router module

class mindroot.coreplugins.admin.plugin_router.PluginUpdateRequest(*, plugins: dict)

Bases: BaseModel

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

plugins: dict

async mindroot.coreplugins.admin.plugin_router.get_plugins()

mindroot.coreplugins.admin.plugin_router.update_plugins(request: PluginUpdateRequest)

mindroot.coreplugins.admin.plugin_router_fixed module

mindroot.coreplugins.admin.plugin_router_new_not_working module

mindroot.coreplugins.admin.plugin_routes module

class mindroot.coreplugins.admin.plugin_routes.GithubPublishRequest(*, repo: str, registry_url: str | None = None)

Bases: BaseModel

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

registry_url: str | None

repo: str

class mindroot.coreplugins.admin.plugin_routes.PluginUpdateRequest(*, plugins: dict)

Bases: BaseModel

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

plugins: dict

async mindroot.coreplugins.admin.plugin_routes.get_plugins()

Get list of all plugins.

async mindroot.coreplugins.admin.plugin_routes.publish_plugin_from_github(request: GithubPublishRequest, authorization: str | None = Header(None))

Publish a plugin from GitHub repository to the registry.

This endpoint allows publishing a plugin by simply providing the GitHub repository in the format ‘username/repo’. It will fetch the plugin_info.json from the repository and publish it to the configured registry.

The registry token can be provided via: 1. Authorization header: “Bearer <token>” 2. REGISTRY_TOKEN environment variable 3. registry_token in data/registry_settings.json

mindroot.coreplugins.admin.plugin_routes.update_plugins(request: PluginUpdateRequest)

Update plugin enabled/disabled status.

mindroot.coreplugins.admin.registry_settings_routes module

async mindroot.coreplugins.admin.registry_settings_routes.clear_registry_token()

Clear the stored registry token.

async mindroot.coreplugins.admin.registry_settings_routes.get_registry_settings()

Get registry settings including token status.

async mindroot.coreplugins.admin.registry_settings_routes.test_registry_connection()

Test connection to the registry.

async mindroot.coreplugins.admin.registry_settings_routes.update_registry_settings(settings_data: dict)

Update registry settings.

mindroot.coreplugins.admin.router module

async mindroot.coreplugins.admin.router.get_admin_html()

async mindroot.coreplugins.admin.router.get_model_preferences_v2_html()

Serve the new Model Preferences V2 page

async mindroot.coreplugins.admin.router.get_version_info()

Get version information, trying git first, then falling back to cached file.

async mindroot.coreplugins.admin.router.update_mindroot()

Update MindRoot using pip install –upgrade mindroot

mindroot.coreplugins.admin.server_router module

async mindroot.coreplugins.admin.server_router.delayed_exit()

mindroot.coreplugins.admin.server_router.get_start_method()

async mindroot.coreplugins.admin.server_router.ping()

Simple endpoint to check if server is running

async mindroot.coreplugins.admin.server_router.restart_server()

mindroot.coreplugins.admin.server_router.spawn_restart()

async mindroot.coreplugins.admin.server_router.stop_server()

mindroot.coreplugins.admin.service_models module

async mindroot.coreplugins.admin.service_models.cached_get_service_models()

Retrieve service models from the cache or fetch them if not available. :returns:

{

“service_name”: {

“provider_name”: [“model1”, “model2”, …], …

}

Return type:

Dictionary mapping services to providers to models

async mindroot.coreplugins.admin.service_models.get_service_models_from_providers(timeout: float = 500.0, context=None) → Dict[str, Dict[str, List[str]]]

Gather service models from all providers.

Parameters:

timeout – Maximum time in seconds to wait for each provider response

Returns:

{

“service_name”: {

“provider_name”: [“model1”, “model2”, …], …

}

Return type:

Dictionary mapping services to providers to models

mindroot.coreplugins.admin.settings_router module

class mindroot.coreplugins.admin.settings_router.Setting(*, service_or_command_name: str, flag: str, model: str)

Bases: BaseModel

flag: str

model: str

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

service_or_command_name: str

async mindroot.coreplugins.admin.settings_router.delete_setting(setting_id: int)

async mindroot.coreplugins.admin.settings_router.get_commands()

async mindroot.coreplugins.admin.settings_router.get_equivalent_flags()

async mindroot.coreplugins.admin.settings_router.get_models()

async mindroot.coreplugins.admin.settings_router.get_organized_models()

async mindroot.coreplugins.admin.settings_router.get_providers()

async mindroot.coreplugins.admin.settings_router.get_service_models()

async mindroot.coreplugins.admin.settings_router.get_services()

async mindroot.coreplugins.admin.settings_router.get_settings()

async mindroot.coreplugins.admin.settings_router.get_settings_v2()

Get preferences in new v2 format: {service: [[provider, model], …]}

async mindroot.coreplugins.admin.settings_router.migrate_settings()

One-time migration from old format to new v2 format.

mindroot.coreplugins.admin.settings_router.read_equivalent_flags() → List[List[str]]

mindroot.coreplugins.admin.settings_router.read_models() → List[Dict]

mindroot.coreplugins.admin.settings_router.read_providers() → List[Dict]

mindroot.coreplugins.admin.settings_router.read_settings() → List[Dict]

async mindroot.coreplugins.admin.settings_router.save_settings(request: Request)

async mindroot.coreplugins.admin.settings_router.save_settings_v2(request: Request)

Save preferences in new v2 format.

async mindroot.coreplugins.admin.settings_router.update_setting(setting_id: int, updated_setting: Dict)

mindroot.coreplugins.admin.settings_router.write_settings(settings: List[Dict])

Module contents