agentforge-core 0.2.1__py3-none-any.whl

agentforge_core/config/module_schemas.py

@@ -0,0 +1,208 @@
+"""Module-side config schema validation (feat-012 §4.4).
+
+Per spec §4.4, each module ships its own Pydantic config schema; the
+framework composes them at load time so `modules.memory.config:`,
+`modules.evaluators[*].config:`, etc. get validated against the
+right shape.
+
+Module convention: a class registered with the resolver MAY declare
+a class-level attribute:
+
+    class PostgresMemoryStore(MemoryStore):
+        config_schema: ClassVar[type[BaseModel] | None] = PostgresMemoryConfig
+
+The validator walks the resolved config's `modules.*` blocks, looks
+each entry's class up in the resolver, reads `cls.config_schema`,
+and runs `schema.model_validate(entry.config)` if present. Modules
+without a schema (the common case) accept any dict — the resolver
+still confirms the class is registered (fail-at-startup, P11).
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from pydantic import ValidationError
+
+from agentforge_core.config.schema import (
+    AgentForgeConfig,
+    EvaluatorEntry,
+    ModuleEntry,
+    ObservabilityEntry,
+    PipelineTaskEntry,
+    RerankerEntry,
+)
+from agentforge_core.production.exceptions import ModuleError
+
+if TYPE_CHECKING:
+    from agentforge_core.resolver import Resolver
+
+
+def validate_module_configs(
+    cfg: AgentForgeConfig,
+    *,
+    resolver: Resolver | None = None,
+    strict: bool = True,
+) -> None:
+    """Validate each `modules.*` block against its module's schema.
+
+    Args:
+        cfg: A loaded `AgentForgeConfig` (post-`load_config`).
+        resolver: Resolver to look classes up in. Defaults to the
+            global resolver.
+        strict: When True (default), missing modules raise
+            `ModuleError`. When False, missing modules are skipped
+            (useful for `agentforge config validate` against a config
+            that references not-yet-installed packages).
+
+    Raises:
+        ModuleError: a referenced module isn't registered (strict
+            mode) or a config dict fails its module's schema.
+    """
+    # Late import — avoids a load-order cycle with the values /
+    # contracts modules that the resolver pulls in.
+    from agentforge_core.resolver import Resolver as _Resolver  # noqa: PLC0415
+
+    r = resolver if resolver is not None else _Resolver.global_()
+
+    if cfg.modules.memory is not None:
+        _validate_one(r, "memory", cfg.modules.memory, strict=strict)
+    if cfg.modules.graph is not None:
+        _validate_one(r, "graph", cfg.modules.graph, strict=strict)
+    if cfg.modules.retriever is not None:
+        _validate_one(r, "retriever", cfg.modules.retriever, strict=strict)
+
+    for eval_entry in cfg.modules.evaluators:
+        _validate_named(r, "evaluators", eval_entry, strict=strict)
+    for obs_entry in cfg.modules.observability:
+        _validate_named(r, "hooks", obs_entry, strict=strict)
+    for proto_entry in cfg.modules.protocols:
+        _validate_named(r, "protocols", proto_entry, strict=strict)
+    if cfg.modules.pipeline is not None:
+        for task_entry in cfg.modules.pipeline.tasks:
+            _validate_named(r, "tasks", task_entry, strict=strict)
+    if cfg.modules.chat is not None:
+        if cfg.modules.chat.history is not None:
+            _validate_driver(
+                r,
+                "chat.history",
+                cfg.modules.chat.history.driver,
+                cfg.modules.chat.history.config,
+                strict=strict,
+            )
+        if cfg.modules.chat.truncation is not None:
+            _validate_driver(
+                r,
+                "chat.truncation",
+                cfg.modules.chat.truncation.strategy,
+                cfg.modules.chat.truncation.config,
+                strict=strict,
+            )
+
+    if cfg.retrieval is not None:
+        _validate_retrieval(r, cfg, strict=strict)
+
+
+def _validate_one(
+    resolver: Resolver,
+    category: str,
+    entry: ModuleEntry,
+    *,
+    strict: bool,
+) -> None:
+    """Validate a `driver + config`-shaped module entry."""
+    try:
+        cls = resolver.resolve(category, entry.driver)
+    except ModuleError:
+        if strict:
+            raise
+        return
+    schema = _read_config_schema(cls)
+    if schema is None:
+        return
+    try:
+        schema.model_validate(entry.config)
+    except ValidationError as exc:
+        raise ModuleError(
+            f"modules.{category}.config failed validation for driver "
+            f"{entry.driver!r}: {exc.errors(include_url=False)}"
+        ) from exc
+
+
+def _validate_named(
+    resolver: Resolver,
+    category: str,
+    entry: EvaluatorEntry | ObservabilityEntry | PipelineTaskEntry | RerankerEntry,
+    *,
+    strict: bool,
+) -> None:
+    """Validate a named-list entry (evaluators / observability /
+    protocols)."""
+    try:
+        cls = resolver.resolve(category, entry.name)
+    except ModuleError:
+        if strict:
+            raise
+        return
+    schema = _read_config_schema(cls)
+    if schema is None:
+        return
+    try:
+        schema.model_validate(entry.config)
+    except ValidationError as exc:
+        raise ModuleError(
+            f"modules.{category}[{entry.name!r}].config failed validation: "
+            f"{exc.errors(include_url=False)}"
+        ) from exc
+
+
+def _validate_retrieval(
+    resolver: Resolver,
+    cfg: AgentForgeConfig,
+    *,
+    strict: bool,
+) -> None:
+    """Validate the top-level `retrieval:` block (feat-021 follow-up)."""
+    assert cfg.retrieval is not None
+    _validate_one(resolver, "vector_stores", cfg.retrieval.vector_store, strict=strict)
+    _validate_one(resolver, "embeddings", cfg.retrieval.embedder, strict=strict)
+    if cfg.retrieval.reranker is not None:
+        _validate_named(resolver, "rerankers", cfg.retrieval.reranker, strict=strict)
+
+
+def _validate_driver(
+    resolver: Resolver,
+    category: str,
+    name: str,
+    config: dict[str, Any],
+    *,
+    strict: bool,
+) -> None:
+    """Validate a driver-by-name + config dict (feat-020 chat hook)."""
+    try:
+        cls = resolver.resolve(category, name)
+    except ModuleError:
+        if strict:
+            raise
+        return
+    schema = _read_config_schema(cls)
+    if schema is None:
+        return
+    try:
+        schema.model_validate(config)
+    except ValidationError as exc:
+        raise ModuleError(
+            f"modules.{category}.config failed validation for {name!r}: "
+            f"{exc.errors(include_url=False)}"
+        ) from exc
+
+
+def _read_config_schema(cls: type) -> Any:
+    """Pull `cls.config_schema` if declared. Tolerant — modules without
+    one return `None` (any dict accepted)."""
+    schema = getattr(cls, "config_schema", None)
+    if schema is None:
+        return None
+    if not isinstance(schema, type):
+        return None
+    return schema

agentforge_core/config/schema.py

@@ -0,0 +1,424 @@
+"""Locked root models for `agentforge.yaml` (feat-012).
+
+feat-001 shipped a minimal schema (`agent` + `logging`). feat-012
+widens it to the full §4.2 surface: nested `budget`, `modules`
+section with sub-shapes (memory, graph, retriever, evaluators,
+observability, tools, protocols), `providers` named registry, and
+`output` config. Adding fields is additive (ADR-0007 minor bump).
+
+The runtime `Agent(budget_usd=, max_iterations=)` kwargs from
+feat-001 remain the locked Public API; they continue to drive
+`BudgetPolicy` internally. The YAML field shape (`budget.usd` etc.)
+is the data-side representation.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+
+class BudgetConfig(BaseModel):
+    """`agent.budget:` — nested budget shape per spec §4.1.
+
+    All caps optional; runtime defaults preserved when omitted. The
+    flat `agent.budget_usd: float` form from feat-001 is no longer
+    valid in YAML — `agentforge config validate` will report it as
+    an unknown field (set `agent.budget.usd:` instead).
+    """
+
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    usd: float = Field(default=1.0, ge=0.0)
+    max_tokens: int | None = Field(default=None, ge=1)
+    error_streak_limit: int | None = Field(default=None, ge=1)
+
+
+class AgentConfig(BaseModel):
+    """`agent:` section — model, strategy, prompt, budget, etc."""
+
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    name: str | None = None
+    model: str | dict[str, Any] | None = None
+    strategy: str | dict[str, Any] | None = None
+    system_prompt: str | None = None
+    system_prompt_file: Path | None = None
+    tools: list[str | dict[str, Any]] = Field(default_factory=list)
+    budget: BudgetConfig = Field(default_factory=BudgetConfig)
+    max_iterations: int = Field(default=25, ge=1)
+    llm_options: dict[str, Any] = Field(default_factory=dict)
+
+    @field_validator("system_prompt_file", mode="before")
+    @classmethod
+    def _coerce_path(cls, value: Any) -> Any:
+        # Strict mode rejects strings for Path; YAML loads as `str`,
+        # so coerce here. None / Path stay as-is.
+        if isinstance(value, str):
+            return Path(value)
+        return value
+
+
+class LoggingConfig(BaseModel):
+    """`logging:` — level, run-id filter toggle, format."""
+
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    level: str = "INFO"
+    run_id_filter: bool = True
+    format: str = "text"  # "text" | "json"
+
+
+class ModuleEntry(BaseModel):
+    """Generic `driver + config` shape used by the `modules.memory`,
+    `modules.graph`, `modules.retriever` sections."""
+
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    driver: str = Field(min_length=1)
+    config: dict[str, Any] = Field(default_factory=dict)
+
+
+class MemoryModuleConfig(ModuleEntry):
+    """Alias of `ModuleEntry` for `modules.memory:` — distinct type so
+    schema docs can attach memory-specific guidance."""
+
+
+class GraphModuleConfig(ModuleEntry):
+    """Alias of `ModuleEntry` for `modules.graph:`."""
+
+
+class RetrieverModuleConfig(ModuleEntry):
+    """Alias of `ModuleEntry` for `modules.retriever:` (legacy).
+
+    .. deprecated:: 0.2
+        Use the top-level `retrieval:` block (see
+        :class:`RetrievalConfig`) instead. The legacy single-entry
+        form remains valid for v0.2 backward compatibility and may
+        be removed in v1.0.
+    """
+
+
+class RerankerEntry(BaseModel):
+    """`retrieval.reranker:` — name + config for a `Reranker` impl.
+
+    Resolved against the `rerankers` entry-point category. Name
+    matches the registered entry-point name (e.g.
+    `sentence-transformers`).
+    """
+
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    name: str = Field(min_length=1)
+    config: dict[str, Any] = Field(default_factory=dict)
+
+
+class GraphExpansionConfig(BaseModel):
+    """`retrieval.graph_expansion:` — wiring for GraphRAG hybrid
+    retrieval (feat-023).
+
+    The `store` field resolves against the `graph_stores`
+    entry-point category. When set on a `RetrievalConfig`, the
+    builder constructs a `GraphExpansion` value and forwards it
+    into the `Retriever` constructor so vector / hybrid hits get
+    augmented with N-hop graph neighbours.
+    """
+
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    store: ModuleEntry
+    max_hops: int = Field(default=2, ge=1)
+    edge_types: list[str] | None = None
+    """Edge-type filter. YAML lists deserialize to `list[str]`;
+    converted to a tuple by `build_retriever_from_config` before
+    constructing the `GraphExpansion` value."""
+    text_property: str = "text"
+    decay: float = Field(default=0.5, gt=0.0, le=1.0)
+
+
+class RetrievalConfig(BaseModel):
+    """Top-level `retrieval:` block (feat-021 follow-up).
+
+    Models the full retrieval pipeline: a `VectorStore` + an
+    `EmbeddingClient` + an optional `Reranker`, plus retrieval-
+    time knobs (`top_k`, `over_fetch_factor`, `batch_size`).
+    Lives at the root of `agentforge.yaml`, not nested under
+    `modules:`.
+
+    The legacy `modules.retriever` single-entry form still works
+    for v0.2 backward compat; the new `retrieval:` block
+    supersedes it. Both should not be set simultaneously — the
+    builder picks `retrieval:` when present.
+    """
+
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    vector_store: ModuleEntry
+    embedder: ModuleEntry
+    reranker: RerankerEntry | None = None
+    top_k: int = Field(default=5, ge=1)
+    over_fetch_factor: int = Field(default=3, ge=1)
+    batch_size: int = Field(default=32, ge=1)
+    mode: Literal["vector", "hybrid"] = "vector"
+    """Retrieval mode (feat-022): ``"vector"`` for cosine-only or
+    ``"hybrid"`` for BM25 + cosine fused via RRF. Hybrid requires the
+    underlying ``VectorStore`` to declare the ``"hybrid_search"``
+    capability."""
+    rrf_k: int = Field(default=60, ge=1)
+    """RRF constant (Cormack 2009 default 60). Ignored when ``mode``
+    is ``"vector"``."""
+    graph_expansion: GraphExpansionConfig | None = None
+    """Optional graph-augmented retrieval (feat-023). When set the
+    builder resolves the graph store, constructs a
+    :class:`GraphExpansion`, and forwards it to ``Retriever`` so
+    vector / hybrid hits get expanded with N-hop graph neighbours.
+    Composes orthogonally with ``mode`` and ``reranker``."""
+
+
+class EvaluatorEntry(BaseModel):
+    """An entry in `modules.evaluators:`. Two YAML shapes are valid:
+
+    - String form: `- faithfulness` (just the name).
+    - Mapping form: `- faithfulness: {cost_cap_usd: 0.05, ...}`.
+
+    We model the mapping form here; the loader normalises strings to
+    `EvaluatorEntry(name=..., config={})` before validation.
+    """
+
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    name: str = Field(min_length=1)
+    config: dict[str, Any] = Field(default_factory=dict)
+
+
+class ObservabilityEntry(BaseModel):
+    """An entry in `modules.observability:` — same shape as evaluator
+    entries (name + config)."""
+
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    name: str = Field(min_length=1)
+    config: dict[str, Any] = Field(default_factory=dict)
+
+
+class GuardrailPolicy(BaseModel):
+    """Framework-wide guardrail policy (feat-018).
+
+    Read from `agentforge.yaml` under the top-level
+    `guardrail_policy:` key. Defaults are conservative (per P6 —
+    loud defaults). Lives here rather than in `values/guardrails.py`
+    so the config-schema module doesn't have to reach into
+    `values` (avoids an import cycle through `values.state`).
+    The runtime `ValidationResult` remains in `values.guardrails`.
+    """
+
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    on_input_violation: Literal["block", "redact", "warn", "allow"] = "block"
+    on_output_violation: Literal["block", "redact", "warn", "allow"] = "redact"
+    on_tool_violation: Literal["block", "warn"] = "block"
+    audit_channel: str = "agentforge.audit"
+    fail_open: bool = False
+
+
+class GuardrailEntry(BaseModel):
+    """One entry inside `modules.guardrails.{input,output,tool_gates}`.
+
+    Two YAML shapes are valid (mirrors `EvaluatorEntry`):
+
+    - String form: `- prompt_injection_basic` (just the name).
+    - Mapping form: `- presidio: {entities: ["EMAIL_ADDRESS"]}`.
+
+    Both normalise to `GuardrailEntry(name=..., config={})` before
+    validation.
+    """
+
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    name: str = Field(min_length=1)
+    config: dict[str, Any] = Field(default_factory=dict)
+
+
+class ChatHistoryDriverConfig(BaseModel):
+    """`modules.chat.history:` — driver + config for a chat history
+    store (feat-020)."""
+
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    driver: str = Field(min_length=1)
+    config: dict[str, Any] = Field(default_factory=dict)
+
+
+class ChatTruncationConfig(BaseModel):
+    """`modules.chat.truncation:` — strategy + config (feat-020)."""
+
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    strategy: str = Field(min_length=1)
+    config: dict[str, Any] = Field(default_factory=dict)
+
+
+class ChatSessionConfig(BaseModel):
+    """`modules.chat.session:` — per-session policy knobs (feat-020)."""
+
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    per_turn_budget_usd: float | None = Field(default=None, ge=0.0)
+    per_session_budget_usd: float | None = Field(default=None, ge=0.0)
+    idempotency_window_s: float = Field(default=60.0, ge=0.0)
+    concurrency: Literal["queue", "reject", "replace"] = "queue"
+    safety_mode: Literal["buffer-then-stream", "sentence-window", "stream-then-redact"] = (
+        "buffer-then-stream"
+    )
+    """Output-guardrail policy on streamed assistant turns:
+
+    - ``"buffer-then-stream"`` (default) — agent runs to completion;
+      output validators see the full text once; the assembled response
+      is then sentence-segmented for the wire. Existing v0.2 behaviour.
+    - ``"sentence-window"`` (feat-020 v0.3) — for real per-token
+      streaming, buffer tokens until a sentence boundary, run
+      ``check_output`` over each completed sentence, emit the
+      validated sentence as the next ``text`` chunk. Trades a small
+      latency hit (visible chunks at sentence boundaries) for
+      streaming-aware safety.
+    - ``"stream-then-redact"`` (deferred) — currently an alias for
+      ``sentence-window``. A future v0.3+ pass may add inline regex
+      redaction without buffering.
+    """
+
+
+class ChatConfig(BaseModel):
+    """`modules.chat:` — chat layer config (feat-020).
+
+    `history` may be ``None`` (defaults to in-memory). `truncation`
+    similarly defaults to `SlidingWindow(50)` when absent.
+    """
+
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    history: ChatHistoryDriverConfig | None = None
+    truncation: ChatTruncationConfig | None = None
+    session: ChatSessionConfig = Field(default_factory=ChatSessionConfig)
+
+
+class PipelineTaskEntry(BaseModel):
+    """One entry inside `modules.pipeline.tasks` (feat-015).
+
+    Mirrors `EvaluatorEntry` / `GuardrailEntry`: a name (resolver
+    lookup under the `"tasks"` category) plus optional kwargs the
+    task class receives at construction.
+    """
+
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    name: str = Field(min_length=1)
+    config: dict[str, Any] = Field(default_factory=dict)
+
+
+class PipelineConfig(BaseModel):
+    """`modules.pipeline:` — deterministic-task DAG (feat-015).
+
+    When ``enabled`` is True and ``tasks`` is non-empty, the runtime
+    resolves each entry against the global resolver's ``tasks``
+    category, builds a `Pipeline`, and wires it into the `Agent`.
+    """
+
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    enabled: bool = True
+    max_concurrent: int = Field(default=4, ge=1)
+    on_task_error: Literal["continue", "fail"] = "continue"
+    tasks: list[PipelineTaskEntry] = Field(default_factory=list)
+
+
+class GuardrailsConfig(BaseModel):
+    """`modules.guardrails:` — input / output / tool-call validators.
+
+    `defaults: true` keeps the framework's built-in basic validators
+    (prompt_injection_basic, pii_redact_basic, capability_check)
+    installed alongside whatever's listed here. Disabling them is
+    explicit and emits a startup warning per P6 (loud defaults).
+    """
+
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    defaults: bool = True
+    input: list[GuardrailEntry] = Field(default_factory=list)
+    output: list[GuardrailEntry] = Field(default_factory=list)
+    tool_gates: list[GuardrailEntry] = Field(default_factory=list)
+
+
+class ModulesConfig(BaseModel):
+    """`modules:` — every plug-and-play module the agent uses.
+
+    Each section accepts either a single driver-with-config or a list
+    of entries:
+
+        modules:
+          memory: {driver: postgres, config: {...}}
+          evaluators: [faithfulness, {geval: {rubric: "..."}}]
+          observability: [{name: otel, config: {endpoint: "..."}}]
+          guardrails:
+            input: [prompt_injection_basic]
+            output: [pii_redact_basic]
+            tool_gates: [capability_check]
+    """
+
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    memory: MemoryModuleConfig | None = None
+    graph: GraphModuleConfig | None = None
+    retriever: RetrieverModuleConfig | None = None
+    evaluators: list[EvaluatorEntry] = Field(default_factory=list)
+    observability: list[ObservabilityEntry] = Field(default_factory=list)
+    tools: list[str | dict[str, Any]] = Field(default_factory=list)
+    protocols: list[ObservabilityEntry] = Field(default_factory=list)
+    guardrails: GuardrailsConfig = Field(default_factory=GuardrailsConfig)
+    pipeline: PipelineConfig | None = None
+    chat: ChatConfig | None = None
+
+
+class ProviderConfig(BaseModel):
+    """One entry in the `providers:` named registry.
+
+    `type` is the entry-point name (e.g. `"anthropic"`, `"bedrock"`).
+    `model` + extra kwargs are passed through to the provider's
+    constructor. `options` carries per-call LLM options.
+    """
+
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    type: str = Field(min_length=1)
+    model: str | None = None
+    options: dict[str, Any] = Field(default_factory=dict)
+    config: dict[str, Any] = Field(default_factory=dict)
+
+
+class OutputConfig(BaseModel):
+    """`output:` — finding-variant defaults, renderer choice, thresholds."""
+
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    default_finding_variant: str = "simple"
+    default_renderer: str = "scorecard"
+    thresholds: dict[str, list[str]] = Field(default_factory=dict)
+
+
+class AgentForgeConfig(BaseModel):
+    """Root model — `agentforge.yaml` shape.
+
+    Adding a field to this model (or any submodel) is a minor bump
+    under ADR-0007; removing or renaming requires a major bump.
+    """
+
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+    agent: AgentConfig = Field(default_factory=AgentConfig)
+    modules: ModulesConfig = Field(default_factory=ModulesConfig)
+    retrieval: RetrievalConfig | None = None
+    providers: dict[str, ProviderConfig] = Field(default_factory=dict)
+    logging: LoggingConfig = Field(default_factory=LoggingConfig)
+    output: OutputConfig = Field(default_factory=OutputConfig)
+    guardrail_policy: GuardrailPolicy = Field(default_factory=GuardrailPolicy)

agentforge_core/contracts/__init__.py

@@ -0,0 +1,52 @@
+"""Locked contracts — ABCs and the `Finding` Protocol.
+
+Per ADR-0007, these are the framework's stable surface. Adding a method
+to an ABC is a major version bump. Modules implement these; the runtime
+consumes them by reference to the abstraction, never the implementation.
+"""
+
+from __future__ import annotations
+
+from agentforge_core.contracts.auth import AuthPolicy
+from agentforge_core.contracts.chat import ChatHistoryStore, HistoryTruncationStrategy
+from agentforge_core.contracts.embedding import EmbeddingClient
+from agentforge_core.contracts.evaluator import EvalResult, Evaluator
+from agentforge_core.contracts.finding import Finding
+from agentforge_core.contracts.graph_store import GraphStore
+from agentforge_core.contracts.llm import LLMClient
+from agentforge_core.contracts.memory import MemoryStore
+from agentforge_core.contracts.migrator import (
+    Migration,
+    MigrationChecksumError,
+    MigrationStatus,
+    Migrator,
+)
+from agentforge_core.contracts.renderer import FindingRenderer
+from agentforge_core.contracts.reranker import Reranker
+from agentforge_core.contracts.strategy import ReasoningStrategy
+from agentforge_core.contracts.task import Task
+from agentforge_core.contracts.tool import Tool
+from agentforge_core.contracts.vector_store import VectorStore
+
+__all__ = [
+    "AuthPolicy",
+    "ChatHistoryStore",
+    "EmbeddingClient",
+    "EvalResult",
+    "Evaluator",
+    "Finding",
+    "FindingRenderer",
+    "GraphStore",
+    "HistoryTruncationStrategy",
+    "LLMClient",
+    "MemoryStore",
+    "Migration",
+    "MigrationChecksumError",
+    "MigrationStatus",
+    "Migrator",
+    "ReasoningStrategy",
+    "Reranker",
+    "Task",
+    "Tool",
+    "VectorStore",
+]