chore: import upstream snapshot with attribution

schema_registry/__init__.py

@@ -0,0 +1,59 @@
+"""Public helpers for entity schema registries."""
+
+from .registry import (
+    SchemaLookupError,
+    SchemaRegistrationError,
+    NodeSchemaSpec,
+    EdgeConditionSchemaSpec,
+    EdgeProcessorSchemaSpec,
+    MemoryStoreSchemaSpec,
+    ThinkingSchemaSpec,
+    ModelProviderSchemaSpec,
+    register_node_schema,
+    register_edge_condition_schema,
+    register_edge_processor_schema,
+    register_memory_store_schema,
+    register_thinking_schema,
+    register_model_provider_schema,
+    iter_node_schemas,
+    iter_edge_condition_schemas,
+    iter_edge_processor_schemas,
+    iter_memory_store_schemas,
+    iter_thinking_schemas,
+    iter_model_provider_schemas,
+    get_node_schema,
+    get_edge_condition_schema,
+    get_edge_processor_schema,
+    get_memory_store_schema,
+    get_thinking_schema,
+    get_model_provider_schema,
+)
+
+__all__ = [
+    "SchemaLookupError",
+    "SchemaRegistrationError",
+    "NodeSchemaSpec",
+    "EdgeConditionSchemaSpec",
+    "EdgeProcessorSchemaSpec",
+    "MemoryStoreSchemaSpec",
+    "ThinkingSchemaSpec",
+    "ModelProviderSchemaSpec",
+    "register_node_schema",
+    "register_edge_condition_schema",
+    "register_edge_processor_schema",
+    "register_memory_store_schema",
+    "register_thinking_schema",
+    "register_model_provider_schema",
+    "iter_node_schemas",
+    "iter_edge_condition_schemas",
+    "iter_edge_processor_schemas",
+    "iter_memory_store_schemas",
+    "iter_thinking_schemas",
+    "iter_model_provider_schemas",
+    "get_node_schema",
+    "get_edge_condition_schema",
+    "get_edge_processor_schema",
+    "get_memory_store_schema",
+    "get_thinking_schema",
+    "get_model_provider_schema",
+]

schema_registry/registry.py

@@ -0,0 +1,290 @@
+"""Schema registries for entity-layer configuration classes."""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, Mapping, MutableMapping, Type
+from entity.configs.base import BaseConfig
+
+
+class SchemaLookupError(RuntimeError):
+    """Raised when a requested schema spec is not registered."""
+
+
+class SchemaRegistrationError(RuntimeError):
+    """Raised when schema registration is inconsistent."""
+
+
+@dataclass
+class NodeSchemaSpec:
+    name: str
+    config_cls: Type["BaseConfig"]
+    summary: str | None = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class EdgeConditionSchemaSpec:
+    name: str
+    config_cls: Type["BaseConfig"]
+    summary: str | None = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class EdgeProcessorSchemaSpec:
+    name: str
+    config_cls: Type["BaseConfig"]
+    summary: str | None = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class MemoryStoreSchemaSpec:
+    name: str
+    config_cls: Type["BaseConfig"]
+    summary: str | None = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class ThinkingSchemaSpec:
+    name: str
+    config_cls: Type["BaseConfig"]
+    summary: str | None = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class ModelProviderSchemaSpec:
+    name: str
+    label: str | None = None
+    summary: str | None = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+_node_schemas: Dict[str, NodeSchemaSpec] = {}
+_edge_condition_schemas: Dict[str, EdgeConditionSchemaSpec] = {}
+_edge_processor_schemas: Dict[str, EdgeProcessorSchemaSpec] = {}
+_edge_processor_builtins_loaded = False
+_memory_store_schemas: Dict[str, MemoryStoreSchemaSpec] = {}
+_thinking_schemas: Dict[str, ThinkingSchemaSpec] = {}
+_model_provider_schemas: Dict[str, ModelProviderSchemaSpec] = {}
+
+
+def _update_metadata(target: MutableMapping[str, Any], new_items: Mapping[str, Any] | None) -> None:
+    if not new_items:
+        return
+    target.update({key: value for key, value in new_items.items() if value is not None})
+
+
+def register_node_schema(
+    name: str,
+    *,
+    config_cls: Type["BaseConfig"],
+    summary: str | None = None,
+    metadata: Mapping[str, Any] | None = None,
+) -> NodeSchemaSpec:
+    spec = _node_schemas.get(name)
+    if spec:
+        if spec.config_cls is not config_cls:
+            raise SchemaRegistrationError(
+                f"Node schema '{name}' already registered with a different config class"
+            )
+        if summary:
+            spec.summary = summary
+        _update_metadata(spec.metadata, metadata)
+        return spec
+    spec = NodeSchemaSpec(name=name, config_cls=config_cls, summary=summary)
+    _update_metadata(spec.metadata, metadata)
+    _node_schemas[name] = spec
+    return spec
+
+
+def iter_node_schemas() -> Dict[str, NodeSchemaSpec]:
+    return dict(_node_schemas)
+
+
+def get_node_schema(name: str) -> NodeSchemaSpec:
+    try:
+        return _node_schemas[name]
+    except KeyError as exc:  # pragma: no cover - defensive guard
+        raise SchemaLookupError(f"Node schema '{name}' is not registered") from exc
+
+
+def register_edge_condition_schema(
+    name: str,
+    *,
+    config_cls: Type["BaseConfig"],
+    summary: str | None = None,
+    metadata: Mapping[str, Any] | None = None,
+) -> EdgeConditionSchemaSpec:
+    spec = _edge_condition_schemas.get(name)
+    if spec:
+        if spec.config_cls is not config_cls:
+            raise SchemaRegistrationError(
+                f"Edge condition schema '{name}' already registered with a different config class"
+            )
+        if summary:
+            spec.summary = summary
+        _update_metadata(spec.metadata, metadata)
+        return spec
+    spec = EdgeConditionSchemaSpec(name=name, config_cls=config_cls, summary=summary)
+    _update_metadata(spec.metadata, metadata)
+    _edge_condition_schemas[name] = spec
+    return spec
+
+
+def iter_edge_condition_schemas() -> Dict[str, EdgeConditionSchemaSpec]:
+    return dict(_edge_condition_schemas)
+
+
+def get_edge_condition_schema(name: str) -> EdgeConditionSchemaSpec:
+    try:
+        return _edge_condition_schemas[name]
+    except KeyError as exc:  # pragma: no cover
+        raise SchemaLookupError(f"Edge condition schema '{name}' is not registered") from exc
+
+
+def register_edge_processor_schema(
+    name: str,
+    *,
+    config_cls: Type["BaseConfig"],
+    summary: str | None = None,
+    metadata: Mapping[str, Any] | None = None,
+) -> EdgeProcessorSchemaSpec:
+    spec = _edge_processor_schemas.get(name)
+    if spec:
+        if spec.config_cls is not config_cls:
+            raise SchemaRegistrationError(
+                f"Edge processor schema '{name}' already registered with a different config class"
+            )
+        if summary:
+            spec.summary = summary
+        _update_metadata(spec.metadata, metadata)
+        return spec
+    spec = EdgeProcessorSchemaSpec(name=name, config_cls=config_cls, summary=summary)
+    _update_metadata(spec.metadata, metadata)
+    _edge_processor_schemas[name] = spec
+    return spec
+
+
+def iter_edge_processor_schemas() -> Dict[str, EdgeProcessorSchemaSpec]:
+    _ensure_edge_processor_builtins_loaded()
+    return dict(_edge_processor_schemas)
+
+
+def get_edge_processor_schema(name: str) -> EdgeProcessorSchemaSpec:
+    _ensure_edge_processor_builtins_loaded()
+    try:
+        return _edge_processor_schemas[name]
+    except KeyError as exc:  # pragma: no cover
+        raise SchemaLookupError(f"Edge processor schema '{name}' is not registered") from exc
+
+
+def register_memory_store_schema(
+    name: str,
+    *,
+    config_cls: Type["BaseConfig"],
+    summary: str | None = None,
+    metadata: Mapping[str, Any] | None = None,
+) -> MemoryStoreSchemaSpec:
+    spec = _memory_store_schemas.get(name)
+    if spec:
+        if spec.config_cls is not config_cls:
+            raise SchemaRegistrationError(
+                f"Memory store schema '{name}' already registered with a different config class"
+            )
+        if summary:
+            spec.summary = summary
+        _update_metadata(spec.metadata, metadata)
+        return spec
+    spec = MemoryStoreSchemaSpec(name=name, config_cls=config_cls, summary=summary)
+    _update_metadata(spec.metadata, metadata)
+    _memory_store_schemas[name] = spec
+    return spec
+
+
+def iter_memory_store_schemas() -> Dict[str, MemoryStoreSchemaSpec]:
+    return dict(_memory_store_schemas)
+
+
+def get_memory_store_schema(name: str) -> MemoryStoreSchemaSpec:
+    try:
+        return _memory_store_schemas[name]
+    except KeyError as exc:  # pragma: no cover
+        raise SchemaLookupError(f"Memory store schema '{name}' is not registered") from exc
+
+
+def register_thinking_schema(
+    name: str,
+    *,
+    config_cls: Type["BaseConfig"],
+    summary: str | None = None,
+    metadata: Mapping[str, Any] | None = None,
+) -> ThinkingSchemaSpec:
+    spec = _thinking_schemas.get(name)
+    if spec:
+        if spec.config_cls is not config_cls:
+            raise SchemaRegistrationError(
+                f"Thinking schema '{name}' already registered with a different config class"
+            )
+        if summary:
+            spec.summary = summary
+        _update_metadata(spec.metadata, metadata)
+        return spec
+    spec = ThinkingSchemaSpec(name=name, config_cls=config_cls, summary=summary)
+    _update_metadata(spec.metadata, metadata)
+    _thinking_schemas[name] = spec
+    return spec
+
+
+def iter_thinking_schemas() -> Dict[str, ThinkingSchemaSpec]:
+    return dict(_thinking_schemas)
+
+
+def get_thinking_schema(name: str) -> ThinkingSchemaSpec:
+    try:
+        return _thinking_schemas[name]
+    except KeyError as exc:  # pragma: no cover
+        raise SchemaLookupError(f"Thinking schema '{name}' is not registered") from exc
+
+
+def register_model_provider_schema(
+    name: str,
+    *,
+    label: str | None = None,
+    summary: str | None = None,
+    metadata: Mapping[str, Any] | None = None,
+) -> ModelProviderSchemaSpec:
+    spec = _model_provider_schemas.get(name)
+    if spec:
+        if label:
+            spec.label = label
+        if summary:
+            spec.summary = summary
+        _update_metadata(spec.metadata, metadata)
+        return spec
+    spec = ModelProviderSchemaSpec(name=name, label=label, summary=summary)
+    _update_metadata(spec.metadata, metadata)
+    _model_provider_schemas[name] = spec
+    return spec
+
+
+def iter_model_provider_schemas() -> Dict[str, ModelProviderSchemaSpec]:
+    return dict(_model_provider_schemas)
+
+
+def get_model_provider_schema(name: str) -> ModelProviderSchemaSpec:
+    try:
+        return _model_provider_schemas[name]
+    except KeyError as exc:  # pragma: no cover
+        raise SchemaLookupError(f"Model provider schema '{name}' is not registered") from exc
+
+def _ensure_edge_processor_builtins_loaded() -> None:
+    global _edge_processor_builtins_loaded
+    if _edge_processor_builtins_loaded:
+        return
+    try:
+        import runtime.edge.processors.builtin_types  # noqa: F401
+    except Exception:
+        pass
+    _edge_processor_builtins_loaded = True