aria-code 0.52.0__py3-none-any.whl

aria_code/packages/aria_services/registry.py

@@ -0,0 +1,249 @@
+"""Product-level service contracts for Aria Code.
+
+These manifests describe stable service boundaries. They intentionally wrap the
+current modules instead of moving code all at once, so the CLI can migrate away
+from the large legacy entrypoint incrementally.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, List
+
+from aria_code.packages.aria_core import CapabilityManifest, PackageLink, PermissionLevel, ServiceKind
+
+
+@dataclass(frozen=True)
+class ServiceSpec:
+    name: str
+    description: str
+    owner_package: str
+    module: str
+    capabilities: List[str] = field(default_factory=list)
+    permissions: List[PermissionLevel] = field(default_factory=list)
+    required: bool = True
+    migration_target: str = ""
+
+    def manifest(self) -> CapabilityManifest:
+        tags = ["service"]
+        if self.required:
+            tags.append("required")
+        return CapabilityManifest(
+            name=self.name,
+            kind=ServiceKind.DATA if self.name == "data" else ServiceKind.SERVICE,
+            description=self.description,
+            capabilities=self.capabilities,
+            permissions=self.permissions,
+            package_link=PackageLink(
+                package=self.owner_package,
+                module=self.module,
+                object_name=self.migration_target,
+                notes="Facade over existing modules; migrate implementation behind this boundary.",
+            ),
+            tags=tags,
+        )
+
+
+def list_service_specs() -> List[ServiceSpec]:
+    """Return stable service boundaries for the Aria Code product."""
+
+    return [
+        ServiceSpec(
+            name="gateway",
+            description="Local-first control plane for CLI, daemon, MCP, and channel entrypoints.",
+            owner_package="packages.aria_services",
+            module="apps.gateway",
+            capabilities=["session.routing", "task.queue", "mcp.routing", "channel.routing"],
+            permissions=[PermissionLevel.READ_ONLY, PermissionLevel.WORKSPACE_WRITE],
+            migration_target="GatewayService",
+        ),
+        ServiceSpec(
+            name="runtime",
+            description="Agent turn loop, tool execution, approvals, traces, and parallel tool orchestration.",
+            owner_package="runtime",
+            module="runtime",
+            capabilities=["agent.loop", "tool.execution", "approval.policy", "trace"],
+            permissions=[PermissionLevel.READ_ONLY, PermissionLevel.WORKSPACE_WRITE],
+            migration_target="AgentRuntime",
+        ),
+        ServiceSpec(
+            name="settings",
+            description="Configuration, secrets, model profiles, runtime flags, and permission policy resolution.",
+            owner_package="packages.aria_services",
+            module="packages.aria_services.settings",
+            capabilities=[
+                "settings.config",
+                "settings.secrets",
+                "settings.model_profiles",
+                "settings.permission_policy",
+            ],
+            permissions=[PermissionLevel.READ_ONLY],
+            migration_target="SettingsService",
+        ),
+        ServiceSpec(
+            name="context",
+            description="Conversation memory, context pressure checks, compaction, and resumable summary envelopes.",
+            owner_package="packages.aria_services",
+            module="packages.aria_services.context",
+            capabilities=[
+                "context.memory",
+                "context.compaction",
+                "context.resume",
+                "context.checkpoint",
+            ],
+            permissions=[PermissionLevel.READ_ONLY, PermissionLevel.WORKSPACE_WRITE],
+            migration_target="ContextService",
+        ),
+        ServiceSpec(
+            name="references",
+            description="Typed read-only @ references for files, folders, assets, and research artifacts.",
+            owner_package="packages.aria_services",
+            module="packages.aria_services.references",
+            capabilities=[
+                "context.reference.parse",
+                "context.reference.resolve",
+                "context.reference.tool_plan",
+                "context.reference.complete",
+            ],
+            permissions=[PermissionLevel.READ_ONLY],
+            migration_target="ReferenceService",
+        ),
+        ServiceSpec(
+            name="tools",
+            description="Typed tool manifests, schemas, permissions, local tool adapters, and MCP tool conversion.",
+            owner_package="packages.aria_tools",
+            module="packages.aria_tools",
+            capabilities=[
+                "tool.registry",
+                "tool.schema",
+                "tool.permissions",
+                "tool.local_adapter",
+                "tool.mcp_adapter",
+            ],
+            permissions=[PermissionLevel.READ_ONLY, PermissionLevel.WORKSPACE_WRITE, PermissionLevel.NETWORK],
+            migration_target="ToolRegistry",
+        ),
+        ServiceSpec(
+            name="data",
+            description="Multi-source market data with timestamps, provider attribution, and stale-data flags.",
+            owner_package="packages.aria_services",
+            module="data_service",
+            capabilities=["market.quote", "market.history", "technical.indicators", "data.quality"],
+            permissions=[PermissionLevel.NETWORK],
+            migration_target="MarketDataService",
+        ),
+        ServiceSpec(
+            name="reports",
+            description="Report, chart, and artifact generation with local workspace storage policies.",
+            owner_package="packages.aria_services",
+            module="report_generator",
+            capabilities=[
+                "report.markdown",
+                "report.html",
+                "chart.render",
+                "artifact.storage",
+            ],
+            permissions=[PermissionLevel.READ_ONLY, PermissionLevel.WORKSPACE_WRITE],
+            migration_target="ReportService",
+        ),
+        ServiceSpec(
+            name="research_quality",
+            description="Deterministic report completion, plausibility, coverage, and provenance gates.",
+            owner_package="packages.aria_services",
+            module="packages.aria_services.research_quality",
+            capabilities=["report.quality_gate", "report.provenance", "report.plausibility"],
+            permissions=[PermissionLevel.READ_ONLY],
+            migration_target="ReportQualityAssessment",
+        ),
+        ServiceSpec(
+            name="brokers",
+            description="Broker account reads, paper trading, order previews, guarded execution, and audit trails.",
+            owner_package="brokers",
+            module="brokers",
+            capabilities=[
+                "broker.account",
+                "broker.positions",
+                "broker.orders",
+                "broker.paper",
+                "broker.trade_preview",
+                "broker.confirmed_execution",
+                "broker.audit",
+            ],
+            permissions=[PermissionLevel.BROKER_READ, PermissionLevel.BROKER_TRADE],
+            migration_target="BrokerService",
+        ),
+        ServiceSpec(
+            name="skills",
+            description="Workflow recipes that bind tools, agents, data, reports, and brokers.",
+            owner_package="packages.aria_skills",
+            module="packages.aria_skills",
+            capabilities=[
+                "skill.registry",
+                "skill.discovery",
+                "skill.metadata_route",
+                "skill.namespace",
+                "skill.integrity",
+                "skill.activation_trace",
+                "workflow.binding",
+            ],
+            permissions=[PermissionLevel.READ_ONLY],
+            migration_target="SkillRegistry",
+        ),
+        ServiceSpec(
+            name="mcp",
+            description="MCP server discovery, health, tool provenance, reconnect policy, and manifest conversion.",
+            owner_package="packages.aria_mcp",
+            module="packages.aria_mcp",
+            capabilities=[
+                "mcp.discovery",
+                "mcp.health",
+                "mcp.tool_manifests",
+                "mcp.reconnect",
+                "mcp.provenance",
+            ],
+            permissions=[PermissionLevel.READ_ONLY, PermissionLevel.NETWORK],
+            migration_target="MCPService",
+        ),
+        ServiceSpec(
+            name="channels",
+            description="Optional external entrypoints such as daemon, relay, Feishu, Telegram, and webhooks.",
+            owner_package="apps.channels",
+            module="apps.channels",
+            capabilities=["channel.daemon", "channel.relay", "channel.feishu", "channel.telegram"],
+            permissions=[PermissionLevel.NETWORK],
+            required=False,
+            migration_target="ChannelRegistry",
+        ),
+        ServiceSpec(
+            name="safety",
+            description="Sandbox, workspace permissions, command policy, privacy controls, and audit hooks.",
+            owner_package="safety",
+            module="safety",
+            capabilities=["sandbox", "command.policy", "privacy", "audit"],
+            permissions=[PermissionLevel.READ_ONLY],
+            migration_target="SafetyService",
+        ),
+        ServiceSpec(
+            name="observability",
+            description="Doctor checks, runtime traces, provider health, architecture coverage, and support bundles.",
+            owner_package="packages.aria_infra",
+            module="packages.aria_infra.doctor",
+            capabilities=[
+                "doctor.checks",
+                "trace.export",
+                "provider.health",
+                "architecture.coverage",
+                "support.bundle",
+            ],
+            permissions=[PermissionLevel.READ_ONLY, PermissionLevel.WORKSPACE_WRITE],
+            migration_target="ObservabilityService",
+        ),
+    ]
+
+
+def service_map() -> Dict[str, ServiceSpec]:
+    return {service.name: service for service in list_service_specs()}
+
+
+def required_service_names() -> List[str]:
+    return [service.name for service in list_service_specs() if service.required]

aria_code/packages/aria_services/research_protocol.py

@@ -0,0 +1,57 @@
+"""Financial-research grounding policy shared by Aria adapters."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable, Mapping
+
+
+_MARKET_IDENTIFIER = re.compile(
+    r"\b[A-Z]{1,5}(?:\.[A-Z]{1,4})?\b|\b\d{6}(?:\.(?:SH|SZ|SS|HK))?\b"
+)
+_FINANCIAL_SUBJECTS = (
+    "stock", "share", "equity", "market", "portfolio", "holding", "fund",
+    "option", "bond", "forex", "crypto", "price", "volume", "valuation",
+    "股票", "股价", "行情", "市场", "持仓", "组合", "基金", "期权", "债券",
+    "外汇", "加密", "成交量", "估值", "市值", "财报", "基本面",
+)
+_EVIDENCE_INTENTS = (
+    "analyze", "analysis", "forecast", "predict", "recommend", "buy", "sell",
+    "current", "latest", "today", "trend", "risk", "target", "outlook",
+    "分析", "预测", "推荐", "买入", "卖出", "最新", "当前", "今天", "走势",
+    "趋势", "风险", "目标价", "前景", "成交量", "全面分析",
+)
+_GROUNDING_TOOL_FRAGMENTS = (
+    "market", "quote", "price", "ohlcv", "fundamental", "filing", "news",
+    "factor", "risk", "backtest", "portfolio", "prediction", "signal",
+    "regime", "financial", "earnings", "valuation", "macro", "flow",
+)
+
+
+def requires_financial_evidence(query: str) -> bool:
+    """Return whether a request needs current external financial evidence."""
+    text = str(query or "").strip()
+    if not text:
+        return False
+    lowered = text.lower()
+    has_subject = bool(_MARKET_IDENTIFIER.search(text)) or any(
+        term in lowered for term in _FINANCIAL_SUBJECTS
+    )
+    return has_subject and any(term in lowered for term in _EVIDENCE_INTENTS)
+
+
+def grounding_tool_names(tool_schemas: Iterable[Mapping]) -> frozenset[str]:
+    """Select registered tools whose outputs can ground a financial conclusion."""
+    names: set[str] = set()
+    for schema in tool_schemas:
+        function = schema.get("function") if isinstance(schema, Mapping) else None
+        name = str(
+            (function or {}).get("name")
+            if isinstance(function, Mapping)
+            else schema.get("name", "")
+        )
+        canonical = name.rsplit("__", 1)[-1].lower()
+        if name and any(fragment in canonical for fragment in _GROUNDING_TOOL_FRAGMENTS):
+            names.add(name)
+    return frozenset(names)
+

aria_code/packages/aria_services/research_quality.py

@@ -0,0 +1,186 @@
+"""Deterministic completion gates for multi-agent research reports."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any, Iterable
+
+
+class ReportQualityDecision(str, Enum):
+    COMPLETE = "complete"
+    PARTIAL = "partial"
+    BLOCKED = "blocked"
+
+
+def _utc_timestamp() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+
+@dataclass(frozen=True)
+class ReportQualityPolicy:
+    min_agent_coverage: float = 0.60
+    min_core_coverage: float = 2 / 3
+    core_agents: tuple[str, ...] = ("technical", "fundamental", "risk")
+    max_degraded_ratio: float = 0.50
+    require_quote: bool = True
+    allow_stale: bool = False
+    max_market_cap: float = 100_000_000_000_000.0
+    max_implied_shares: float = 100_000_000_000.0
+
+
+@dataclass(frozen=True)
+class ReportQualityAssessment:
+    decision: ReportQualityDecision
+    requested_agents: tuple[str, ...]
+    usable_agents: tuple[str, ...]
+    degraded_agents: tuple[str, ...]
+    failed_agents: tuple[str, ...]
+    agent_coverage: float
+    core_coverage: float
+    reasons: tuple[str, ...] = field(default_factory=tuple)
+    warnings: tuple[str, ...] = field(default_factory=tuple)
+    blocking_reasons: tuple[str, ...] = field(default_factory=tuple)
+    assessed_at: str = field(default_factory=_utc_timestamp)
+
+    @property
+    def metadata_status(self) -> str:
+        if self.decision is ReportQualityDecision.BLOCKED:
+            return "data_unavailable"
+        return self.decision.value
+
+    def to_dict(self) -> dict[str, Any]:
+        data = asdict(self)
+        data["decision"] = self.decision.value
+        data["metadata_status"] = self.metadata_status
+        data["core_agent_coverage"] = data["core_coverage"]
+        data["_contract_type"] = "ResearchQualityAssessment"
+        data["_contract_version"] = "1.0.0"
+        return data
+
+
+def _as_float(value: Any) -> float | None:
+    try:
+        if value in (None, ""):
+            return None
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _unique(values: Iterable[str]) -> tuple[str, ...]:
+    return tuple(dict.fromkeys(value for value in values if value))
+
+
+def assess_team_report(
+    team_result: Any,
+    data_bundle: Any = None,
+    policy: ReportQualityPolicy | None = None,
+) -> ReportQualityAssessment:
+    """Assess whether a report is complete, usable with caveats, or blocked."""
+    policy = policy or ReportQualityPolicy()
+    requested = _unique(
+        str(name)
+        for name in (getattr(team_result, "agents_run", None) or [])
+        if name not in {"synthesis", "debate"}
+    )
+    results = list(getattr(team_result, "results", None) or [])
+    if not requested:
+        requested = _unique(
+            str(getattr(result, "agent", ""))
+            for result in results
+            if getattr(result, "agent", "") not in {"synthesis", "debate"}
+        )
+
+    result_by_agent = {
+        str(getattr(result, "agent", "")): result
+        for result in results
+        if getattr(result, "agent", "")
+    }
+    usable = _unique(
+        name
+        for name in requested
+        if name in result_by_agent
+        and bool(getattr(result_by_agent[name], "success", False))
+        and bool(str(getattr(result_by_agent[name], "analysis", "") or "").strip())
+    )
+    degraded = _unique(
+        name for name in usable if bool(getattr(result_by_agent[name], "degraded", False))
+    )
+    failed = _unique(name for name in requested if name not in usable)
+    coverage = len(usable) / len(requested) if requested else 0.0
+    expected_core = tuple(name for name in policy.core_agents if name in requested)
+    core_coverage = (
+        sum(1 for name in expected_core if name in usable) / len(expected_core)
+        if expected_core else 1.0
+    )
+
+    warnings: list[str] = []
+    blocking: list[str] = []
+    reasons: list[str] = []
+
+    quote = dict(getattr(data_bundle, "quote", {}) or {}) if data_bundle else {}
+    price = _as_float(quote.get("price") or quote.get("current_price"))
+    volume = _as_float(quote.get("volume"))
+    market_cap = _as_float(quote.get("market_cap") or quote.get("marketCap"))
+    data_status = str(getattr(data_bundle, "status", "") or "").lower() if data_bundle else ""
+    stale = bool((getattr(data_bundle, "quality", {}) or {}).get("stale", False)) if data_bundle else False
+
+    if policy.require_quote and (price is None or price <= 0):
+        blocking.append("missing or invalid reference price")
+    if volume is not None and volume < 0:
+        blocking.append("negative volume")
+    if market_cap is not None:
+        if market_cap <= 0:
+            warnings.append("invalid market capitalization")
+        elif market_cap > policy.max_market_cap:
+            warnings.append("market capitalization exceeds plausibility limit")
+        if price and price > 0 and market_cap / price > policy.max_implied_shares:
+            warnings.append("implied share count exceeds plausibility limit")
+
+    if data_status in {"data_unavailable", "unavailable", "failed"}:
+        blocking.append("market data bundle unavailable")
+    elif data_status in {"partial", "stale"}:
+        warnings.append(f"market data status is {data_status}")
+    if stale and not policy.allow_stale:
+        warnings.append("market data is stale")
+    if not usable:
+        blocking.append("no agent produced usable analysis")
+    if coverage < policy.min_agent_coverage:
+        warnings.append(
+            f"agent coverage {coverage:.0%} is below {policy.min_agent_coverage:.0%}"
+        )
+    if core_coverage < policy.min_core_coverage:
+        warnings.append(
+            f"core-agent coverage {core_coverage:.0%} is below {policy.min_core_coverage:.0%}"
+        )
+    degraded_ratio = len(degraded) / len(usable) if usable else 0.0
+    if degraded_ratio > policy.max_degraded_ratio:
+        warnings.append(f"degraded-agent ratio {degraded_ratio:.0%} is too high")
+
+    if blocking:
+        decision = ReportQualityDecision.BLOCKED
+    elif warnings:
+        decision = ReportQualityDecision.PARTIAL
+    else:
+        decision = ReportQualityDecision.COMPLETE
+
+    reasons.append(f"usable agents: {len(usable)}/{len(requested)}")
+    if degraded:
+        reasons.append(f"degraded agents: {', '.join(degraded)}")
+    if failed:
+        reasons.append(f"failed agents: {', '.join(failed)}")
+
+    return ReportQualityAssessment(
+        decision=decision,
+        requested_agents=requested,
+        usable_agents=usable,
+        degraded_agents=degraded,
+        failed_agents=failed,
+        agent_coverage=round(coverage, 4),
+        core_coverage=round(core_coverage, 4),
+        reasons=_unique(reasons),
+        warnings=_unique(warnings),
+        blocking_reasons=_unique(blocking),
+    )

aria_code/packages/aria_services/settings.py

@@ -0,0 +1,157 @@
+"""SettingsService — single owner of persistent Aria configuration.
+
+This is the concrete implementation behind the ``settings`` ServiceSpec in
+``packages.aria_services.registry`` (capability ``settings.config``). It owns
+the merge/normalize/persist mechanics that previously lived in
+``apps/cli/config_store.py``; that module is now a thin CLI adapter which
+constructs this service with CLI-specific hooks.
+
+Layering: this package must stay importable by launcher, daemon, brokers and
+MCP without dragging in the CLI. Anything CLI-flavored (provider-name
+normalization, i18n language detection, model auto-selection, policy sync) is
+injected as an optional callable rather than imported from ``apps.cli``.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Optional
+
+
+# Models that no longer exist / were renamed; a saved config pointing at one
+# is silently reset to the caller's default so the CLI never boots into a
+# permanently-broken model selection.
+STALE_ARIA_MODEL_PREFIXES = ("aria-opus", "aria-prelude", "aria-sonata:3", "aria-sonata:4")
+
+# Keys that are session state, not configuration — never persisted.
+NEVER_PERSIST = frozenset({"conversation_history"})
+
+
+@dataclass
+class SettingsService:
+    """Load, normalize, persist, and hand out the Aria config dict.
+
+    ``config_dir``/``config_file``/``sessions_dir`` duck-type
+    ``apps.cli.config_paths.AriaConfigPaths`` so the CLI can pass its existing
+    paths object fields straight through.
+    """
+
+    config_dir: Path
+    config_file: Path
+    sessions_dir: Path
+    defaults: dict = field(default_factory=dict)
+    # Optional environment hooks (all safe to omit):
+    normalize_provider: Optional[Callable[[str], str]] = None
+    detect_lang: Optional[Callable[[], str]] = None
+    # There was an auto_select_model hook here. It probed Ollama on first run
+    # and replaced the caller's default model with whatever was installed; see
+    # load(). Removed rather than left unwired, so it is not reconnected by
+    # someone who finds an unused hook and assumes it should be doing something.
+    on_loaded: Optional[Callable[[dict], None]] = None  # e.g. CLI policy sync
+    stale_model_prefixes: tuple = STALE_ARIA_MODEL_PREFIXES
+
+    _snapshot: Optional[dict] = field(default=None, repr=False)
+
+    # ── core API ─────────────────────────────────────────────────────────────
+
+    def load(self) -> dict:
+        """Read config file, merge over defaults, normalize, fire on_loaded."""
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        self.sessions_dir.mkdir(parents=True, exist_ok=True)
+        if self.config_file.exists():
+            try:
+                saved = json.loads(self.config_file.read_text(encoding="utf-8"))
+                merged = {**self.defaults, **saved}
+                self._infer_local_provider(merged, saved)
+                self._reset_stale_model(merged)
+                self._ensure_ui_lang(merged)
+                self._finish_load(merged)
+                return merged
+            except Exception:
+                pass
+
+        # First run: the defaults stand as written. This used to probe Ollama
+        # here and overwrite cfg["model"] with whatever was installed, which
+        # contradicted the comment above DEFAULT_MODEL in apps/cli/bootstrap.py
+        # -- "provider configuration is the user's to make ... the code's job is
+        # to have a sane default and then get out of the way". It also cost a
+        # 3s HTTP timeout on every first start, and it was not needed for
+        # discoverability: the banner already reports "Ollama online · N models"
+        # (ui/banner.ollama_status_label), so a user with local models can see
+        # them and run /model.
+        cfg = dict(self.defaults)
+        try:
+            if self.detect_lang is not None:
+                cfg["ui_lang"] = self.detect_lang()
+        except Exception:
+            cfg["ui_lang"] = "en"
+        cfg.setdefault("ui_lang", "en")
+        self._finish_load(cfg)
+        return cfg
+
+    def save(self, cfg: dict) -> None:
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        payload = {k: v for k, v in cfg.items() if k not in NEVER_PERSIST}
+        # config.json holds auth_token / refresh_token from /login, so it is
+        # written owner-only like the other credential files.
+        from aria_code.packages.aria_core.secure_file import write_secret_json
+
+        write_secret_json(self.config_file, payload)
+        self._snapshot = dict(cfg)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Read one key from the last-loaded snapshot (loads on first use)."""
+        if self._snapshot is None:
+            self.load()
+        return self._snapshot.get(key, default)
+
+    def set(self, key: str, value: Any) -> dict:
+        """Update one key and persist immediately; returns the new snapshot."""
+        if self._snapshot is None:
+            self.load()
+        cfg = dict(self._snapshot)
+        cfg[key] = value
+        self.save(cfg)
+        return cfg
+
+    def snapshot(self) -> dict:
+        """The last-loaded/saved config dict (loads on first use)."""
+        if self._snapshot is None:
+            self.load()
+        return dict(self._snapshot)
+
+    # ── normalization steps (extracted verbatim from the CLI loader) ─────────
+
+    def _infer_local_provider(self, merged: dict, saved: dict) -> None:
+        saved_model = merged.get("model", "")
+        if "local_provider" not in saved:
+            merged["local_provider"] = (
+                saved_model.split("/", 1)[0].lower() if "/" in saved_model else "ollama"
+            )
+        if self.normalize_provider is not None:
+            try:
+                merged["local_provider"] = (
+                    self.normalize_provider(merged.get("local_provider")) or "ollama"
+                )
+            except Exception:
+                pass
+
+    def _reset_stale_model(self, merged: dict) -> None:
+        model = merged.get("model", "")
+        if any(model.startswith(p) for p in self.stale_model_prefixes):
+            merged["model"] = self.defaults.get("model", "")
+
+    def _ensure_ui_lang(self, merged: dict) -> None:
+        if not merged.get("ui_lang"):
+            try:
+                merged["ui_lang"] = self.detect_lang() if self.detect_lang else "en"
+            except Exception:
+                merged["ui_lang"] = "en"
+
+    def _finish_load(self, cfg: dict) -> None:
+        self._snapshot = dict(cfg)
+        if self.on_loaded is not None:
+            self.on_loaded(cfg)