Skip to content

Agent Zero AI framework

Add project-scoped LLM presets

Alessandrofe2310aa9000
diff --git a/docs/developer/extensions.md b/docs/developer/extensions.md
index 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 `.a0p
These 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 Projects
Projects 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.md
index a7a808ca3..06d0e7281 100644
--- a/docs/guides/projects.md
+++ b/docs/guides/projects.md
@@ -223,6 +223,41 @@ SMTP_PASSWORD=email_pwd_here
Projects 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 Files
Import project-specific knowledge documents:
diff --git a/helpers/projects.py b/helpers/projects.py
index 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 None
abs_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 name
def 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 None
abs_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: BasicProjec
data = _normalizeBasicData(data)
data["git_url"] = clean_url
save_project_header(actual_name, data)
+
+ save_project_llm_settings(actual_name, llm_data)
return actual_name
except 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 state
current = 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.py
index 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_config
action = 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.md
index 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.py
index 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_config
class 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.py
index 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 models
from helpers import plugins, files
from helpers import yaml as yaml_helper
@@ -6,12 +8,18 @@ from helpers.providers import get_providers
PRESETS_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 plugin
default_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 p
return 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.py
index 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_content
assert "/plugins/_model_config/missing_api_key_status" not in composer_store_content
assert "$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_content
assert "$store.modelConfig.resetApiKeyDrafts();" in modal_content
diff --git a/tests/test_model_config_project_presets.py b/tests/test_model_config_project_presets.py
new file mode 100644
index 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_yaml
diff --git a/webui/components/projects/project-create.html b/webui/components/projects/project-create.html
index 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.html
new file mode 100644
index 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.html
index 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.js
index 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);