Agent Zero AI framework
Add project-scoped LLM presets
Alessandrofe2310aa9000
diff --git a/docs/developer/extensions.md b/docs/developer/extensions.mdindex 22a8c6f45..953ae1fc3 100644--- a/docs/developer/extensions.md+++ b/docs/developer/extensions.md@@ -343,6 +343,7 @@ Each project directory contains a hidden `.a0proj` folder with project metadata├── instructions/ # additional prompt/instruction files├── knowledge/ # files to be imported into memory├── memory/ # project-specific memory storage+ ├── plugins/ # project-scoped plugin configuration├── secrets.env # sensitive variables (secrets)└── variables.env # non-sensitive variables```@@ -369,6 +370,25 @@ Each project manages its own configuration values via environment files in `.a0pThese files allow you to keep credentials and configuration tightly scoped to a single project.+Plugin-owned project configuration is stored under `.a0proj/plugins/<plugin_name>/`. For example, `_model_config` stores project model settings and project-only presets here:++```text+/a0/usr/projects/{project_name}/.a0proj/plugins/_model_config/config.json+/a0/usr/projects/{project_name}/.a0proj/plugins/_model_config/presets.yaml+```++The `_model_config/presets.yaml` file is a plain YAML list:++```yaml+- name: Research+ chat:+ provider: openrouter+ name: anthropic/claude-sonnet-4.6+ utility:+ provider: openrouter+ name: openai/gpt-5.4-mini+```+### When to Use ProjectsProjects are the recommended way to create specialized workflows in Agent Zero when you need to:diff --git a/docs/guides/projects.md b/docs/guides/projects.mdindex a7a808ca3..06d0e7281 100644--- a/docs/guides/projects.md+++ b/docs/guides/projects.md@@ -223,6 +223,41 @@ SMTP_PASSWORD=email_pwd_hereProjects can enable or disable specific subagents. This is configured via the UI and stored in `.a0proj/agents.json`. The Browser Agent is not a subagent; it is a built-in plugin.+### Project LLM Configuration++Projects can carry their own model settings without adding model data to `.a0proj/project.json`. The selected project model config is stored in the `_model_config` plugin's project-scoped path:++```text+/a0/usr/projects/<project_name>/.a0proj/plugins/_model_config/config.json+```++Project-only presets are stored next to that config:++```text+/a0/usr/projects/<project_name>/.a0proj/plugins/_model_config/presets.yaml+```++The project preset YAML is the same plain list used by global model presets:++```yaml+- name: Research+ chat:+ provider: openrouter+ name: anthropic/claude-sonnet-4.6+ api_base: ""+ ctx_length: 200000+ ctx_history: 0.7+ vision: true+ utility:+ provider: openrouter+ name: openai/gpt-5.4-mini+ api_base: ""+ ctx_length: 128000+ ctx_input: 0.7+```++When you select a preset for a project, Agent Zero copies the preset's chat and utility settings into the project config. It does not keep a live link to the preset, and embedding model settings remain copied from the current effective config.+### Knowledge FilesImport project-specific knowledge documents:diff --git a/helpers/projects.py b/helpers/projects.pyindex 3e5193cc9..089656a98 100644--- a/helpers/projects.py+++ b/helpers/projects.py@@ -76,18 +76,22 @@ def delete_project(name: str):def create_project(name: str, data: BasicProjectData):+ llm_data = data.get("llm") if isinstance(data, dict) else Noneabs_path = files.create_dir_safe(files.get_abs_path(PROJECTS_PARENT_DIR, name), rename_format="{name}_{number}")create_project_meta_folders(name)data = _normalizeBasicData(data)save_project_header(name, data)+ save_project_llm_settings(name, llm_data)return namedef clone_git_project(name: str, git_url: str, git_token: str, data: BasicProjectData):"""Clone a git repository as a new A0 project. Token is used only for cloning via http header."""from helpers import git++ llm_data = data.get("llm") if isinstance(data, dict) else Noneabs_path = files.create_dir_safe(files.get_abs_path(PROJECTS_PARENT_DIR, name), rename_format="{name}_{number}"@@ -114,6 +118,8 @@ def clone_git_project(name: str, git_url: str, git_token: str, data: BasicProjecdata = _normalizeBasicData(data)data["git_url"] = clean_urlsave_project_header(actual_name, data)++ save_project_llm_settings(actual_name, llm_data)return actual_nameexcept Exception as e:@@ -206,6 +212,8 @@ def _basic_data_to_edit_data(data: BasicProjectData) -> EditProjectData:def update_project(name: str, data: EditProjectData):+ llm_data = data.get("llm") if isinstance(data, dict) else None+# merge with current statecurrent = load_edit_project_data(name)current.update(data)@@ -219,6 +227,7 @@ def update_project(name: str, data: EditProjectData):save_project_variables(name, current["variables"])save_project_secrets(name, current["secrets"])save_project_subagents(name, current["subagents"])+ save_project_llm_settings(name, llm_data)reactivate_project_in_chats(name)return name@@ -255,6 +264,7 @@ def load_edit_project_data(name: str) -> EditProjectData:},)data = _normalizeEditData(data)+ data["llm"] = load_project_llm_data(name) # type: ignore[typeddict-unknown-key]return data@@ -268,6 +278,55 @@ def save_project_header(name: str, data: BasicProjectData):files.write_file(abs_path, header)+def load_project_llm_data(name: str) -> dict:+ from plugins._model_config.helpers import model_config++ config = model_config.normalize_config_for_save(+ model_config.get_config(project_name=name) or {}+ )+ return {+ "config": config,+ "selected_preset": {+ "scope": "current",+ "project_name": name,+ "name": "Current config",+ },+ "presets": model_config.get_combined_presets(name),+ "global_presets": model_config.get_presets(),+ "project_presets": model_config.get_project_presets(name),+ }+++def save_project_llm_settings(name: str, llm_data: object):+ if not isinstance(llm_data, dict):+ return++ from helpers import plugins+ from plugins._model_config.helpers import model_config++ project_presets = llm_data.get("project_presets")+ if isinstance(project_presets, list):+ model_config.save_presets(project_presets, project_name=name)++ config_to_save = None+ selected_preset = llm_data.get("selected_preset")+ if isinstance(selected_preset, dict) and selected_preset.get("scope") in {+ "global",+ "project",+ }:+ preset = model_config.resolve_preset_selection(selected_preset, project_name=name)+ if preset:+ base_config = model_config.get_config(project_name=name) or {}+ config_to_save = model_config.build_config_from_preset(preset, base_config)++ config = llm_data.get("config")+ if config_to_save is None and isinstance(config, dict):+ config_to_save = model_config.normalize_config_for_save(config)++ if config_to_save is not None:+ plugins.save_plugin_config("_model_config", name, "", config_to_save)++def get_active_projects_list():return _get_projects_list(get_projects_parent_folder())diff --git a/plugins/_a0_connector/api/v1/model_presets.py b/plugins/_a0_connector/api/v1/model_presets.pyindex 0ef838a94..1b2df6a83 100644--- a/plugins/_a0_connector/api/v1/model_presets.py+++ b/plugins/_a0_connector/api/v1/model_presets.py@@ -10,20 +10,60 @@ class ModelPresets(connector_base.ProtectedConnectorApiHandler):from plugins._model_config.helpers import model_configaction = str(input.get("action", "get")).strip() or "get"+ project_name = str(input.get("project_name") or "").strip()+ scope = str(input.get("scope") or "").strip()if action == "get":- presets = model_config.get_presets()- return {"ok": True, "presets": presets}+ if scope == "project":+ presets = model_config.get_project_presets(project_name) if project_name else []+ return {"ok": True, "presets": presets}+ if scope == "combined" or project_name:+ return {+ "ok": True,+ "presets": model_config.get_combined_presets(project_name or None),+ "global_presets": model_config.get_presets(),+ "project_presets": (+ model_config.get_project_presets(project_name)+ if project_name+ else []+ ),+ }+ return {"ok": True, "presets": model_config.get_presets()}if action == "save":presets = input.get("presets")if not isinstance(presets, list):return Response(status=400, response="presets must be an array")- model_config.save_presets(presets)- return {"ok": True, "presets": presets}+ model_config.save_presets(+ presets,+ project_name=project_name if scope == "project" or project_name else None,+ )+ return {"ok": True, "presets": model_config.clean_presets_for_file(presets)}if action == "reset":- presets = model_config.reset_presets()+ presets = model_config.reset_presets(+ project_name=project_name if scope == "project" or project_name else None+ )return {"ok": True, "presets": presets}+ if action == "resolve":+ name = str(input.get("name") or "").strip()+ if not name:+ return Response(status=400, response="Missing preset name")+ resolved = model_config.resolve_preset(+ name,+ scope=scope or "global",+ project_name=project_name or None,+ )+ if not resolved:+ return Response(status=404, response=f"Preset '{name}' not found")+ return {+ "ok": True,+ "preset": {+ **resolved,+ "scope": scope or "global",+ "project_name": project_name if scope == "project" else "",+ },+ }+return Response(status=400, response=f"Unknown action: {action}")diff --git a/plugins/_model_config/README.md b/plugins/_model_config/README.mdindex 6426a6e25..15a07861d 100644--- a/plugins/_model_config/README.md+++ b/plugins/_model_config/README.md@@ -18,6 +18,7 @@ This plugin centralizes model selection and model-related settings for the appli- Reads plugin config through the standard plugin config system with project and agent overrides.- **Preset management**- Loads presets from a user file when present and falls back to bundled defaults.+ - Project presets can be stored beside a project's scoped model config.- **Per-chat override**- Allows a chat context to store a temporary override or preset reference in context data.- **Model object construction**@@ -47,6 +48,41 @@ This plugin centralizes model selection and model-related settings for the appli- **Per-agent config**: `true`- **Always enabled**: `true`+## Project-Scoped Model Config++Projects store copied model settings in the standard scoped plugin path:++```text+/a0/usr/projects/<project>/.a0proj/plugins/_model_config/config.json+```++Project-only presets live beside that config:++```text+/a0/usr/projects/<project>/.a0proj/plugins/_model_config/presets.yaml+```++The project preset file uses the same plain YAML list schema as global presets. It does not contain scope metadata:++```yaml+- name: Research+ chat:+ provider: openrouter+ name: anthropic/claude-sonnet-4.6+ api_base: ""+ ctx_length: 200000+ ctx_history: 0.7+ vision: true+ utility:+ provider: openrouter+ name: openai/gpt-5.4-mini+ api_base: ""+ ctx_length: 128000+ ctx_input: 0.7+```++Selecting a preset for a project copies the preset's `chat` and optional `utility` settings into the project's `config.json`. The embedding model is copied from the current effective config, because presets currently define chat and utility only.+## Plugin Metadata- **Name**: `_model_config`diff --git a/plugins/_model_config/api/model_presets.py b/plugins/_model_config/api/model_presets.pyindex e21e4ed57..a63477560 100644--- a/plugins/_model_config/api/model_presets.py+++ b/plugins/_model_config/api/model_presets.py@@ -5,8 +5,26 @@ from plugins._model_config.helpers import model_configclass ModelPresets(ApiHandler):async def process(self, input: dict, request: Request) -> dict | Response:action = input.get("action", "get")+ project_name = str(input.get("project_name") or "").strip()+ scope = str(input.get("scope") or "").strip()if action == "get":+ if scope == "project":+ presets = model_config.get_project_presets(project_name) if project_name else []+ return {"ok": True, "presets": presets}++ if scope == "combined" or project_name:+ return {+ "ok": True,+ "presets": model_config.get_combined_presets(project_name or None),+ "global_presets": model_config.get_presets(),+ "project_presets": (+ model_config.get_project_presets(project_name)+ if project_name+ else []+ ),+ }+presets = model_config.get_presets()return {"ok": True, "presets": presets}@@ -14,11 +32,36 @@ class ModelPresets(ApiHandler):presets = input.get("presets")if not isinstance(presets, list):return Response(status=400, response="presets must be an array")- model_config.save_presets(presets)- return {"ok": True, "presets": presets}+ model_config.save_presets(+ presets,+ project_name=project_name if scope == "project" or project_name else None,+ )+ return {"ok": True, "presets": model_config.clean_presets_for_file(presets)}elif action == "reset":- presets = model_config.reset_presets()+ presets = model_config.reset_presets(+ project_name=project_name if scope == "project" or project_name else None+ )return {"ok": True, "presets": presets}+ elif action == "resolve":+ name = str(input.get("name") or "").strip()+ if not name:+ return Response(status=400, response="Missing preset name")+ resolved = model_config.resolve_preset(+ name,+ scope=scope or "global",+ project_name=project_name or None,+ )+ if not resolved:+ return Response(status=404, response=f"Preset '{name}' not found")+ return {+ "ok": True,+ "preset": {+ **resolved,+ "scope": scope or "global",+ "project_name": project_name if scope == "project" else "",+ },+ }+return Response(status=400, response=f"Unknown action: {action}")diff --git a/plugins/_model_config/helpers/model_config.py b/plugins/_model_config/helpers/model_config.pyindex a209e2cca..eee226bb8 100644--- a/plugins/_model_config/helpers/model_config.py+++ b/plugins/_model_config/helpers/model_config.py@@ -1,4 +1,6 @@import os+from copy import deepcopy+import modelsfrom helpers import plugins, filesfrom helpers import yaml as yaml_helper@@ -6,12 +8,18 @@ from helpers.providers import get_providersPRESETS_FILE = "presets.yaml"DEFAULT_PRESETS_FILE = "default_presets.yaml"+PRESET_SCOPE_GLOBAL = "global"+PRESET_SCOPE_PROJECT = "project"LOCAL_PROVIDERS = {"ollama", "lm_studio"}LOCAL_EMBEDDING = {"huggingface"}-def _get_presets_path() -> str:- """Return the path to the user's global presets file (usr/plugins/_model_config/presets.yaml)."""+def _get_presets_path(project_name: str | None = None) -> str:+ """Return the user-editable presets path for the requested scope."""+ if project_name:+ return plugins.determine_plugin_asset_path(+ "_model_config", project_name, "", PRESETS_FILE+ )return files.get_abs_path(files.USER_DIR, files.PLUGINS_DIR, "_model_config", PRESETS_FILE)@@ -31,44 +39,173 @@ def get_config(agent=None, project_name=None, agent_profile=None):) or {}-def get_presets() -> list:- """Get global model presets list (not scoped to project/agent)."""- path = _get_presets_path()+def _load_presets_from_path(path: str) -> list | None:if files.exists(path):data = yaml_helper.loads(files.read_file(path))if isinstance(data, list):return data+ return None+++def _strip_ui_fields(value: dict, *, strip_api_key: bool) -> dict:+ cleaned = deepcopy(value)+ for key in list(cleaned.keys()):+ if key.startswith("_"):+ cleaned.pop(key, None)+ if strip_api_key:+ cleaned.pop("api_key", None)+ return cleaned+++def _clean_preset_for_file(preset: dict) -> dict:+ cleaned = {+ "name": str(preset.get("name", "") or ""),+ }+ for slot in ("chat", "utility"):+ slot_config = preset.get(slot)+ if isinstance(slot_config, dict):+ cleaned[slot] = _strip_ui_fields(slot_config, strip_api_key=False)+ return cleaned+++def clean_presets_for_file(presets: list) -> list:+ """Return presets without API/UI metadata, preserving the plain YAML schema."""+ cleaned = []+ for preset in presets:+ if isinstance(preset, dict):+ cleaned.append(_clean_preset_for_file(preset))+ return cleaned+++def normalize_config_for_save(config: dict) -> dict:+ """Remove UI-only fields and inline API keys before storing scoped config."""+ cleaned = deepcopy(config or {})+ for section_name in ("chat_model", "utility_model", "embedding_model"):+ section = cleaned.get(section_name)+ if isinstance(section, dict):+ cleaned[section_name] = _strip_ui_fields(section, strip_api_key=True)+ return cleaned+++def get_presets(project_name: str | None = None) -> list:+ """Get global model presets list (not scoped to project/agent)."""+ if project_name:+ return get_project_presets(project_name)++ path = _get_presets_path()+ presets = _load_presets_from_path(path)+ if presets is not None:+ return presets+# Fall back to defaults bundled with the plugindefault_path = _get_default_presets_path()- if default_path and files.exists(default_path):- data = yaml_helper.loads(files.read_file(default_path))- if isinstance(data, list):- return data- return []+ default_presets = _load_presets_from_path(default_path) if default_path else None+ return default_presets or []-def save_presets(presets: list) -> None:- """Save the global presets list."""- path = _get_presets_path()- files.write_file(path, yaml_helper.dumps(presets))+def get_project_presets(project_name: str) -> list:+ """Get presets stored beside the project-scoped _model_config config."""+ return _load_presets_from_path(_get_presets_path(project_name)) or []-def reset_presets() -> list:- """Delete user presets so get_presets() falls back to bundled defaults. Returns the default presets."""- path = _get_presets_path()+def _with_preset_metadata(preset: dict, scope: str, project_name: str = "") -> dict:+ item = deepcopy(preset)+ item["scope"] = scope+ item["project_name"] = project_name if scope == PRESET_SCOPE_PROJECT else ""+ item["name"] = str(item.get("name", "") or "")+ return item+++def get_combined_presets(project_name: str | None = None) -> list:+ """Get presets with explicit API metadata for unambiguous UI/API selection."""+ presets = [+ _with_preset_metadata(preset, PRESET_SCOPE_GLOBAL)+ for preset in get_presets()+ if isinstance(preset, dict)+ ]+ if project_name:+ presets.extend(+ _with_preset_metadata(preset, PRESET_SCOPE_PROJECT, project_name)+ for preset in get_project_presets(project_name)+ if isinstance(preset, dict)+ )+ return presets+++def save_presets(presets: list, project_name: str | None = None) -> None:+ """Save the presets list for the requested scope."""+ path = _get_presets_path(project_name)+ files.write_file(path, yaml_helper.dumps(clean_presets_for_file(presets)))+++def reset_presets(project_name: str | None = None) -> list:+ """Delete user presets for the scope. Global reset falls back to bundled defaults."""+ path = _get_presets_path(project_name)if os.path.exists(path):os.remove(path)- return get_presets()-+ return get_project_presets(project_name) if project_name else get_presets()+++def resolve_preset(+ name: str,+ *,+ scope: str = PRESET_SCOPE_GLOBAL,+ project_name: str | None = None,+) -> dict | None:+ """Resolve a preset by explicit scope so same-name presets are unambiguous."""+ if scope == PRESET_SCOPE_PROJECT:+ if not project_name:+ return None+ presets = get_project_presets(project_name)+ else:+ presets = get_presets()-def get_preset_by_name(name: str) -> dict | None:- """Find a preset by name from the global presets list."""- for p in get_presets():+ for p in presets:if p.get("name") == name:return preturn None+def resolve_preset_selection(selection: dict | str, project_name: str | None = None) -> dict | None:+ """Resolve a UI/API preset selection payload to a preset dict."""+ if isinstance(selection, str):+ return resolve_preset(selection)+ if not isinstance(selection, dict):+ return None++ scope = str(selection.get("scope") or PRESET_SCOPE_GLOBAL)+ if scope == "current":+ return None+ name = str(selection.get("name") or "")+ selected_project = str(selection.get("project_name") or project_name or "")+ return resolve_preset(name, scope=scope, project_name=selected_project or None)+++def get_preset_by_name(+ name: str,+ *,+ scope: str = PRESET_SCOPE_GLOBAL,+ project_name: str | None = None,+) -> dict | None:+ """Find a preset by name. Defaults to global presets for legacy callers."""+ return resolve_preset(name, scope=scope, project_name=project_name)+++def build_config_from_preset(preset: dict, base_config: dict) -> dict:+ """Copy chat/utility settings from a preset into a standalone model config."""+ config = normalize_config_for_save(base_config)++ chat = preset.get("chat") if isinstance(preset, dict) else None+ if isinstance(chat, dict):+ config["chat_model"] = _strip_ui_fields(chat, strip_api_key=True)++ utility = preset.get("utility") if isinstance(preset, dict) else None+ if isinstance(utility, dict) and (utility.get("provider") or utility.get("name")):+ config["utility_model"] = _strip_ui_fields(utility, strip_api_key=True)++ return config++def _resolve_override(agent) -> dict | None:"""Resolve the active per-chat override config dict.Supports both raw override dicts and preset-based overrides.diff --git a/tests/test_model_config_api_keys.py b/tests/test_model_config_api_keys.pyindex 14162d3bf..59571fd03 100644--- a/tests/test_model_config_api_keys.py+++ b/tests/test_model_config_api_keys.py@@ -85,13 +85,23 @@ async def test_missing_api_key_banner_exposes_missing_providers(monkeypatch):def test_model_config_frontend_tracks_inline_api_key_edits():store_path = PROJECT_ROOT / "plugins" / "_model_config" / "webui" / "model-config-store.js"+ api_keys_mixin_path = PROJECT_ROOT / "plugins" / "_model_config" / "webui" / "api-keys-mixin.js"composer_store_path = PROJECT_ROOT / "webui" / "components" / "chat" / "input" / "composer-banner-store.js"config_path = PROJECT_ROOT / "plugins" / "_model_config" / "webui" / "config.html"+ model_field_path = PROJECT_ROOT / "plugins" / "_model_config" / "webui" / "model-field.html"modal_path = PROJECT_ROOT / "plugins" / "_model_config" / "webui" / "api-keys.html"- store_content = store_path.read_text(encoding="utf-8")+ store_content = (+ store_path.read_text(encoding="utf-8")+ + "\n"+ + api_keys_mixin_path.read_text(encoding="utf-8")+ )composer_store_content = composer_store_path.read_text(encoding="utf-8")- config_content = config_path.read_text(encoding="utf-8")+ config_content = (+ config_path.read_text(encoding="utf-8")+ + "\n"+ + model_field_path.read_text(encoding="utf-8")+ )modal_content = modal_path.read_text(encoding="utf-8")assert "apiKeyDirty" in store_content@@ -102,6 +112,6 @@ def test_model_config_frontend_tracks_inline_api_key_edits():assert 'callJsonApi("/banners"' in composer_store_contentassert "/plugins/_model_config/missing_api_key_status" not in composer_store_contentassert "$store.modelConfig.resetApiKeyDrafts();" in config_content- assert '@input="$store.modelConfig.touchApiKey(config[section.key].provider)"' in config_content- assert "updates[provider] = this.keys[provider] || '';" in modal_content+ assert '@input="$store.modelConfig.setApiKeyValue(_prov, $el.value)"' in config_content+ assert "persistAllDirtyApiKeys()" in modal_contentassert "$store.modelConfig.resetApiKeyDrafts();" in modal_contentdiff --git a/tests/test_model_config_project_presets.py b/tests/test_model_config_project_presets.pynew file mode 100644index 000000000..a0d1d1b81--- /dev/null+++ b/tests/test_model_config_project_presets.py@@ -0,0 +1,289 @@+from __future__ import annotations++import json+import sys+import threading+import types+from pathlib import Path++import pytest+from flask import Flask+++PROJECT_ROOT = Path(__file__).resolve().parents[1]+if str(PROJECT_ROOT) not in sys.path:+ sys.path.insert(0, str(PROJECT_ROOT))++sys.modules.setdefault("giturlparse", types.SimpleNamespace(parse=lambda *args, **kwargs: None))+++class _DummyObserver:+ def __init__(self):+ self._alive = False++ def is_alive(self):+ return self._alive++ def start(self):+ self._alive = True++ def stop(self):+ self._alive = False++ def join(self, *args, **kwargs):+ return None++ def unschedule_all(self):+ return None++ def schedule(self, *args, **kwargs):+ return None+++watchdog = types.ModuleType("watchdog")+watchdog.observers = types.SimpleNamespace(Observer=_DummyObserver)+watchdog.events = types.SimpleNamespace(FileSystemEventHandler=object)+sys.modules.setdefault("watchdog", watchdog)+sys.modules.setdefault("watchdog.observers", watchdog.observers)+sys.modules.setdefault("watchdog.events", watchdog.events)+++def _prepare_a0_tree(monkeypatch, tmp_path: Path):+ from helpers import files, plugins++ monkeypatch.setattr(files, "_base_dir", str(tmp_path))+ monkeypatch.setattr(+ plugins,+ "call_plugin_hook",+ lambda plugin_name, hook_name, default=None, **kwargs: default,+ )++ plugin_dir = tmp_path / "plugins" / "_model_config"+ plugin_dir.mkdir(parents=True)+ (plugin_dir / "plugin.yaml").write_text(+ "name: _model_config\nper_project_config: true\nper_agent_config: true\n",+ encoding="utf-8",+ )+ (plugin_dir / "default_presets.yaml").write_text(+ """+- name: Default Balance+ chat:+ provider: openrouter+ name: default-chat+ utility:+ provider: openrouter+ name: default-utility+""".lstrip(),+ encoding="utf-8",+ )+ (plugin_dir / "default_config.yaml").write_text(+ """+allow_chat_override: true+chat_model:+ provider: openrouter+ name: configured-chat+utility_model:+ provider: openrouter+ name: configured-utility+embedding_model:+ provider: huggingface+ name: configured-embedding+""".lstrip(),+ encoding="utf-8",+ )+ (tmp_path / "usr" / "projects").mkdir(parents=True)+++def test_global_presets_keep_legacy_default_and_save_behavior(monkeypatch, tmp_path):+ _prepare_a0_tree(monkeypatch, tmp_path)++ from plugins._model_config.helpers import model_config++ assert model_config.get_presets()[0]["name"] == "Default Balance"++ model_config.save_presets(+ [+ {+ "name": "Global One",+ "scope": "project",+ "project_name": "ignored",+ "chat": {"provider": "openai", "name": "gpt-test", "_kwargs_text": ""},+ }+ ]+ )++ presets = model_config.get_presets()+ assert presets == [+ {"name": "Global One", "chat": {"provider": "openai", "name": "gpt-test"}}+ ]++ saved_path = tmp_path / "usr" / "plugins" / "_model_config" / "presets.yaml"+ assert "scope:" not in saved_path.read_text(encoding="utf-8")++ model_config.save_presets([])+ assert model_config.get_presets() == []++ assert model_config.reset_presets()[0]["name"] == "Default Balance"+++def test_project_presets_are_separate_and_resolve_by_scope(monkeypatch, tmp_path):+ _prepare_a0_tree(monkeypatch, tmp_path)++ from helpers import projects+ from plugins._model_config.helpers import model_config++ projects.create_project("demo", {"title": "Demo"})+ model_config.save_presets(+ [{"name": "Shared", "chat": {"provider": "global", "name": "chat"}}]+ )+ model_config.save_presets(+ [{"name": "Shared", "chat": {"provider": "project", "name": "chat"}}],+ project_name="demo",+ )++ assert model_config.get_presets()[0]["chat"]["provider"] == "global"+ assert model_config.get_project_presets("demo")[0]["chat"]["provider"] == "project"++ combined = model_config.get_combined_presets("demo")+ assert [(item["scope"], item["project_name"], item["name"]) for item in combined] == [+ ("global", "", "Shared"),+ ("project", "demo", "Shared"),+ ]+ assert model_config.resolve_preset("Shared", scope="global")["chat"]["provider"] == "global"+ assert (+ model_config.resolve_preset("Shared", scope="project", project_name="demo")["chat"]["provider"]+ == "project"+ )+++async def test_model_presets_api_returns_global_or_combined_by_project(monkeypatch, tmp_path):+ _prepare_a0_tree(monkeypatch, tmp_path)++ from helpers import projects+ from plugins._model_config.api.model_presets import ModelPresets+ from plugins._model_config.helpers import model_config++ projects.create_project("demo", {"title": "Demo"})+ model_config.save_presets(+ [{"name": "Global", "chat": {"provider": "global", "name": "chat"}}]+ )+ model_config.save_presets(+ [{"name": "Project", "chat": {"provider": "project", "name": "chat"}}],+ project_name="demo",+ )++ handler = ModelPresets(Flask(__name__), threading.Lock())+ global_response = await handler.process({"action": "get"}, None)+ assert global_response["presets"] == [+ {"name": "Global", "chat": {"provider": "global", "name": "chat"}}+ ]+ assert "scope" not in global_response["presets"][0]++ project_response = await handler.process({"action": "get", "project_name": "demo"}, None)+ assert [(p["scope"], p["name"]) for p in project_response["presets"]] == [+ ("global", "Global"),+ ("project", "Project"),+ ]+++def test_project_save_copies_selected_preset_to_scoped_model_config(monkeypatch, tmp_path):+ _prepare_a0_tree(monkeypatch, tmp_path)++ from helpers import projects+ from plugins._model_config.helpers import model_config++ model_config.save_presets(+ [+ {+ "name": "Research",+ "chat": {"provider": "anthropic", "name": "claude-research"},+ "utility": {"provider": "openai", "name": "utility-research"},+ }+ ]+ )++ projects.create_project(+ "demo",+ {+ "title": "Demo",+ "llm": {+ "selected_preset": {"scope": "global", "name": "Research"},+ },+ },+ )++ config_path = (+ tmp_path+ / "usr"+ / "projects"+ / "demo"+ / ".a0proj"+ / "plugins"+ / "_model_config"+ / "config.json"+ )+ config = json.loads(config_path.read_text(encoding="utf-8"))+ assert config["chat_model"]["name"] == "claude-research"+ assert config["utility_model"]["name"] == "utility-research"+ assert config["embedding_model"]["name"] == "configured-embedding"++ project_json = (+ tmp_path / "usr" / "projects" / "demo" / ".a0proj" / "project.json"+ ).read_text(encoding="utf-8")+ assert "llm" not in project_json+ assert "_model_config" not in project_json+++def test_project_save_disambiguates_same_name_project_preset(monkeypatch, tmp_path):+ _prepare_a0_tree(monkeypatch, tmp_path)++ from helpers import projects+ from plugins._model_config.helpers import model_config++ model_config.save_presets(+ [{"name": "Shared", "chat": {"provider": "global", "name": "chat"}}]+ )+ projects.create_project(+ "demo",+ {+ "title": "Demo",+ "llm": {+ "selected_preset": {+ "scope": "project",+ "project_name": "demo",+ "name": "Shared",+ },+ "project_presets": [+ {"name": "Shared", "chat": {"provider": "project", "name": "chat"}}+ ],+ },+ },+ )++ config = json.loads(+ (+ tmp_path+ / "usr"+ / "projects"+ / "demo"+ / ".a0proj"+ / "plugins"+ / "_model_config"+ / "config.json"+ ).read_text(encoding="utf-8")+ )+ assert config["chat_model"]["provider"] == "project"++ presets_yaml = (+ tmp_path+ / "usr"+ / "projects"+ / "demo"+ / ".a0proj"+ / "plugins"+ / "_model_config"+ / "presets.yaml"+ ).read_text(encoding="utf-8")+ assert "scope:" not in presets_yaml+ assert "project_name:" not in presets_yamldiff --git a/webui/components/projects/project-create.html b/webui/components/projects/project-create.htmlindex b8140cd9a..fef27b830 100644--- a/webui/components/projects/project-create.html+++ b/webui/components/projects/project-create.html@@ -36,6 +36,14 @@</div></template>+ <div class="project-detail-inline-section">+ <div class="project-detail-header">+ <span class="projects-project-card-title">LLM</span>+ </div>+ <x-component path="projects/project-edit-llm.html">+ </x-component>+ </div>+<div class="buttons-right"><button type="button" class="button cancel"@click="$store.projects.cancelCreate()"@@ -74,6 +82,12 @@margin-bottom: 1em;}+ .project-detail-inline-section {+ border-top: 1px solid var(--color-border);+ margin-top: 1em;+ padding-top: 1em;+ }+.button-loading {display: inline-flex;align-items: center;@@ -100,4 +114,4 @@}</style>-</html>\ No newline at end of file+</html>diff --git a/webui/components/projects/project-edit-llm.html b/webui/components/projects/project-edit-llm.htmlnew file mode 100644index 000000000..afbda1129--- /dev/null+++ b/webui/components/projects/project-edit-llm.html@@ -0,0 +1,90 @@+<html>++<head>+ <title>Project LLM</title>+ <script type="module">+ import { store } from "/components/projects/projects-store.js";+ import { store as modelConfigStore } from "/plugins/_model_config/webui/model-config-store.js";+ </script>+</head>++<body>+ <div x-data x-init="await $store.modelConfig.ensureLoaded()">+ <template x-if="$store.projects && $store.projects.selectedProject && $store.projects.selectedProject.llm && $store.modelConfig._loaded">+ <div>+ <div class="projects-form-group">+ <label class="projects-form-label">Preset</label>+ <span class="projects-form-description">Pick a preset to copy its main and utility model settings into this project. Embeddings stay with the current project config.</span>+ <select class="projects-form-select"+ x-model="$store.projects.selectedProject.llm.preset_key"+ @change="$store.projects.applySelectedLlmPreset()">+ <option value="current">Current config</option>+ <optgroup label="Global presets">+ <template x-for="preset in $store.projects.selectedProject.llm.global_presets" :key="$store.projects.getLlmPresetKey(preset)">+ <option :value="$store.projects.getLlmPresetKey(preset)" x-text="preset.name"></option>+ </template>+ </optgroup>+ <optgroup label="This project's presets">+ <template x-for="preset in $store.projects.selectedProject.llm.project_presets" :key="$store.projects.getLlmPresetKey(preset)">+ <option :value="$store.projects.getLlmPresetKey(preset)" x-text="preset.name"></option>+ </template>+ </optgroup>+ </select>+ </div>++ <div class="projects-form-group">+ <label class="projects-form-label">Project preset</label>+ <template x-if="$store.projects.selectedProject._meta.creating">+ <span class="projects-form-description">Create or update a preset stored in this project's <strong>_model_config/presets.yaml</strong> when the project is saved.</span>+ </template>+ <template x-if="!$store.projects.selectedProject._meta.creating">+ <span class="projects-form-description">Create or update a preset stored in <strong><span x-text="$store.projects.getSelectedAbsPath('.a0proj','plugins','_model_config','presets.yaml')"></span></strong>.</span>+ </template>+ <div class="projects-input-with-button-wrapper">+ <input class="projects-form-input" type="text"+ x-model="$store.projects.selectedProject.llm.new_preset_name"+ placeholder="Preset name">+ <button type="button" class="button icon-button"+ :disabled="!$store.projects.selectedProject.llm.new_preset_name.trim()"+ @click="$store.projects.saveSelectedLlmProjectPreset()">+ <span class="icon material-symbols-outlined">save</span>+ <span>Save preset</span>+ </button>+ </div>+ </div>++ <template x-for="section in $store.modelConfig.MODEL_SECTIONS" :key="section.key">+ <div class="project-llm-model-section"+ @input.capture="$store.projects.markLlmCurrent()"+ @change.capture="$store.projects.markLlmCurrent()"+ x-data="{ get model() { return $store.projects.selectedProject.llm.config[section.key]; }, get modelType() { return section.key.replace('_model', ''); }, get providers() { return $store.modelConfig.getProviders(section.key); }, get searchType() { return $store.modelConfig.getSearchType(section.key); }, apiKeyMode: 'store' }">+ <div class="project-llm-section-title" x-text="section.title"></div>+ <div class="project-llm-section-description" x-text="section.desc"></div>+ <x-component path="/plugins/_model_config/webui/model-field.html"></x-component>+ </div>+ </template>+ </div>+ </template>+ </div>+</body>+<style>+ .project-llm-model-section {+ border-top: 1px dashed var(--color-border);+ margin-top: 1em;+ padding-top: 1em;+ }++ .project-llm-section-title {+ font-size: 0.95rem;+ font-weight: 700;+ margin-bottom: 0.25em;+ }++ .project-llm-section-description {+ font-size: 0.8rem;+ opacity: 0.75;+ margin-bottom: 0.8em;+ }+</style>++</html>diff --git a/webui/components/projects/project-edit.html b/webui/components/projects/project-edit.htmlindex 0c18d2da1..befba50f9 100644--- a/webui/components/projects/project-edit.html+++ b/webui/components/projects/project-edit.html@@ -34,6 +34,14 @@</x-component></div>+ <div class="project-detail">+ <div class="project-detail-header">+ <span class="projects-project-card-title">LLM</span>+ </div>+ <x-component path="projects/project-edit-llm.html">+ </x-component>+ </div>+<div class="project-detail"><div class="project-detail-header"><span class="projects-project-card-title">Instructions</span>@@ -98,4 +106,4 @@}</style>-</html>\ No newline at end of file+</html>diff --git a/webui/components/projects/projects-store.js b/webui/components/projects/projects-store.jsindex 965e33d11..b24ba365e 100644--- a/webui/components/projects/projects-store.js+++ b/webui/components/projects/projects-store.js@@ -5,6 +5,7 @@ import * as notifications from "/components/notifications/notification-store.js"import { store as chatsStore } from "/components/sidebar/chats/chats-store.js";import { store as browserStore } from "/components/modals/file-browser/file-browser-store.js";import { store as skillsImportStore } from "/components/settings/skills/skills-import-store.js";+import { store as modelConfigStore } from "/plugins/_model_config/webui/model-config-store.js";import * as shortcuts from "/js/shortcuts.js";import { showConfirmDialog } from "/js/confirmDialog.js";@@ -93,7 +94,7 @@ const model = {},async openCreateModal() {- this.selectedProject = this._createNewProjectData();+ this.selectedProject = await this._createNewProjectData();await modals.openModal(createModal);this.selectedProject = null;},@@ -162,6 +163,7 @@ const model = {color: project.color,git_url: project.git_url,git_token: project.git_token || "",+ llm: project.llm || null,},});@@ -396,7 +398,7 @@ const model = {}},- _createNewProjectData() {+ async _createNewProjectData() {return {_meta: {creating: true,@@ -408,6 +410,7 @@ const model = {color: "",git_url: "",git_token: "",+ llm: await this._createProjectLlmData(""),};},@@ -423,9 +426,207 @@ const model = {creating: false,},...projectData,+ llm: this._normalizeProjectLlmData(projectData.llm, name),};},+ async _createProjectLlmData(projectName) {+ await modelConfigStore.ensureLoaded();+ const configResult = await api.callJsonApi("/plugins/_model_config/model_config_get", {+ project_name: projectName || "",+ });+ const presetsResult = await api.callJsonApi("/plugins/_model_config/model_presets", {+ action: "get",+ project_name: projectName || "",+ scope: projectName ? "combined" : "global",+ });+ return this._normalizeProjectLlmData({+ config: configResult.config || {},+ selected_preset: {+ scope: "current",+ project_name: projectName || "",+ name: "Current config",+ },+ global_presets: presetsResult.global_presets || presetsResult.presets || [],+ project_presets: presetsResult.project_presets || [],+ presets: presetsResult.presets || [],+ }, projectName);+ },++ _normalizeProjectLlmData(raw, projectName) {+ const data = raw || {};+ const config = JSON.parse(JSON.stringify(data.config || {}));+ config.chat_model = config.chat_model || {};+ config.utility_model = config.utility_model || {};+ config.embedding_model = config.embedding_model || {};+ modelConfigStore.initConfigFields(config);++ const globalPresets = this._normalizePresetsWithScope(+ data.global_presets || [],+ "global",+ ""+ );+ const projectPresets = this._normalizePresetsWithScope(+ data.project_presets || [],+ "project",+ projectName || ""+ );+ const presets = [+ ...globalPresets,+ ...projectPresets,+ ];+ const selected = data.selected_preset || {+ scope: "current",+ project_name: projectName || "",+ name: "Current config",+ };+ return {+ config,+ selected_preset: selected,+ preset_key: this.getLlmPresetKey(selected),+ global_presets: globalPresets,+ project_presets: projectPresets,+ presets,+ new_preset_name: "",+ };+ },++ _normalizePresetsWithScope(presets, defaultScope, projectName) {+ return modelConfigStore._normalizePresets(presets || []).map((preset, index) => {+ const raw = presets[index] || {};+ return {+ ...preset,+ scope: raw.scope || defaultScope,+ project_name: raw.project_name || (defaultScope === "project" ? projectName : ""),+ };+ });+ },++ getLlmPresetKey(preset) {+ if (!preset || preset.scope === "current") return "current";+ return `${preset.scope || "global"}|${preset.project_name || ""}|${preset.name || ""}`;+ },++ _findLlmPresetByKey(key) {+ const llm = this.selectedProject?.llm;+ if (!llm || key === "current") return null;+ return (llm.presets || []).find((preset) => this.getLlmPresetKey(preset) === key) || null;+ },++ applySelectedLlmPreset() {+ const llm = this.selectedProject?.llm;+ if (!llm) return;+ if (llm.preset_key === "current") {+ llm.selected_preset = {+ scope: "current",+ project_name: this.selectedProject?.name || "",+ name: "Current config",+ };+ return;+ }+ const preset = this._findLlmPresetByKey(llm.preset_key);+ if (!preset) return;+ llm.selected_preset = {+ scope: preset.scope || "global",+ project_name: preset.project_name || "",+ name: preset.name || "",+ };+ llm.config = this._configFromPreset(preset, llm.config || {});+ modelConfigStore.initConfigFields(llm.config);+ },++ markLlmCurrent() {+ const llm = this.selectedProject?.llm;+ if (!llm) return;+ llm.selected_preset = {+ scope: "current",+ project_name: this.selectedProject?.name || "",+ name: "Current config",+ };+ llm.preset_key = "current";+ },++ _configFromPreset(preset, baseConfig) {+ const config = JSON.parse(JSON.stringify(baseConfig || {}));+ if (preset.chat) config.chat_model = this._cleanModelSlot(preset.chat, true);+ if (preset.utility?.provider || preset.utility?.name) {+ config.utility_model = this._cleanModelSlot(preset.utility, true);+ }+ return config;+ },++ _cleanModelSlot(slot, stripApiKey = true) {+ const clean = JSON.parse(JSON.stringify(slot || {}));+ for (const key of Object.keys(clean)) {+ if (key.startsWith("_")) delete clean[key];+ }+ if (stripApiKey) delete clean.api_key;+ return clean;+ },++ _presetFromLlmConfig(name, config) {+ return {+ name,+ chat: this._cleanModelSlot(config?.chat_model || {}, true),+ utility: this._cleanModelSlot(config?.utility_model || {}, true),+ };+ },++ async saveSelectedLlmProjectPreset() {+ const project = this.selectedProject;+ const llm = project?.llm;+ const name = (llm?.new_preset_name || "").trim();+ if (!project || !llm || !name) return;++ const preset = {+ ...this._presetFromLlmConfig(name, llm.config || {}),+ scope: "project",+ project_name: project.name || "",+ };+ const projectPresets = llm.project_presets || (llm.project_presets = []);+ const existingIndex = projectPresets.findIndex((p) => p.name === name);+ if (existingIndex >= 0) projectPresets.splice(existingIndex, 1, preset);+ else projectPresets.push(preset);++ llm.presets = [+ ...(llm.global_presets || []),+ ...(llm.project_presets || []),+ ];+ llm.selected_preset = {+ scope: "project",+ project_name: project.name || "",+ name,+ };+ llm.preset_key = this.getLlmPresetKey(llm.selected_preset);+ llm.new_preset_name = "";++ if (!project._meta?.creating && project.name) {+ await api.callJsonApi("/plugins/_model_config/model_presets", {+ action: "save",+ scope: "project",+ project_name: project.name,+ presets: llm.project_presets,+ });+ notifications.toastFrontendSuccess(+ "Project preset saved",+ "LLM preset",+ 3,+ "projects_llm",+ notifications.NotificationPriority.NORMAL,+ true+ );+ } else {+ notifications.toastFrontendSuccess(+ "Project preset ready",+ "LLM preset",+ 3,+ "projects_llm",+ notifications.NotificationPriority.NORMAL,+ true+ );+ }+ },+async browseSelected(...relPath) {const path = this.getSelectedAbsPath(...relPath);return await browserStore.open(path);