rootmemory 0.1.0__py3-none-any.whl

rootmemory/__init__.py

@@ -0,0 +1,84 @@
+"""RootMemory - provenance-aware memory for multi-agent AI systems.
+
+It tells corroboration apart from repetition. Every belief records what it was
+derived from, so three agents echoing one document are counted as one piece of
+evidence rather than three.
+
+Quick start::
+
+    from rootmemory import RootMemory, open_memory
+
+    with open_memory("sqlite+pysqlite:///memory.db") as session:
+        memory = RootMemory(session)
+        agent = memory.register_agent("ResearchAgent")
+
+        article = memory.create_observation("news", "Revenue may have slipped.")
+        belief = memory.create_belief(
+            agent.id, "The supplier is struggling.", "supplier_risk", 0.6,
+            derived_from=[article],       # required: cite what you read
+        )
+
+        claim = memory.get_or_create_claim("supplier_risk", "Supplier is struggling.")
+        memory.support_claim(claim.id, belief.id)
+
+        verdict = memory.evaluate_claim(claim.id)
+        print(verdict.independent_support_count)   # 1, not 3
+        print(verdict.explanation)
+
+The async client and the framework adapters live in ``rootmemory.integrations``
+and are imported on demand, so nothing here pulls in FastAPI or LangGraph.
+"""
+
+from __future__ import annotations
+
+from rootmemory.client import RootMemory
+from rootmemory.db.session import create_isolated_session, open_memory, session_scope
+from rootmemory.errors import (
+    ImmutableRecordError,
+    NodeNotFoundError,
+    PromotionForbiddenError,
+    ProvenanceCycleError,
+    ProvenanceRequiredError,
+    RootMemoryError,
+)
+from rootmemory.models.enums import (
+    ClaimStatus,
+    DecisionStatus,
+    EdgeType,
+    EpistemicStatus,
+    NodeType,
+    ValidityStatus,
+    Visibility,
+)
+from rootmemory.models.node_ref import NodeRef
+from rootmemory.services.promotion_service import PromotionEvaluation, PromotionPolicy
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # the client you will actually use
+    "RootMemory",
+    "open_memory",
+    "session_scope",
+    "create_isolated_session",
+    # the promotion policy and its verdict
+    "PromotionPolicy",
+    "PromotionEvaluation",
+    # errors worth catching
+    "RootMemoryError",
+    "NodeNotFoundError",
+    "ProvenanceRequiredError",
+    "ProvenanceCycleError",
+    "ImmutableRecordError",
+    "PromotionForbiddenError",
+    # vocabulary
+    "NodeRef",
+    "NodeType",
+    "EdgeType",
+    "ValidityStatus",
+    "EpistemicStatus",
+    "Visibility",
+    "ClaimStatus",
+    "DecisionStatus",
+    "__version__",
+]

rootmemory/api/__init__.py

@@ -0,0 +1,25 @@
+"""API layer: routing and serialization only, no epistemic rules."""
+
+from rootmemory.api import (
+    agents,
+    beliefs,
+    claims,
+    graph,
+    invalidation,
+    observations,
+    promotion,
+    provenance,
+)
+
+ROUTERS = [
+    agents.router,
+    observations.router,
+    beliefs.router,
+    claims.router,
+    promotion.router,
+    provenance.router,
+    invalidation.router,
+    graph.router,
+]
+
+__all__ = ["ROUTERS"]

rootmemory/api/agents.py

@@ -0,0 +1,38 @@
+"""Agent endpoints."""
+
+from __future__ import annotations
+
+import uuid
+
+from fastapi import APIRouter, status
+
+from rootmemory.api.deps import MemoryDep
+from rootmemory.errors import NodeNotFoundError
+from rootmemory.schemas.agent import AgentCreate, AgentRead
+
+router = APIRouter(prefix="/agents", tags=["agents"])
+
+
+@router.post("", response_model=AgentRead, status_code=status.HTTP_201_CREATED)
+def create_agent(payload: AgentCreate, memory: MemoryDep) -> AgentRead:
+    """Register an agent. Names are unique, so this is idempotent."""
+    agent = memory.register_agent(
+        name=payload.name,
+        role=payload.role,
+        description=payload.description,
+        trust_score=payload.trust_score,
+    )
+    return AgentRead.model_validate(agent)
+
+
+@router.get("", response_model=list[AgentRead])
+def list_agents(memory: MemoryDep) -> list[AgentRead]:
+    return [AgentRead.model_validate(a) for a in memory.agents.list()]
+
+
+@router.get("/{agent_id}", response_model=AgentRead)
+def get_agent(agent_id: uuid.UUID, memory: MemoryDep) -> AgentRead:
+    agent = memory.agents.get(agent_id)
+    if agent is None:
+        raise NodeNotFoundError(f"agent {agent_id} does not exist")
+    return AgentRead.model_validate(agent)

rootmemory/api/beliefs.py

@@ -0,0 +1,66 @@
+"""Belief endpoints."""
+
+from __future__ import annotations
+
+import uuid
+
+from fastapi import APIRouter, status
+
+from rootmemory.api.deps import MemoryDep
+from rootmemory.models.node_ref import NodeRef
+from rootmemory.schemas.belief import BeliefCreate, BeliefRead, BeliefWithProvenance
+from rootmemory.schemas.common import NodeReference
+from rootmemory.services.belief_service import ParentSpec
+
+router = APIRouter(prefix="/beliefs", tags=["beliefs"])
+
+
+@router.post("", response_model=BeliefRead, status_code=status.HTTP_201_CREATED)
+def create_belief(payload: BeliefCreate, memory: MemoryDep) -> BeliefRead:
+    """Create a belief.
+
+    Returns 422 when no parent is given (a belief must be traceable) and 409
+    when the requested provenance would create a cycle.
+    """
+    parents = [ParentSpec(id=node.id, type=node.type) for node in payload.parent_nodes]
+    belief = memory.beliefs.create_belief(
+        agent_id=payload.agent_id,
+        claim_text=payload.claim_text,
+        normalized_claim_key=payload.normalized_claim_key,
+        confidence=payload.confidence,
+        parents=parents,
+        llm_generated=payload.llm_generated,
+        meta=payload.metadata,
+    )
+    return BeliefRead.model_validate(belief)
+
+
+@router.get("/{belief_id}", response_model=BeliefWithProvenance)
+def get_belief(belief_id: uuid.UUID, memory: MemoryDep) -> BeliefWithProvenance:
+    belief = memory.get_belief(belief_id)
+    roots = memory.provenance.find_evidence_root_observations(NodeRef.belief(belief_id))
+    return BeliefWithProvenance(
+        **BeliefRead.model_validate(belief).model_dump(),
+        evidence_roots=[o.id for o in roots],
+        independent_source_count=len({o.independence_key for o in roots}),
+    )
+
+
+@router.post("/{belief_id}/parents", status_code=status.HTTP_204_NO_CONTENT)
+def add_parent(belief_id: uuid.UUID, parent: NodeReference, memory: MemoryDep) -> None:
+    """Attach another causal parent to an existing belief.
+
+    Returns 409 if the edge would make the belief its own ancestor
+    (spec section 28).
+    """
+    memory.beliefs.add_parent(belief_id, ParentSpec(id=parent.id, type=parent.type))
+
+
+@router.post("/{belief_id}/propose", response_model=BeliefRead)
+def propose_shared_belief(belief_id: uuid.UUID, memory: MemoryDep) -> BeliefRead:
+    """Move a private belief to candidate_shared.
+
+    This is as far as an agent can push its own belief; entering shared memory
+    requires the promotion gate.
+    """
+    return BeliefRead.model_validate(memory.propose_shared_belief(belief_id))

rootmemory/api/claims.py

@@ -0,0 +1,87 @@
+"""Claim endpoints: creation, support, contradiction and honest reads."""
+
+from __future__ import annotations
+
+import uuid
+
+from fastapi import APIRouter, status
+
+from rootmemory.api.deps import MemoryDep
+from rootmemory.errors import NodeNotFoundError
+from rootmemory.models.enums import ClaimStatus
+from rootmemory.schemas.claim import (
+    ClaimContextResponse,
+    ClaimCreate,
+    ClaimLinkRequest,
+    ClaimRead,
+    EvidenceSide,
+)
+
+router = APIRouter(prefix="/claims", tags=["claims"])
+
+
+@router.post("", response_model=ClaimRead, status_code=status.HTTP_201_CREATED)
+def create_claim(payload: ClaimCreate, memory: MemoryDep) -> ClaimRead:
+    """Create (or fetch) a claim.
+
+    A new claim always starts unconfirmed. Shared/confirmed state can only be
+    reached through the promotion gate (spec section 46).
+    """
+    claim = memory.get_or_create_claim(payload.claim_key, payload.canonical_text)
+    return ClaimRead.model_validate(claim)
+
+
+@router.get("", response_model=list[ClaimRead])
+def list_claims(memory: MemoryDep) -> list[ClaimRead]:
+    return [ClaimRead.model_validate(c) for c in memory.claims.list()]
+
+
+@router.get("/{claim_id}", response_model=ClaimRead)
+def get_claim(claim_id: uuid.UUID, memory: MemoryDep) -> ClaimRead:
+    claim = memory.claims.get(claim_id)
+    if claim is None:
+        raise NodeNotFoundError(f"claim {claim_id} does not exist")
+    return ClaimRead.model_validate(claim)
+
+
+@router.post("/{claim_id}/support", status_code=status.HTTP_204_NO_CONTENT)
+def register_support(claim_id: uuid.UUID, payload: ClaimLinkRequest, memory: MemoryDep) -> None:
+    memory.support_claim(claim_id, payload.belief_id)
+
+
+@router.post("/{claim_id}/contradict", status_code=status.HTTP_204_NO_CONTENT)
+def register_contradiction(
+    claim_id: uuid.UUID, payload: ClaimLinkRequest, memory: MemoryDep
+) -> None:
+    """Record a belief that argues against the claim.
+
+    Nothing is overwritten or deleted: both sides stay in memory and both are
+    reported back (spec section 23).
+    """
+    memory.contradict_claim(claim_id, payload.belief_id)
+
+
+@router.get("/{claim_id}/context", response_model=ClaimContextResponse)
+def get_claim_context(claim_id: uuid.UUID, memory: MemoryDep) -> ClaimContextResponse:
+    """Read a claim the way an agent should: both sides, independence counted."""
+    context = memory.get_claim_context(claim_id)
+    return ClaimContextResponse(
+        claim_id=context.claim.id,
+        claim_key=context.claim.claim_key,
+        claim=context.claim.canonical_text,
+        status=ClaimStatus(context.claim.status),
+        support=EvidenceSide(
+            belief_count=context.support.belief_count,
+            agreeing_agents=context.support.agreeing_agent_count,
+            independent_sources=context.support.independent_source_count,
+            confidence=context.support.aggregate_confidence,
+            root_observation_ids=context.support.root_observation_ids,
+        ),
+        contradictions=EvidenceSide(
+            belief_count=context.contradiction.belief_count,
+            agreeing_agents=context.contradiction.agreeing_agent_count,
+            independent_sources=context.contradiction.independent_source_count,
+            confidence=context.contradiction.aggregate_confidence,
+            root_observation_ids=context.contradiction.root_observation_ids,
+        ),
+    )

rootmemory/api/deps.py

@@ -0,0 +1,21 @@
+"""FastAPI dependencies."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+from fastapi import Depends
+from sqlalchemy.orm import Session
+
+from rootmemory.client import RootMemory
+from rootmemory.db.session import get_db
+
+SessionDep = Annotated[Session, Depends(get_db)]
+
+
+def get_memory_client(session: SessionDep) -> RootMemory:
+    """One memory client per request."""
+    return RootMemory(session)
+
+
+MemoryDep = Annotated[RootMemory, Depends(get_memory_client)]

rootmemory/api/errors.py

@@ -0,0 +1,36 @@
+"""Mapping of domain errors onto HTTP status codes."""
+
+from __future__ import annotations
+
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+
+from rootmemory.errors import (
+    ImmutableRecordError,
+    NodeNotFoundError,
+    PromotionForbiddenError,
+    ProvenanceCycleError,
+    ProvenanceRequiredError,
+    RootMemoryError,
+)
+
+STATUS_BY_ERROR: list[tuple[type[RootMemoryError], int]] = [
+    (NodeNotFoundError, 404),
+    (ProvenanceCycleError, 409),
+    (ProvenanceRequiredError, 422),
+    (PromotionForbiddenError, 403),
+    (ImmutableRecordError, 409),
+    (RootMemoryError, 400),
+]
+
+
+def register_error_handlers(app: FastAPI) -> None:
+    @app.exception_handler(RootMemoryError)
+    async def handle_domain_error(_: Request, exc: RootMemoryError) -> JSONResponse:
+        status = next(
+            (code for error_type, code in STATUS_BY_ERROR if isinstance(exc, error_type)), 400
+        )
+        return JSONResponse(
+            status_code=status,
+            content={"error": type(exc).__name__, "detail": str(exc)},
+        )

rootmemory/api/graph.py

@@ -0,0 +1,32 @@
+"""Graph snapshot endpoint, used by the portal."""
+
+from __future__ import annotations
+
+import uuid
+
+from fastapi import APIRouter
+
+from rootmemory.api.deps import MemoryDep, SessionDep
+from rootmemory.errors import NodeNotFoundError
+from rootmemory.services.graph_service import GraphService
+
+router = APIRouter(tags=["graph"])
+
+
+@router.get("/graph")
+def get_graph(session: SessionDep) -> dict:
+    """The whole memory graph in one call: nodes, edges and headline counts.
+
+    Each belief carries its evidence roots and each claim carries both the
+    agreement count and the independent-source count, so the portal never has
+    to infer the difference for itself.
+    """
+    return GraphService(session).snapshot().as_dict()
+
+
+@router.get("/graph/claims/{claim_id}/sides")
+def get_claim_sides(claim_id: uuid.UUID, session: SessionDep, memory: MemoryDep) -> dict:
+    """Which beliefs support and which contradict a claim."""
+    if memory.claims.get(claim_id) is None:
+        raise NodeNotFoundError(f"claim {claim_id} does not exist")
+    return GraphService(session).claim_supporters(claim_id)

rootmemory/api/invalidation.py

@@ -0,0 +1,47 @@
+"""Invalidation endpoints: retracting a source and repairing what it touched."""
+
+from __future__ import annotations
+
+import uuid
+
+from fastapi import APIRouter
+
+from rootmemory.api.deps import MemoryDep
+from rootmemory.schemas.observation import (
+    InvalidationRequest,
+    InvalidationResponse,
+    RepairReportRead,
+)
+
+router = APIRouter(tags=["invalidation"])
+
+
+@router.post("/observations/{observation_id}/invalidate", response_model=InvalidationResponse)
+def invalidate_observation(
+    observation_id: uuid.UUID, payload: InvalidationRequest, memory: MemoryDep
+) -> InvalidationResponse:
+    """Mark a source invalid and repair everything downstream of it.
+
+    The observation itself is not edited or deleted; only its validity moves,
+    and the traversal is recorded as a repair report.
+    """
+    summary = memory.invalidate_observation(observation_id, payload.reason)
+    return InvalidationResponse(
+        repair_report_id=summary.report_id,
+        trigger_node_id=summary.trigger_node_id,
+        trigger_reason=summary.trigger_reason,
+        affected_beliefs=summary.affected_beliefs,
+        affected_claims=summary.affected_claims,
+        affected_decisions=summary.affected_decisions,
+        details=summary.details,
+    )
+
+
+@router.get("/repair-reports", response_model=list[RepairReportRead])
+def list_repair_reports(memory: MemoryDep) -> list[RepairReportRead]:
+    return [RepairReportRead.model_validate(r) for r in memory.invalidation.audits.list_repairs()]
+
+
+@router.get("/repair-reports/{report_id}", response_model=RepairReportRead)
+def get_repair_report(report_id: uuid.UUID, memory: MemoryDep) -> RepairReportRead:
+    return RepairReportRead.model_validate(memory.invalidation.get_report(report_id))

rootmemory/api/observations.py

@@ -0,0 +1,46 @@
+"""Observation endpoints.
+
+There is deliberately no DELETE and no PUT: observations are immutable
+historical records. The only thing that can change is validity, and that goes
+through the invalidation endpoint so a repair report is always produced.
+"""
+
+from __future__ import annotations
+
+import uuid
+
+from fastapi import APIRouter, status
+
+from rootmemory.api.deps import MemoryDep
+from rootmemory.errors import NodeNotFoundError
+from rootmemory.schemas.observation import ObservationCreate, ObservationRead
+
+router = APIRouter(prefix="/observations", tags=["observations"])
+
+
+@router.post("", response_model=ObservationRead, status_code=status.HTTP_201_CREATED)
+def create_observation(payload: ObservationCreate, memory: MemoryDep) -> ObservationRead:
+    observation = memory.create_observation(
+        source_type=payload.source_type,
+        content=payload.content,
+        source_uri=payload.source_uri,
+        source_actor=payload.source_actor,
+        created_by_agent_id=payload.created_by_agent_id,
+        reliability_score=payload.reliability_score,
+        source_family_id=payload.source_family_id,
+        meta=payload.metadata,
+    )
+    return ObservationRead.model_validate(observation)
+
+
+@router.get("", response_model=list[ObservationRead])
+def list_observations(memory: MemoryDep) -> list[ObservationRead]:
+    return [ObservationRead.model_validate(o) for o in memory.observations.list()]
+
+
+@router.get("/{observation_id}", response_model=ObservationRead)
+def get_observation(observation_id: uuid.UUID, memory: MemoryDep) -> ObservationRead:
+    observation = memory.observations.get(observation_id)
+    if observation is None:
+        raise NodeNotFoundError(f"observation {observation_id} does not exist")
+    return ObservationRead.model_validate(observation)

rootmemory/api/promotion.py

@@ -0,0 +1,37 @@
+"""Promotion endpoints: the only route into shared memory."""
+
+from __future__ import annotations
+
+import uuid
+
+from fastapi import APIRouter
+
+from rootmemory.api.deps import MemoryDep
+from rootmemory.schemas.promotion import PromotionAuditRead, PromotionEvaluationResponse
+
+router = APIRouter(prefix="/claims", tags=["promotion"])
+
+
+@router.post("/{claim_id}/evaluate-promotion", response_model=PromotionEvaluationResponse)
+def evaluate_promotion(claim_id: uuid.UUID, memory: MemoryDep) -> PromotionEvaluationResponse:
+    """Run the gate and report the verdict without changing the claim."""
+    evaluation = memory.evaluate_claim(claim_id)
+    return PromotionEvaluationResponse.model_validate(evaluation.as_dict())
+
+
+@router.post("/{claim_id}/promote", response_model=PromotionEvaluationResponse)
+def promote_claim(claim_id: uuid.UUID, memory: MemoryDep) -> PromotionEvaluationResponse:
+    """Attempt to promote a claim into shared memory.
+
+    The gate is re-run here from scratch: a caller's earlier evaluation is
+    never trusted (spec section 27.8).
+    """
+    evaluation = memory.promote_claim(claim_id)
+    return PromotionEvaluationResponse.model_validate(evaluation.as_dict())
+
+
+@router.get("/{claim_id}/promotion-audits", response_model=list[PromotionAuditRead])
+def list_promotion_audits(claim_id: uuid.UUID, memory: MemoryDep) -> list[PromotionAuditRead]:
+    """Every promotion decision ever made about this claim, in order."""
+    audits = memory.promotion.audits.promotions_for_claim(claim_id)
+    return [PromotionAuditRead.model_validate(a) for a in audits]

rootmemory/api/provenance.py

@@ -0,0 +1,88 @@
+"""Provenance inspection and decision endpoints."""
+
+from __future__ import annotations
+
+import uuid
+
+from fastapi import APIRouter, Query, status
+
+from rootmemory.api.deps import MemoryDep
+from rootmemory.errors import NodeNotFoundError
+from rootmemory.models.enums import NodeType
+from rootmemory.models.node_ref import NodeRef
+from rootmemory.schemas.provenance import (
+    DecisionCreate,
+    DecisionRead,
+    EvidenceRootRead,
+    ProvenanceResponse,
+)
+
+router = APIRouter(tags=["provenance"])
+
+
+@router.get("/provenance/{node_id}", response_model=ProvenanceResponse)
+def inspect_provenance(
+    node_id: uuid.UUID,
+    memory: MemoryDep,
+    node_type: NodeType = Query(
+        default=NodeType.BELIEF, description="Which table the node lives in."
+    ),
+    include_paths: bool = Query(default=True),
+) -> ProvenanceResponse:
+    """Answer 'where did this come from?' for any node in the graph."""
+    ref = NodeRef(node_id, node_type)
+    if not memory.provenance.node_exists(ref):
+        raise NodeNotFoundError(f"{node_type}:{node_id} does not exist")
+
+    roots = memory.provenance.find_evidence_roots(ref)
+    observations = memory.observations.get_many(roots.roots)
+    return ProvenanceResponse(
+        node_id=node_id,
+        node_type=node_type,
+        evidence_roots=sorted(roots.roots, key=str),
+        excluded_roots={str(k): v for k, v in roots.excluded_roots.items()},
+        independent_source_count=len({o.independence_key for o in observations}),
+        root_details=[
+            EvidenceRootRead(
+                id=o.id,
+                source_type=o.source_type,
+                source_uri=o.source_uri,
+                validity_status=o.validity_status,
+                reliability_score=o.reliability_score,
+                source_family_id=o.source_family_id,
+                independence_key=o.independence_key,
+            )
+            for o in observations
+        ],
+        paths=memory.provenance.enumerate_paths(ref) if include_paths else [],
+    )
+
+
+@router.post("/decisions", response_model=DecisionRead, status_code=status.HTTP_201_CREATED)
+def create_decision(payload: DecisionCreate, memory: MemoryDep) -> DecisionRead:
+    """Record a decision and the claims it depends on.
+
+    Those dependencies are what let cascade repair flag the decision if the
+    evidence underneath it is later retracted.
+    """
+    decision = memory.decision_service.create_decision(
+        agent_id=payload.agent_id,
+        decision_type=payload.decision_type,
+        content=payload.content,
+        claim_ids=payload.depends_on_claim_ids,
+        meta=payload.metadata,
+    )
+    return DecisionRead.model_validate(decision)
+
+
+@router.get("/decisions", response_model=list[DecisionRead])
+def list_decisions(memory: MemoryDep) -> list[DecisionRead]:
+    return [DecisionRead.model_validate(d) for d in memory.decisions.list()]
+
+
+@router.get("/decisions/{decision_id}", response_model=DecisionRead)
+def get_decision(decision_id: uuid.UUID, memory: MemoryDep) -> DecisionRead:
+    decision = memory.decisions.get(decision_id)
+    if decision is None:
+        raise NodeNotFoundError(f"decision {decision_id} does not exist")
+    return DecisionRead.model_validate(decision)

rootmemory/api/security.py

@@ -0,0 +1,53 @@
+"""API key authentication.
+
+Off by default so a fresh clone and the test-suite still work with no setup.
+Set ``API_KEYS`` and it turns on for every route except ``/health``.
+
+Why this matters here specifically: ``POST /observations/{id}/invalidate``
+cascades through the graph, downgrading claims and flagging decisions. On an
+open port that is a one-request way to poison shared memory, so an instance
+reachable by anything other than localhost must set ``API_KEYS``.
+"""
+
+from __future__ import annotations
+
+import hmac
+
+from fastapi import Depends, HTTPException, Request, status
+from fastapi.security import APIKeyHeader
+
+from rootmemory.config import Settings, get_settings
+
+API_KEY_HEADER = "X-API-Key"
+
+#: Routes that never require a key: liveness, and the portal shell itself
+#: (the page prompts for a key and then calls the API with it).
+OPEN_PATHS = frozenset({"/health", "/ui", "/", "/docs", "/openapi.json", "/redoc"})
+
+_header_scheme = APIKeyHeader(name=API_KEY_HEADER, auto_error=False)
+
+
+def _is_open(path: str) -> bool:
+    return path in OPEN_PATHS or path.startswith("/static/")
+
+
+def require_api_key(
+    request: Request,
+    provided: str | None = Depends(_header_scheme),
+    settings: Settings = Depends(get_settings),
+) -> None:
+    """Dependency enforcing the API key when one is configured."""
+    if not settings.auth_enabled or _is_open(request.url.path):
+        return
+
+    # Compared with hmac.compare_digest so a wrong key cannot be found by
+    # timing the response.
+    for candidate in settings.api_key_list:
+        if provided is not None and hmac.compare_digest(provided, candidate):
+            return
+
+    raise HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail=f"a valid {API_KEY_HEADER} header is required",
+        headers={"WWW-Authenticate": API_KEY_HEADER},
+    )