sql-safe-mcp 1.2.0__py3-none-any.whl

sql_safe_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""Minimal, PII-safe MCP server for relational databases."""
+
+__version__ = "1.2.0"

sql_safe_mcp/__main__.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+from sql_safe_mcp.config import load_config
+from sql_safe_mcp.errors import DomainError
+from sql_safe_mcp.mcp_server import create_server
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Run the sql-safe-mcp stdio server.")
+    parser.add_argument(
+        "--config",
+        type=Path,
+        default=os.environ.get("SQL_SAFE_MCP_CONFIG", "sql-safe-mcp.yaml"),
+        help="YAML configuration path (default: SQL_SAFE_MCP_CONFIG or sql-safe-mcp.yaml)",
+    )
+    parser.add_argument(
+        "--check-config",
+        action="store_true",
+        help="Validate configuration and secrets without connecting to databases.",
+    )
+    return parser
+
+
+def main() -> None:
+    args = _parser().parse_args()
+    try:
+        config = load_config(args.config)
+    except DomainError as exc:
+        print(str(exc), file=sys.stderr)
+        raise SystemExit(2) from None
+    if args.check_config:
+        print(f"Configuration valid: {len(config.servers)} server alias(es).")
+        return
+    create_server(config).run("stdio")
+
+
+if __name__ == "__main__":
+    main()

sql_safe_mcp/config.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+import base64
+import binascii
+import os
+import re
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Literal
+from urllib.parse import quote
+
+import yaml
+from pydantic import BaseModel, ConfigDict, Field, SecretStr, ValidationError, model_validator
+from sqlalchemy.engine import make_url
+
+from sql_safe_mcp.errors import DomainError, ErrorCode
+
+_ENV_PATTERN = re.compile(r"\$\{([A-Z_][A-Z0-9_]*)\}")
+_FULL_ENV_PATTERN = re.compile(r"^\$\{([A-Z_][A-Z0-9_]*)\}$")
+
+
+class RuntimeConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    max_concurrent_db_operations: int = Field(default=8, ge=1, le=128)
+    engine_cache_size: int = Field(default=32, ge=1, le=1024)
+    pool_size: int = Field(default=2, ge=1, le=32)
+    max_overflow: int = Field(default=2, ge=0, le=64)
+    pool_timeout_seconds: int = Field(default=10, ge=1, le=300)
+    statement_timeout_seconds: int = Field(default=30, ge=1, le=3600)
+    max_definition_chars: int = Field(default=262_144, ge=1024, le=10_000_000)
+    default_max_rows: int = Field(default=200, ge=1, le=100_000)
+    hard_max_rows: int = Field(default=1000, ge=1, le=100_000)
+    max_sql_chars: int = Field(default=65_536, ge=256, le=1_000_000)
+    max_ast_nodes: int = Field(default=2000, ge=10, le=100_000)
+    max_joins: int = Field(default=8, ge=0, le=100)
+    max_in_list_items: int = Field(default=500, ge=1, le=100_000)
+
+    @model_validator(mode="after")
+    def validate_row_limits(self) -> RuntimeConfig:
+        if self.default_max_rows > self.hard_max_rows:
+            raise ValueError("default_max_rows cannot exceed hard_max_rows")
+        return self
+
+
+class PiiRule(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    database: str = Field(min_length=1)
+    schema_: str | None = Field(default=None, alias="schema")
+    table: str = Field(min_length=1)
+    columns: list[str] = Field(min_length=1)
+
+    @model_validator(mode="after")
+    def validate_wildcards(self) -> PiiRule:
+        if "*" in self.table or (self.schema_ and "*" in self.schema_):
+            raise ValueError("wildcards are allowed only in pii rule database")
+        if self.database != "*" and "*" in self.database:
+            raise ValueError("database must be an exact name or '*'")
+        folded = [column.casefold() for column in self.columns]
+        if len(folded) != len(set(folded)):
+            raise ValueError("pii rule columns must be unique")
+        return self
+
+
+class PiiConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    rules: list[PiiRule] = Field(min_length=1)
+
+
+_DRIVERNAMES = {
+    "sqlserver": "mssql+pyodbc",
+    "mysql": "mysql+pymysql",
+    "mariadb": "mysql+pymysql",
+}
+
+
+class ServerConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    engine: Literal["sqlserver", "mysql", "mariadb"]
+    access_level: Literal["metadata", "pii_safe"] = "metadata"
+    connection_url: SecretStr
+    pii_key_env: str | None = Field(default=None, pattern=r"^[A-Z_][A-Z0-9_]*$")
+    pii: PiiConfig | None = None
+    pii_key: SecretStr | None = Field(default=None, exclude=True)
+
+    @model_validator(mode="after")
+    def validate_security_shape(self) -> ServerConfig:
+        if self.access_level == "pii_safe":
+            if not self.pii_key_env or self.pii is None:
+                raise ValueError("pii_safe servers require pii_key_env and pii rules")
+            if self.engine != "sqlserver" and any(rule.schema_ for rule in self.pii.rules):
+                raise ValueError(f"pii rules for engine {self.engine!r} cannot set schema")
+        elif self.pii_key_env is not None or self.pii is not None:
+            raise ValueError("metadata servers cannot configure pii_key_env or pii rules")
+
+        driver = make_url(self.connection_url.get_secret_value()).drivername
+        expected = _DRIVERNAMES[self.engine]
+        if driver != expected:
+            raise ValueError(f"engine {self.engine!r} requires SQLAlchemy dialect {expected!r}")
+        return self
+
+    def key_bytes(self) -> bytes | None:
+        if self.pii_key is None:
+            return None
+        return base64.b64decode(self.pii_key.get_secret_value(), validate=True)
+
+
+class AppConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    version: Literal[1]
+    runtime: RuntimeConfig = Field(default_factory=RuntimeConfig)
+    servers: dict[str, ServerConfig] = Field(min_length=1)
+
+    @model_validator(mode="after")
+    def validate_aliases_and_keys(self) -> AppConfig:
+        seen_keys: dict[bytes, str] = {}
+        for alias, server in self.servers.items():
+            if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9._-]*", alias):
+                raise ValueError(f"invalid server alias {alias!r}")
+            key = server.key_bytes()
+            if key is None:
+                continue
+            if len(key) != 32:
+                raise ValueError(f"PII key for server {alias!r} must decode to 32 bytes")
+            if previous := seen_keys.get(key):
+                raise ValueError(
+                    f"PII keys must be unique per server alias; {alias!r} duplicates {previous!r}"
+                )
+            seen_keys[key] = alias
+        return self
+
+
+def _expand_connection_url(template: str, environ: Mapping[str, str]) -> str:
+    full_match = _FULL_ENV_PATTERN.fullmatch(template)
+    if full_match:
+        name = full_match.group(1)
+        if name not in environ:
+            raise ValueError(f"missing environment variable {name}")
+        return environ[name]
+
+    def replace(match: re.Match[str]) -> str:
+        name = match.group(1)
+        if name not in environ:
+            raise ValueError(f"missing environment variable {name}")
+        return quote(environ[name], safe="")
+
+    expanded = _ENV_PATTERN.sub(replace, template)
+    if "${" in expanded:
+        raise ValueError("invalid environment placeholder in connection_url")
+    return expanded
+
+
+def _validation_summary(error: ValidationError) -> str:
+    issues: list[str] = []
+    for issue in error.errors(include_url=False, include_context=False, include_input=False):
+        location = ".".join(str(part) for part in issue["loc"])
+        issues.append(f"{location}: {issue['msg']}" if location else str(issue["msg"]))
+    return "; ".join(issues)
+
+
+def load_config(path: str | Path, environ: Mapping[str, str] | None = None) -> AppConfig:
+    env = os.environ if environ is None else environ
+    try:
+        raw = yaml.safe_load(Path(path).read_text(encoding="utf-8"))
+        if not isinstance(raw, dict):
+            raise ValueError("configuration root must be a mapping")
+        servers = raw.get("servers")
+        if not isinstance(servers, dict):
+            raise ValueError("servers must be a mapping")
+        for alias, value in servers.items():
+            if not isinstance(value, dict):
+                raise ValueError(f"server {alias!r} must be a mapping")
+            url = value.get("connection_url")
+            if not isinstance(url, str):
+                raise ValueError(f"server {alias!r} requires connection_url")
+            value["connection_url"] = _expand_connection_url(url, env)
+            key_env = value.get("pii_key_env")
+            if key_env is not None:
+                if not isinstance(key_env, str) or key_env not in env:
+                    raise ValueError(f"missing PII key environment variable {key_env!r}")
+                try:
+                    decoded = base64.b64decode(env[key_env], validate=True)
+                except (binascii.Error, ValueError) as exc:
+                    raise ValueError(f"PII key for server {alias!r} is not valid base64") from exc
+                if len(decoded) != 32:
+                    raise ValueError(f"PII key for server {alias!r} must decode to 32 bytes")
+                value["pii_key"] = env[key_env]
+        return AppConfig.model_validate(raw)
+    except ValidationError as exc:
+        raise DomainError(
+            ErrorCode.CONFIG_ERROR,
+            f"Invalid configuration: {_validation_summary(exc)}",
+        ) from exc
+    except (OSError, yaml.YAMLError) as exc:
+        raise DomainError(ErrorCode.CONFIG_ERROR, "Invalid configuration file.") from exc
+    except ValueError as exc:
+        raise DomainError(ErrorCode.CONFIG_ERROR, f"Invalid configuration: {exc}") from exc

sql_safe_mcp/db/__init__.py

@@ -0,0 +1 @@
+"""Database integration layer."""

sql_safe_mcp/db/extras.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from typing import Protocol
+
+from sqlalchemy import Connection
+
+from sql_safe_mcp.models import StoredProcedureDefinition, StoredProcedureSummary
+
+
+class DatabaseExtras(Protocol):
+    def list_databases(self, connection: Connection) -> list[str]: ...
+
+    def list_stored_procedures(
+        self, connection: Connection, database: str
+    ) -> list[StoredProcedureSummary]: ...
+
+    def get_stored_procedure(
+        self,
+        connection: Connection,
+        database: str,
+        schema: str | None,
+        name: str,
+    ) -> StoredProcedureDefinition | None: ...
+
+
+def extras_for(engine: str) -> DatabaseExtras:
+    if engine == "sqlserver":
+        from sql_safe_mcp.db.sqlserver import SqlServerExtras
+
+        return SqlServerExtras()
+    if engine in ("mysql", "mariadb"):
+        from sql_safe_mcp.db.mysql import MySqlExtras
+
+        return MySqlExtras()
+    raise ValueError(f"unsupported engine {engine!r}")

sql_safe_mcp/db/mysql.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from sqlalchemy import Connection, text
+
+from sql_safe_mcp.db.extras import DatabaseExtras
+from sql_safe_mcp.models import StoredProcedureDefinition, StoredProcedureSummary
+
+SYSTEM_DATABASES = ("information_schema", "mysql", "performance_schema", "sys")
+
+
+class MySqlExtras(DatabaseExtras):
+    """MySQL and MariaDB: a database is the catalog, there is no separate schema."""
+
+    def list_databases(self, connection: Connection) -> list[str]:
+        rows = connection.execute(
+            text(
+                "SELECT SCHEMA_NAME AS name FROM information_schema.SCHEMATA "
+                "WHERE SCHEMA_NAME NOT IN (:s0, :s1, :s2, :s3) ORDER BY SCHEMA_NAME"
+            ),
+            {f"s{index}": name for index, name in enumerate(SYSTEM_DATABASES)},
+        )
+        return [str(row.name) for row in rows]
+
+    def list_stored_procedures(
+        self, connection: Connection, database: str
+    ) -> list[StoredProcedureSummary]:
+        rows = connection.execute(
+            text(
+                "SELECT ROUTINE_NAME AS procedure_name FROM information_schema.ROUTINES "
+                "WHERE ROUTINE_SCHEMA = :database AND ROUTINE_TYPE = 'PROCEDURE' "
+                "ORDER BY ROUTINE_NAME"
+            ),
+            {"database": database},
+        )
+        return [StoredProcedureSummary(schema_=None, name=str(row.procedure_name)) for row in rows]
+
+    def get_stored_procedure(
+        self,
+        connection: Connection,
+        database: str,
+        schema: str | None,
+        name: str,
+    ) -> StoredProcedureDefinition | None:
+        if schema is not None:
+            return None
+        row = connection.execute(
+            text(
+                "SELECT ROUTINE_NAME AS procedure_name, ROUTINE_DEFINITION AS definition "
+                "FROM information_schema.ROUTINES "
+                "WHERE ROUTINE_SCHEMA = :database AND ROUTINE_NAME = :name "
+                "AND ROUTINE_TYPE = 'PROCEDURE'"
+            ),
+            {"database": database, "name": name},
+        ).first()
+        if row is None:
+            return None
+        definition = None if row.definition is None else str(row.definition)
+        return StoredProcedureDefinition(
+            schema_=None,
+            name=str(row.procedure_name),
+            definition=definition,
+            definition_available=definition is not None,
+        )

sql_safe_mcp/db/reflection.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from typing import Any
+
+from sqlalchemy import Connection, inspect
+
+from sql_safe_mcp.models import (
+    ColumnDefinition,
+    ForeignKeyDefinition,
+    IndexDefinition,
+    PrimaryKeyDefinition,
+    TableDefinition,
+    TableSummary,
+    UniqueConstraintDefinition,
+)
+
+_SQLSERVER_SYSTEM_SCHEMAS = {
+    "db_accessadmin",
+    "db_backupoperator",
+    "db_datareader",
+    "db_datawriter",
+    "db_ddladmin",
+    "db_denydatareader",
+    "db_denydatawriter",
+    "db_owner",
+    "db_securityadmin",
+    "guest",
+    "information_schema",
+    "sys",
+}
+
+
+def list_tables(connection: Connection) -> list[TableSummary]:
+    inspector = inspect(connection)
+    if getattr(connection.dialect, "name", None) == "mysql":
+        # MySQL and MariaDB have no schema level: the connection is bound to one database.
+        return [
+            TableSummary(schema_=None, name=name) for name in inspector.get_table_names(schema=None)
+        ]
+    tables: list[TableSummary] = []
+    for schema in inspector.get_schema_names():
+        if schema.casefold() in _SQLSERVER_SYSTEM_SCHEMAS:
+            continue
+        tables.extend(
+            TableSummary(schema_=schema, name=name)
+            for name in inspector.get_table_names(schema=schema)
+        )
+    return tables
+
+
+def _dict_or_none(value: Any) -> dict[str, Any] | None:
+    return dict(value) if isinstance(value, dict) else None
+
+
+def _normalize_columns(
+    connection: Connection, columns: Iterable[Mapping[str, Any]]
+) -> list[ColumnDefinition]:
+    result: list[ColumnDefinition] = []
+    for column in columns:
+        type_ = column["type"]
+        native_type = str(type_.compile(dialect=connection.dialect))
+        result.append(
+            ColumnDefinition(
+                name=str(column["name"]),
+                native_type=native_type,
+                nullable=bool(column.get("nullable", True)),
+                length=getattr(type_, "length", None),
+                precision=getattr(type_, "precision", None),
+                scale=getattr(type_, "scale", None),
+                autoincrement=column.get("autoincrement"),
+                identity=_dict_or_none(column.get("identity")),
+                computed=_dict_or_none(column.get("computed")),
+                default=None if column.get("default") is None else str(column["default"]),
+            )
+        )
+    return result
+
+
+def get_table_definition(
+    connection: Connection,
+    schema: str | None,
+    table: str,
+) -> TableDefinition:
+    inspector = inspect(connection)
+    primary_key = inspector.get_pk_constraint(table, schema=schema)
+    foreign_keys = inspector.get_foreign_keys(table, schema=schema)
+    indexes = inspector.get_indexes(table, schema=schema)
+    try:
+        unique_constraints = inspector.get_unique_constraints(table, schema=schema)
+    except NotImplementedError:
+        unique_constraints = [
+            {"name": item.get("name"), "column_names": item.get("column_names")}
+            for item in indexes
+            if item.get("unique")
+        ]
+    return TableDefinition(
+        schema_=schema,
+        name=table,
+        columns=_normalize_columns(connection, inspector.get_columns(table, schema=schema)),
+        primary_key=PrimaryKeyDefinition(
+            name=primary_key.get("name"),
+            columns=[str(name) for name in primary_key.get("constrained_columns") or []],
+        ),
+        foreign_keys=[
+            ForeignKeyDefinition(
+                name=item.get("name"),
+                columns=[str(name) for name in item.get("constrained_columns") or []],
+                referred_schema=item.get("referred_schema"),
+                referred_table=str(item["referred_table"]),
+                referred_columns=[str(name) for name in item.get("referred_columns") or []],
+                options=dict(item.get("options") or {}),
+            )
+            for item in foreign_keys
+        ],
+        unique_constraints=[
+            UniqueConstraintDefinition(
+                name=None if item.get("name") is None else str(item["name"]),
+                columns=[str(name) for name in item.get("column_names") or []],
+            )
+            for item in unique_constraints
+        ],
+        indexes=[
+            IndexDefinition(
+                name=item.get("name"),
+                columns=list(item.get("column_names") or []),
+                unique=bool(item.get("unique", False)),
+                expressions=[str(value) for value in item.get("expressions") or []],
+            )
+            for item in indexes
+        ],
+    )

sql_safe_mcp/db/registry.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from collections import OrderedDict
+from collections.abc import Callable
+from threading import RLock
+from typing import Any, TypeVar
+
+import anyio
+from sqlalchemy import Engine, create_engine, event
+
+from sql_safe_mcp.config import AppConfig
+from sql_safe_mcp.errors import DomainError, ErrorCode
+
+T = TypeVar("T")
+
+
+class EngineRegistry:
+    """Thread-safe lazy LRU of SQLAlchemy engines."""
+
+    def __init__(self, config: AppConfig) -> None:
+        self._config = config
+        self._engines: OrderedDict[tuple[str, str | None], Engine] = OrderedDict()
+        self._lock = RLock()
+        self._limiter = anyio.CapacityLimiter(config.runtime.max_concurrent_db_operations)
+
+    def _create_engine(self, alias: str, database: str | None) -> Engine:
+        server = self._config.servers[alias]
+        url = server.connection_url.get_secret_value()
+        if database is not None:
+            from sqlalchemy.engine import make_url
+
+            url = make_url(url).set(database=database)
+        timeout = self._config.runtime.statement_timeout_seconds
+        options: dict[str, Any] = {}
+        if server.engine in ("mysql", "mariadb"):
+            options["connect_args"] = {
+                "connect_timeout": self._config.runtime.pool_timeout_seconds,
+                "read_timeout": timeout,
+                "write_timeout": timeout,
+            }
+        engine = create_engine(
+            url,
+            pool_size=self._config.runtime.pool_size,
+            max_overflow=self._config.runtime.max_overflow,
+            pool_timeout=self._config.runtime.pool_timeout_seconds,
+            pool_pre_ping=True,
+            pool_use_lifo=True,
+            **options,
+        )
+
+        @event.listens_for(engine, "connect")
+        def set_connection_timeout(dbapi_connection: Any, _record: Any) -> None:
+            if hasattr(dbapi_connection, "timeout"):
+                dbapi_connection.timeout = timeout
+
+        if server.engine in ("mysql", "mariadb"):
+
+            @event.listens_for(engine, "connect")
+            def keep_backslash_escapes(dbapi_connection: Any, _record: Any) -> None:
+                # NO_BACKSLASH_ESCAPES would make the generated SQL's string escaping unsafe.
+                cursor = dbapi_connection.cursor()
+                try:
+                    cursor.execute("SELECT @@SESSION.sql_mode")
+                    modes = [
+                        mode
+                        for mode in str(cursor.fetchone()[0]).split(",")
+                        if mode and mode != "NO_BACKSLASH_ESCAPES"
+                    ]
+                    cursor.execute("SET SESSION sql_mode = %s", (",".join(modes),))
+                finally:
+                    cursor.close()
+
+        @event.listens_for(engine, "before_cursor_execute")
+        def set_statement_timeout(
+            _connection: Any,
+            cursor: Any,
+            _statement: str,
+            _parameters: Any,
+            _context: Any,
+            _executemany: bool,
+        ) -> None:
+            if hasattr(cursor, "timeout"):
+                cursor.timeout = timeout
+
+        return engine
+
+    def get(self, alias: str, database: str | None = None) -> Engine:
+        if alias not in self._config.servers:
+            raise DomainError(ErrorCode.UNKNOWN_SERVER, f"Unknown configured server {alias!r}.")
+        key = (alias, database)
+        evicted: Engine | None = None
+        with self._lock:
+            if engine := self._engines.get(key):
+                self._engines.move_to_end(key)
+                return engine
+            engine = self._create_engine(alias, database)
+            self._engines[key] = engine
+            if len(self._engines) > self._config.runtime.engine_cache_size:
+                _, evicted = self._engines.popitem(last=False)
+        if evicted is not None:
+            evicted.dispose()
+        return engine
+
+    async def run(
+        self,
+        alias: str,
+        database: str | None,
+        operation: Callable[[Engine], T],
+    ) -> T:
+        engine = self.get(alias, database)
+        return await anyio.to_thread.run_sync(operation, engine, limiter=self._limiter)
+
+    def dispose(self) -> None:
+        with self._lock:
+            engines = list(self._engines.values())
+            self._engines.clear()
+        for engine in engines:
+            engine.dispose()
+
+    @property
+    def cached_engine_count(self) -> int:
+        with self._lock:
+            return len(self._engines)

sql_safe_mcp/db/sqlserver.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from sqlalchemy import Connection, text
+
+from sql_safe_mcp.db.extras import DatabaseExtras
+from sql_safe_mcp.models import StoredProcedureDefinition, StoredProcedureSummary
+
+
+class SqlServerExtras(DatabaseExtras):
+    def list_databases(self, connection: Connection) -> list[str]:
+        rows = connection.execute(
+            text(
+                "SELECT name FROM sys.databases "
+                "WHERE state = 0 AND HAS_DBACCESS(name) = 1 ORDER BY name"
+            )
+        )
+        return [str(row.name) for row in rows]
+
+    def list_stored_procedures(
+        self, connection: Connection, database: str
+    ) -> list[StoredProcedureSummary]:
+        del database
+        rows = connection.execute(
+            text(
+                "SELECT s.name AS schema_name, p.name AS procedure_name "
+                "FROM sys.procedures AS p "
+                "JOIN sys.schemas AS s ON s.schema_id = p.schema_id "
+                "WHERE p.is_ms_shipped = 0 "
+                "ORDER BY s.name, p.name"
+            )
+        )
+        return [
+            StoredProcedureSummary(schema_=str(row.schema_name), name=str(row.procedure_name))
+            for row in rows
+        ]
+
+    def get_stored_procedure(
+        self,
+        connection: Connection,
+        database: str,
+        schema: str | None,
+        name: str,
+    ) -> StoredProcedureDefinition | None:
+        del database
+        if schema is None:
+            return None
+        row = connection.execute(
+            text(
+                "SELECT s.name AS schema_name, p.name AS procedure_name, "
+                "OBJECT_DEFINITION(p.object_id) AS definition "
+                "FROM sys.procedures AS p "
+                "JOIN sys.schemas AS s ON s.schema_id = p.schema_id "
+                "WHERE s.name = :schema AND p.name = :name AND p.is_ms_shipped = 0"
+            ),
+            {"schema": schema, "name": name},
+        ).first()
+        if row is None:
+            return None
+        definition = None if row.definition is None else str(row.definition)
+        return StoredProcedureDefinition(
+            schema_=str(row.schema_name),
+            name=str(row.procedure_name),
+            definition=definition,
+            definition_available=definition is not None,
+        )