claude-code-capabilities 0.1.2__tar.gz

claude_code_capabilities-0.1.2/.claude-plugin/plugin.json

@@ -0,0 +1,22 @@
+{
+  "name": "capdisc",
+  "displayName": "Capabilities Discovery",
+  "version": "0.1.0",
+  "description": "Inventory the machine's Claude Code capabilities — skills, agents, plugins, MCP servers, hooks, and built-in tools across user/project/plugin scopes — into a typed JSON catalog and an HTML environment report.",
+  "author": {
+    "name": "Magic-Man-us"
+  },
+  "repository": "https://github.com/Magic-Man-us/capability-discovery",
+  "license": "MIT",
+  "keywords": [
+    "capabilities",
+    "catalog",
+    "skills",
+    "agents",
+    "plugins",
+    "mcp",
+    "hooks",
+    "environment-report"
+  ],
+  "defaultEnabled": true
+}

claude_code_capabilities-0.1.2/.github/workflows/ci.yml

@@ -0,0 +1,19 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v8.3.2
+        with:
+          enable-cache: true
+      - run: uv sync --locked
+      - run: uv run ruff check .
+      - run: uv run mypy src
+      - run: uv run pytest -q

claude_code_capabilities-0.1.2/.github/workflows/publish.yml

@@ -0,0 +1,39 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v8.3.2
+        with:
+          enable-cache: true
+      - run: uv sync --locked
+      - run: uv run ruff check .
+      - run: uv run mypy src
+      - run: uv run pytest -q
+      - run: uv build
+      - uses: actions/upload-artifact@v7
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          password: ${{ secrets.PYPI_API_TOKEN }}

claude_code_capabilities-0.1.2/.gitignore

@@ -0,0 +1,22 @@
+__pycache__/
+*.pyc
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+*.egg-info/
+dist/
+build/
+.venv/
+venv/
+.coverage
+
+# >>> AgentForge managed gitignore (do not edit between markers) >>>
+**/.agentforge/audit.jsonl
+**/.agentforge/backups/
+**/.agentforge/tombstones/
+**/.agentforge/logs/
+**/.agentforge/sessions/
+**/.agentforge/diagnostics/
+**/.agentforge/cache/
+# <<< AgentForge managed gitignore <<<
+discovery-report.html

claude_code_capabilities-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Magic-Man-us
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

claude_code_capabilities-0.1.2/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: claude-code-capabilities
+Version: 0.1.2
+Summary: Discovers Claude Code capabilities — skills, agents, plugins, MCP servers, hooks — into typed catalogs and an environment report.
+Project-URL: Homepage, https://github.com/Magic-Man-us/capability-discovery
+Project-URL: Repository, https://github.com/Magic-Man-us/capability-discovery
+Author: Magic-Man-us
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: fastmcp>=3.4.4
+Requires-Dist: py-key-value-aio[filetree]>=0.4.5
+Requires-Dist: pydantic-settings>=2.14.2
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: pyyaml>=6.0.3
+Description-Content-Type: text/markdown
+
+# capdisc
+
+[![PyPI](https://img.shields.io/pypi/v/claude-code-capabilities.svg)](https://pypi.org/project/claude-code-capabilities/)
+[![Python versions](https://img.shields.io/pypi/pyversions/claude-code-capabilities.svg)](https://pypi.org/project/claude-code-capabilities/)
+[![CI](https://github.com/Magic-Man-us/capability-discovery/actions/workflows/ci.yml/badge.svg)](https://github.com/Magic-Man-us/capability-discovery/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/Magic-Man-us/capability-discovery/blob/main/LICENSE)
+
+Discovers Claude Code capabilities — skills, agents, plugins, MCP servers, hooks — into typed
+Pydantic catalogs and an environment report.
+
+## Install
+
+```bash
+uv add claude-code-capabilities
+# or
+pip install claude-code-capabilities
+```
+
+## CLI
+
+```bash
+capdisc            # scan this machine, write discovery-report.json + .html
+capdisc --oauth     # also allow the interactive OAuth flow for HTTP MCP servers
+                    # with a pre-registered client (forces a fresh MCP harvest)
+```
+
+Both files are written to `~/.claude/capdisc/` by default. Configure paths and MCP auth via env
+vars (`CAPDISC_` prefix), a `.env` file, or `~/.claude/capdisc/config.json`/`config.yaml` — see
+`DiscoverySettings` in `settings.py` for every field.
+
+## Library
+
+Scan the machine into a typed catalog:
+
+```python
+from pathlib import Path
+from capdisc.discovery import scan_environment
+from capdisc.scope import ScopeRoots
+
+roots = ScopeRoots.discover(start=Path.cwd(), home_dir=Path.home())
+catalog = scan_environment(roots)
+for entry in catalog.entries:
+    ...  # CatalogSkill | CatalogTool | CatalogMcpServer | CatalogPlugin
+```
+
+Build and persist the full environment report (what the CLI does):
+
+```python
+from capdisc.report import build_report, write_report
+
+report = build_report(oauth=False)
+write_report(report)  # -> ~/.claude/capdisc/discovery-report.{json,html}
+```
+
+Inspect the on-disk scope inventory directly — every skill/agent/command/hook found, its
+precedence, and which ones actually win a collision:
+
+```python
+from capdisc.scope import ScopeInventory, ScopeRoots
+
+inventory = ScopeInventory.scan(ScopeRoots.discover(start=Path.cwd(), home_dir=Path.home()))
+print(len(inventory.artifacts), "captured,", len(inventory.effective), "in effect")
+for hooks in inventory.hook_configs:
+    ...  # HookConfig, unified from settings.json and component frontmatter
+```
+
+### MCP servers
+
+Read the last harvested tool inventory (fast, no network — served from a 12h cache):
+
+```python
+from capdisc.mcp_harvest import read_mcp_cache, cache_is_stale
+
+servers = read_mcp_cache()  # [] if there's no cache yet
+if cache_is_stale():
+    ...  # trigger a refresh (below) before trusting this
+```
+
+Force a fresh harvest — connects to every configured server concurrently (bounded) and lists
+their real tool schemas:
+
+```python
+from capdisc.mcp_harvest import refresh_mcp_cache
+
+servers = refresh_mcp_cache(oauth=False)  # also (re)writes the cache
+for server in servers:
+    print(server.ref, [t.name for t in server.tools])
+```
+
+Bearer/OAuth auth for HTTP servers is opt-in via settings, bound to an exact hostname so a
+same-named server elsewhere can never receive a credential meant for another:
+
+```bash
+export CAPDISC_MCP_BEARER_ENV='{"github": {"env": "GH_TOKEN", "host": "api.githubcopilot.com"}}'
+```
+
+`report.EnvironmentReport` captures the full discovery harvest (scan roots, on-disk inventory, skills,
+builtin tools, plugins with per-component token cost, MCP servers). `mcp_harvest` and `mcp_catalog`
+enumerate connected MCP servers; `plugin_catalog` reads installed plugins; `scope` resolves which
+roots to scan.
+
+The package ships `py.typed`.
+
+## Tests
+
+```bash
+uv run pytest
+uv run mypy src
+uv run ruff check .
+```

claude_code_capabilities-0.1.2/README.md

@@ -0,0 +1,110 @@
+# capdisc
+
+[![PyPI](https://img.shields.io/pypi/v/claude-code-capabilities.svg)](https://pypi.org/project/claude-code-capabilities/)
+[![Python versions](https://img.shields.io/pypi/pyversions/claude-code-capabilities.svg)](https://pypi.org/project/claude-code-capabilities/)
+[![CI](https://github.com/Magic-Man-us/capability-discovery/actions/workflows/ci.yml/badge.svg)](https://github.com/Magic-Man-us/capability-discovery/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/Magic-Man-us/capability-discovery/blob/main/LICENSE)
+
+Discovers Claude Code capabilities — skills, agents, plugins, MCP servers, hooks — into typed
+Pydantic catalogs and an environment report.
+
+## Install
+
+```bash
+uv add claude-code-capabilities
+# or
+pip install claude-code-capabilities
+```
+
+## CLI
+
+```bash
+capdisc            # scan this machine, write discovery-report.json + .html
+capdisc --oauth     # also allow the interactive OAuth flow for HTTP MCP servers
+                    # with a pre-registered client (forces a fresh MCP harvest)
+```
+
+Both files are written to `~/.claude/capdisc/` by default. Configure paths and MCP auth via env
+vars (`CAPDISC_` prefix), a `.env` file, or `~/.claude/capdisc/config.json`/`config.yaml` — see
+`DiscoverySettings` in `settings.py` for every field.
+
+## Library
+
+Scan the machine into a typed catalog:
+
+```python
+from pathlib import Path
+from capdisc.discovery import scan_environment
+from capdisc.scope import ScopeRoots
+
+roots = ScopeRoots.discover(start=Path.cwd(), home_dir=Path.home())
+catalog = scan_environment(roots)
+for entry in catalog.entries:
+    ...  # CatalogSkill | CatalogTool | CatalogMcpServer | CatalogPlugin
+```
+
+Build and persist the full environment report (what the CLI does):
+
+```python
+from capdisc.report import build_report, write_report
+
+report = build_report(oauth=False)
+write_report(report)  # -> ~/.claude/capdisc/discovery-report.{json,html}
+```
+
+Inspect the on-disk scope inventory directly — every skill/agent/command/hook found, its
+precedence, and which ones actually win a collision:
+
+```python
+from capdisc.scope import ScopeInventory, ScopeRoots
+
+inventory = ScopeInventory.scan(ScopeRoots.discover(start=Path.cwd(), home_dir=Path.home()))
+print(len(inventory.artifacts), "captured,", len(inventory.effective), "in effect")
+for hooks in inventory.hook_configs:
+    ...  # HookConfig, unified from settings.json and component frontmatter
+```
+
+### MCP servers
+
+Read the last harvested tool inventory (fast, no network — served from a 12h cache):
+
+```python
+from capdisc.mcp_harvest import read_mcp_cache, cache_is_stale
+
+servers = read_mcp_cache()  # [] if there's no cache yet
+if cache_is_stale():
+    ...  # trigger a refresh (below) before trusting this
+```
+
+Force a fresh harvest — connects to every configured server concurrently (bounded) and lists
+their real tool schemas:
+
+```python
+from capdisc.mcp_harvest import refresh_mcp_cache
+
+servers = refresh_mcp_cache(oauth=False)  # also (re)writes the cache
+for server in servers:
+    print(server.ref, [t.name for t in server.tools])
+```
+
+Bearer/OAuth auth for HTTP servers is opt-in via settings, bound to an exact hostname so a
+same-named server elsewhere can never receive a credential meant for another:
+
+```bash
+export CAPDISC_MCP_BEARER_ENV='{"github": {"env": "GH_TOKEN", "host": "api.githubcopilot.com"}}'
+```
+
+`report.EnvironmentReport` captures the full discovery harvest (scan roots, on-disk inventory, skills,
+builtin tools, plugins with per-component token cost, MCP servers). `mcp_harvest` and `mcp_catalog`
+enumerate connected MCP servers; `plugin_catalog` reads installed plugins; `scope` resolves which
+roots to scan.
+
+The package ships `py.typed`.
+
+## Tests
+
+```bash
+uv run pytest
+uv run mypy src
+uv run ruff check .
+```

claude_code_capabilities-0.1.2/commands/capabilities-report.md

@@ -0,0 +1,48 @@
+---
+description: Inventory this machine's Claude Code capabilities — skills, agents, plugins, MCP servers, hooks, and built-in tools across user/project/plugin scopes — as a typed JSON catalog and an HTML environment report.
+allowed-tools: Bash, Read
+---
+
+Build the environment report and summarize it. The scan covers every scope root
+(user, project, plugin), installed plugins with per-component token cost,
+connected MCP servers and their tool schemas, indexed skills, and built-in
+tools. Distinct from `/context-cartographer:map-context`, which budgets one
+repo's context surface — this maps what the whole machine/session has.
+
+Run exactly this:
+
+```bash
+if [ -z "$CLAUDE_PLUGIN_ROOT" ]; then
+  echo "CLAUDE_PLUGIN_ROOT is unset — this command must run from an installed plugin." >&2
+  exit 1
+fi
+PLUGIN="$CLAUDE_PLUGIN_ROOT"
+# Bearer auth for the GitHub MCP server, when gh is logged in — the host binding below is
+# enforced: the token is attached only if the server's own url resolves to that exact host,
+# so a same-named server elsewhere can never receive it. Neither printed nor stored.
+if TOKEN=$(gh auth token 2>/dev/null) && [ -n "$TOKEN" ]; then
+  export GH_TOKEN="$TOKEN"
+  export CAPDISC_MCP_BEARER_ENV='{"github": {"env": "GH_TOKEN", "host": "api.githubcopilot.com"}}'
+fi
+uv run --project "$PLUGIN" capdisc
+```
+
+It prints the two output paths (JSON snapshot + HTML report, under
+`~/.claude/capdisc/` by default). Then:
+
+- Read the JSON snapshot and report the counts per catalog kind (skills, tools,
+  MCP servers, plugins), the scan roots used, and anything anomalous (servers
+  that failed to connect, empty scopes).
+- Point the user at the HTML report path for the full browsable view.
+
+Notes:
+- MCP tool inventories are served from a 12-hour cache; a fresh probe happens in
+  the background when the cache is stale.
+- HTTP MCP servers needing auth: `mcp_bearer_env` in settings maps a server name
+  to `{env, host}` — an env var holding a bearer token, and the exact host the
+  server's url must resolve to before the token is attached (non-interactive).
+  `--oauth` additionally runs the browser OAuth flow for servers with a
+  pre-registered, host-bound client in `mcp_oauth_clients`; never pass it here
+  — this command must stay non-interactive.
+- The JSON round-trips through `EnvironmentReport.model_validate_json` for any
+  downstream typed consumer.

claude_code_capabilities-0.1.2/pyproject.toml

@@ -0,0 +1,98 @@
+[project]
+name = "claude-code-capabilities"
+version = "0.1.2"
+description = "Discovers Claude Code capabilities — skills, agents, plugins, MCP servers, hooks — into typed catalogs and an environment report."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.12"
+authors = [{ name = "Magic-Man-us" }]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Typing :: Typed",
+]
+dependencies = [
+    "fastmcp>=3.4.4",
+    "py-key-value-aio[filetree]>=0.4.5",
+    "pydantic>=2.13.4",
+    "pydantic-settings>=2.14.2",
+    "pyyaml>=6.0.3",
+]
+
+[project.urls]
+Homepage = "https://github.com/Magic-Man-us/capability-discovery"
+Repository = "https://github.com/Magic-Man-us/capability-discovery"
+
+[project.scripts]
+capdisc = "capdisc.report:main"
+
+[dependency-groups]
+dev = [
+    "mypy>=2.3.0",
+    "pytest>=9.1.1",
+    "pytest-cov>=7.1.0",
+    "ruff>=0.15.22",
+    "types-pyyaml>=6.0.12.20260518",
+]
+
+[build-system]
+requires = ["hatchling>=1.31.0"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/capdisc"]
+
+[tool.ruff]
+target-version = "py312"
+line-length = 100
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = [
+    "E", "W", "F", "I", "N", "UP", "B", "A", "C4", "DTZ", "SIM", "PTH",
+    "RET", "TRY", "S", "ARG", "PL", "RUF",
+]
+ignore = ["TRY003", "PLR0913", "RUF012"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**" = ["S101", "S102", "PLR2004", "ARG", "PLC0415"]
+"__init__.py" = ["F401"]
+# These models bind external camelCase JSON config keys (mcpServers, pluginConfigs) by field name.
+"src/capdisc/mcp_harvest/config.py" = ["N815"]
+"src/capdisc/plugin_catalog.py" = ["N815"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["capdisc"]
+
+[tool.ruff.format]
+docstring-code-format = true
+
+[tool.mypy]
+python_version = "3.12"
+mypy_path = "src"
+plugins = ["pydantic.mypy"]
+strict = true
+warn_unreachable = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+
+[tool.pydantic-mypy]
+init_forbid_extra = true
+init_typed = true
+warn_required_dynamic_aliases = true
+warn_untyped_fields = true
+
+[tool.pytest.ini_options]
+pythonpath = ["src", "tests"]
+testpaths = ["tests"]
+addopts = "--strict-markers --strict-config -ra"
+
+[tool.coverage.run]
+source = ["src"]
+branch = true

claude_code_capabilities-0.1.2/src/capdisc/__init__.py

@@ -0,0 +1,69 @@
+"""Discovery of Claude Code capabilities: skills, agents, plugins, MCP servers, hooks.
+
+Scans the environment's scope roots into a typed inventory, harvests plugin and MCP
+metadata, and assembles capability catalogs and the environment report.
+"""
+
+from __future__ import annotations
+
+from .catalog import (
+    Catalog,
+    CatalogEntry,
+    CatalogMcpServer,
+    CatalogPlugin,
+    CatalogSkill,
+    CatalogTool,
+    McpTool,
+)
+from .discovery import BUILTIN_TOOLS, scan_environment, scan_indexed_skills, scan_skills
+from .mcp_catalog import enumerate_mcp_servers
+from .mcp_harvest import (
+    cache_is_stale,
+    read_mcp_cache,
+    refresh_in_background,
+    refresh_mcp_cache,
+    write_mcp_cache,
+)
+from .plugin_catalog import (
+    enumerate_plugins,
+    enumerate_plugins_with_paths,
+    installed_plugin_dirs,
+    installed_plugins,
+)
+from .report import EnvironmentReport, build_report, write_report, write_report_on_start
+from .scope import ScopeInventory, ScopeRoots, default_managed_dir
+from .settings import DiscoverySettings, ExtraSourceDir, get_settings
+
+__all__ = [
+    "BUILTIN_TOOLS",
+    "Catalog",
+    "CatalogEntry",
+    "CatalogMcpServer",
+    "CatalogPlugin",
+    "CatalogSkill",
+    "CatalogTool",
+    "DiscoverySettings",
+    "EnvironmentReport",
+    "ExtraSourceDir",
+    "McpTool",
+    "ScopeInventory",
+    "ScopeRoots",
+    "build_report",
+    "cache_is_stale",
+    "default_managed_dir",
+    "enumerate_mcp_servers",
+    "enumerate_plugins",
+    "enumerate_plugins_with_paths",
+    "get_settings",
+    "installed_plugin_dirs",
+    "installed_plugins",
+    "read_mcp_cache",
+    "refresh_in_background",
+    "refresh_mcp_cache",
+    "scan_environment",
+    "scan_indexed_skills",
+    "scan_skills",
+    "write_mcp_cache",
+    "write_report",
+    "write_report_on_start",
+]

claude_code_capabilities-0.1.2/src/capdisc/base.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import re
+
+from pydantic import BaseModel, ConfigDict
+from pydantic.alias_generators import to_camel
+from pydantic.fields import ComputedFieldInfo, FieldInfo
+
+_CAMEL_BOUNDARY = re.compile(r"(?<=[a-z0-9])(?=[A-Z])")
+
+
+def humanize_field_title(field_name: str, _info: FieldInfo | ComputedFieldInfo) -> str:
+    """A clean, alias-independent JSON-Schema title from a field's Python name.
+
+    Splits snake_case, kebab-case, and camelCase into words and renders them sentence-cased
+    (`status_message` -> `Status message`). Avoids the mangled titles Pydantic derives from a
+    camelCase/hyphenated alias when a schema is exported `by_alias` (`statusMessage` -> the broken
+    `Statusmessage`). Set as `field_title_generator`, so it drives the field-level `title` only;
+    a domain-primitive alias's own `title` on the inner type is untouched.
+    """
+    spaced = _CAMEL_BOUNDARY.sub(" ", field_name.replace("_", " ").replace("-", " "))
+    return " ".join(spaced.split()).capitalize()
+
+
+class FrozenModel(BaseModel):
+    """Immutable, strict domain model — the single config preset for this package."""
+
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+
+class FrozenWireModel(BaseModel):
+    """Immutable model whose snake_case fields bind to the camelCase JSON keys of a Claude Code
+    config file — accepts either spelling on load, emits camelCase on dump. Tolerant of unknown
+    keys (`extra="ignore"`): this is the ingest boundary for config written by a Claude Code that
+    may be newer than us, so a field we don't model yet is dropped, never a parse failure."""
+
+    model_config = ConfigDict(
+        extra="ignore",
+        frozen=True,
+        alias_generator=to_camel,
+        populate_by_name=True,
+        serialize_by_alias=True,
+        field_title_generator=humanize_field_title,
+    )
+
+
+class MutableModel(BaseModel):
+    """Strict but mutable domain model — for in-place accumulators that fill across a loop."""
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class InputModel(BaseModel):
+    """Lenient boundary model — ignores unknown keys from external sources."""
+
+    model_config = ConfigDict(extra="ignore")