amfs-http-server 0.1.0__tar.gz → 0.1.2__tar.gz

{amfs_http_server-0.1.0 → amfs_http_server-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amfs-http-server
-Version: 0.1.0
+Version: 0.1.2
 Summary: AMFS HTTP/REST API server with SSE support
 License-Expression: Apache-2.0
 Requires-Python: >=3.11

{amfs_http_server-0.1.0 → amfs_http_server-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "amfs-http-server"
-version = "0.1.0"
+version = "0.1.2"
 description = "AMFS HTTP/REST API server with SSE support"
 requires-python = ">=3.11"
 license = "Apache-2.0"

{amfs_http_server-0.1.0 → amfs_http_server-0.1.2}/src/amfs_http/models.py

@@ -16,6 +16,7 @@ class WriteRequest(BaseModel):
     memory_type: str = "fact"
     shared: bool = True
     branch: str = "main"
+    agent_id: str | None = None
 
 
 class OutcomeRequest(BaseModel):
@@ -23,6 +24,7 @@ class OutcomeRequest(BaseModel):
     outcome_type: str
     causal_entry_keys: list[str] | None = None
     causal_confidence: float = 1.0
+    agent_id: str | None = None
 
 
 class SearchRequest(BaseModel):
@@ -42,6 +44,7 @@ class ContextRequest(BaseModel):
     label: str
     summary: str
     source: str | None = None
+    agent_id: str | None = None
 
 
 class CreateAPIKeyRequest(BaseModel):

{amfs_http_server-0.1.0 → amfs_http_server-0.1.2}/src/amfs_http/server.py

@@ -79,12 +79,18 @@ async def _dashboard_tenant_middleware(request: Request, call_next):
 _memory: AgentMemory | None = None
 _sse_manager = SSEManager()
 
+_immutable_trace_store = None
 try:
     from amfs_traces.api import mount_pro_routes
     mount_pro_routes(app)
     logger.info("Pro trace endpoints mounted at /api/v1/pro/traces")
+
+    from amfs_traces.store import PostgresImmutableTraceStore
+    from amfs_traces.crypto import seal, get_signing_key, get_signing_key_id
+    from amfs_traces.models import ImmutableDecisionTrace, TraceEntry, TraceExternalContext
+    _HAS_PRO_TRACES = True
 except ImportError:
-    pass
+    _HAS_PRO_TRACES = False
 
 try:
     from amfs_cortex_pro import mount_cortex_pro
@@ -218,6 +224,40 @@ async def health() -> dict[str, str]:
     return {"status": "ok"}
 
 
+@app.get("/api/v1/auth/whoami")
+async def whoami(
+    request: Request,
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    """Return information about the authenticated caller.
+
+    When Pro middleware is active, this returns account, key type, scopes,
+    and rate limit info. In OSS mode, returns basic auth status.
+    """
+    ctx = getattr(request.state, "tenant_ctx", None)
+    if ctx is not None:
+        return {
+            "authenticated": True,
+            "mode": "pro",
+            "account_id": str(ctx.account_id),
+            "actor_id": str(ctx.actor_id),
+            "key_type": ctx.key_type.value if ctx.key_type else None,
+            "scopes": [
+                {
+                    "entity_path_pattern": s.entity_path_pattern,
+                    "permission": s.permission.value,
+                }
+                for s in ctx.scopes
+            ],
+            "rate_limit_rpm": ctx.rate_limit_rpm,
+            "is_admin": ctx.is_admin,
+        }
+    return {
+        "authenticated": _auth is not None,
+        "mode": "oss",
+    }
+
+
 # ──────────────────────────────────────────────────────────────────────
 # Entries
 # ──────────────────────────────────────────────────────────────────────
@@ -252,16 +292,27 @@ async def write_entry(
     }
     mt = type_map.get(req.memory_type.lower(), MemoryType.FACT)
 
-    entry = mem.write(
-        req.entity_path,
-        req.key,
-        req.value,
-        confidence=req.confidence,
-        pattern_refs=req.pattern_refs or None,
-        memory_type=mt,
-        shared=req.shared,
-        branch=req.branch,
-    )
+    original_agent = mem._tagger.agent_id if req.agent_id else None
+    if req.agent_id:
+        mem._tagger.agent_id = req.agent_id
+        try:
+            mem._adapter.ensure_agent(req.agent_id, mem.namespace)
+        except Exception:
+            pass
+    try:
+        entry = mem.write(
+            req.entity_path,
+            req.key,
+            req.value,
+            confidence=req.confidence,
+            pattern_refs=req.pattern_refs or None,
+            memory_type=mt,
+            shared=req.shared,
+            branch=req.branch,
+        )
+    finally:
+        if original_agent is not None:
+            mem._tagger.agent_id = original_agent
     _sse_manager.broadcast(entry)
     _audit_log(
         "memory.write",
@@ -380,6 +431,98 @@ _OUTCOME_TYPE_MAP = {
 }
 
 
+def _get_immutable_store():
+    """Lazily create the immutable trace store (Pro only)."""
+    global _immutable_trace_store
+    if _immutable_trace_store is not None:
+        return _immutable_trace_store
+    if not _HAS_PRO_TRACES:
+        return None
+    dsn = os.environ.get("AMFS_POSTGRES_DSN")
+    if not dsn:
+        return None
+    try:
+        import psycopg
+        from psycopg.rows import dict_row
+        conn = psycopg.connect(dsn, row_factory=dict_row, autocommit=True)
+        _immutable_trace_store = PostgresImmutableTraceStore(conn)
+        logger.info("Immutable trace store initialized")
+        return _immutable_trace_store
+    except Exception:
+        logger.debug("Failed to init immutable trace store", exc_info=True)
+        return None
+
+
+_seal_sequence: dict[str, int] = {}
+
+
+def _auto_seal_trace(mem: AgentMemory) -> str | None:
+    """If Pro traces are available, auto-seal the last OSS trace as immutable."""
+    if not _HAS_PRO_TRACES:
+        return None
+    oss_trace = getattr(mem, "_last_trace", None)
+    if oss_trace is None:
+        return None
+    store = _get_immutable_store()
+    if store is None:
+        return None
+    try:
+        now = datetime.now(timezone.utc)
+        causal = [
+            TraceEntry(
+                entity_path=e.entity_path,
+                key=e.key,
+                version=e.version,
+                confidence=e.confidence,
+                value=e.value,
+                memory_type=getattr(e, "memory_type", None) or "fact",
+                written_by=getattr(e, "written_by", None),
+                read_at=getattr(e, "read_at", None) or now,
+            )
+            for e in (oss_trace.causal_entries or [])
+        ]
+        contexts = [
+            TraceExternalContext(
+                label=c.label,
+                summary=c.summary,
+                source=getattr(c, "source", None),
+                recorded_at=getattr(c, "recorded_at", None) or now,
+            )
+            for c in (oss_trace.external_contexts or [])
+        ]
+
+        session_id = mem.session_id
+        seq = _seal_sequence.get(session_id, 0)
+        parent_hash = store.get_latest_hash(session_id)
+
+        imm = ImmutableDecisionTrace(
+            agent_id=mem.agent_id,
+            session_id=session_id,
+            sequence_number=seq,
+            outcome_ref=oss_trace.outcome_ref,
+            outcome_type=oss_trace.outcome_type,
+            decision_summary=getattr(oss_trace, "decision_summary", None),
+            causal_entries=causal,
+            external_contexts=contexts,
+            created_at=datetime.now(timezone.utc),
+        )
+        sealed = seal(
+            imm,
+            get_signing_key(),
+            parent_hash=parent_hash,
+            sequence_number=seq,
+            signing_key_id=get_signing_key_id(),
+        )
+        saved = store.save(sealed)
+        _seal_sequence[session_id] = seq + 1
+        logger.info("Auto-sealed immutable trace %s for outcome %s",
+                     saved.id, oss_trace.outcome_ref)
+        return str(saved.id)
+    except Exception:
+        logger.warning("Failed to auto-seal immutable trace", exc_info=True)
+        return None
+
+
 @app.post("/api/v1/outcomes")
 async def commit_outcome(
     req: OutcomeRequest,
@@ -393,23 +536,40 @@ async def commit_outcome(
         valid = ", ".join(_OUTCOME_TYPE_MAP.keys())
         return {"error": f"Invalid outcome_type '{req.outcome_type}'. Must be one of: {valid}"}
 
-    entries = mem.commit_outcome(
-        req.outcome_ref,
-        otype,
-        causal_entry_keys=req.causal_entry_keys,
-        causal_confidence=req.causal_confidence,
-    )
+    original_agent = mem._tagger.agent_id if req.agent_id else None
+    if req.agent_id:
+        mem._tagger.agent_id = req.agent_id
+        try:
+            mem._adapter.ensure_agent(req.agent_id, mem.namespace)
+        except Exception:
+            pass
+    try:
+        entries = mem.commit_outcome(
+            req.outcome_ref,
+            otype,
+            causal_entry_keys=req.causal_entry_keys,
+            causal_confidence=req.causal_confidence,
+        )
+    finally:
+        if original_agent is not None:
+            mem._tagger.agent_id = original_agent
     _audit_log(
         "outcome.commit",
         resource=req.outcome_ref,
         ip_address=request.client.host if request.client else None,
     )
-    return {
+
+    immutable_trace_id = _auto_seal_trace(mem)
+
+    result: dict[str, Any] = {
         "outcome_ref": req.outcome_ref,
         "outcome_type": req.outcome_type,
         "affected_entries": len(entries),
         "entries": [_entry_to_response(e) for e in entries],
     }
+    if immutable_trace_id:
+        result["immutable_trace_id"] = immutable_trace_id
+    return result
 
 
 @app.get("/api/v1/outcomes")
@@ -1680,6 +1840,42 @@ async def resolve_pattern(
 # ──────────────────────────────────────────────────────────────────────
 
 
+@app.get("/api/v1/pro/graph/neighbors")
+async def graph_neighbors(
+    entity: str = Query(...),
+    relation: str | None = Query(None),
+    direction: str = Query("both"),
+    min_confidence: float = Query(0.0),
+    depth: int = Query(1, ge=1, le=5),
+    limit: int = Query(200, ge=1, le=1000),
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    """Traverse the knowledge graph from an entity."""
+    from fastapi.responses import JSONResponse
+
+    mem = _get_memory()
+    try:
+        edges = mem.graph_neighbors(
+            entity,
+            relation=relation,
+            direction=direction,
+            min_confidence=min_confidence,
+            depth=depth,
+            limit=limit,
+        )
+    except Exception as exc:
+        logger.warning("graph_neighbors failed for %s: %s", entity, exc)
+        return JSONResponse(
+            {"entity": entity, "edges": [], "count": 0, "error": str(exc)},
+            status_code=200,
+        )
+    return {
+        "entity": entity,
+        "edges": [e.model_dump(mode="json") for e in edges],
+        "count": len(edges),
+    }
+
+
 @app.get("/api/v1/pro/graph/expertise")
 async def expertise_graph(
     limit_agents: int = Query(30, ge=1, le=200),
@@ -1743,6 +1939,92 @@ async def expertise_graph(
     }
 
 
+@app.post("/api/v1/pro/graph/backfill")
+async def graph_backfill(
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    """Backfill knowledge graph edges from existing entries and outcomes.
+
+    Materializes edges from: pattern_refs → 'references' edges,
+    outcome causal chains → 'informed' + 'read' edges,
+    agent writes → 'wrote' edges.
+    """
+    from amfs_core.models import GraphEdge
+
+    mem = _get_memory()
+    entries = mem.list()
+    outcomes = mem._adapter.list_outcomes(namespace=mem.namespace) if hasattr(mem._adapter, "list_outcomes") else []
+
+    created = 0
+    errors = 0
+
+    for e in entries:
+        aid = e.provenance.agent_id
+        ep = e.entity_path
+        ek = f"{ep}/{e.key}"
+
+        try:
+            mem._adapter.upsert_graph_edge(
+                GraphEdge(
+                    source_entity=aid,
+                    source_type="agent",
+                    relation="wrote",
+                    target_entity=ek,
+                    target_type="entry",
+                    confidence=e.confidence,
+                    provenance={"agent_id": aid, "trigger": "backfill"},
+                ),
+                namespace=mem.namespace,
+                branch=e.branch or "main",
+            )
+            created += 1
+        except Exception:
+            errors += 1
+
+        for ref in (e.provenance.pattern_refs or []):
+            try:
+                mem._adapter.upsert_graph_edge(
+                    GraphEdge(
+                        source_entity=ek,
+                        source_type="entry",
+                        relation="references",
+                        target_entity=ref,
+                        target_type="entry",
+                        provenance={"agent_id": aid, "trigger": "backfill"},
+                    ),
+                    namespace=mem.namespace,
+                    branch=e.branch or "main",
+                )
+                created += 1
+            except Exception:
+                errors += 1
+
+    for o in outcomes:
+        otype = getattr(o, "outcome_type", None)
+        edge_conf = 1.0 if otype and otype.value == "success" else 0.7
+        aid = getattr(o, "agent_id", "unknown")
+        for ek in getattr(o, "causal_entry_keys", []):
+            try:
+                mem._adapter.upsert_graph_edge(
+                    GraphEdge(
+                        source_entity=ek,
+                        source_type="entry",
+                        relation="informed",
+                        target_entity=o.outcome_ref,
+                        target_type="outcome",
+                        confidence=edge_conf,
+                        provenance={"agent_id": aid, "trigger": "backfill"},
+                    ),
+                    namespace=mem.namespace,
+                    branch="main",
+                )
+                created += 1
+            except Exception:
+                errors += 1
+
+    return {"edges_created": created, "errors": errors, "entries_scanned": len(entries), "outcomes_scanned": len(outcomes)}
+
+
 # ──────────────────────────────────────────────────────────────────────
 # Pro — HMO Memory Tiers
 # ──────────────────────────────────────────────────────────────────────
@@ -1759,11 +2041,14 @@ def _compute_tiers(entries: list) -> tuple[dict[str, int], dict[str, float]]:
 
 @app.get("/api/v1/pro/tiers/distribution")
 async def tiers_distribution(
+    agent_id: str | None = Query(None),
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
     """Return HMO tier distribution (Hot / Warm / Archive)."""
     mem = _get_memory()
     entries = mem.list()
+    if agent_id:
+        entries = [e for e in entries if e.provenance.agent_id == agent_id]
 
     tiers, scores = _compute_tiers(entries)
 
@@ -1795,11 +2080,14 @@ async def tiers_distribution(
 async def tiers_entries(
     tier: int = Query(..., ge=1, le=3),
     limit: int = Query(50, ge=1, le=500),
+    agent_id: str | None = Query(None),
     _auth: str | None = Depends(verify_api_key),
 ) -> list[dict[str, Any]]:
     """Return entries for a given HMO tier as a flat array."""
     mem = _get_memory()
     entries = mem.list()
+    if agent_id:
+        entries = [e for e in entries if e.provenance.agent_id == agent_id]
 
     tier_map, score_map = _compute_tiers(entries)
 

{amfs_http_server-0.1.0 → amfs_http_server-0.1.2}/src/amfs_http/tenant_middleware.py

@@ -14,11 +14,16 @@ logger = logging.getLogger(__name__)
 def apply_tenant_headers_from_request(request: Request) -> None:
     """If proxy secret + account id headers match env, set thread-local tenant for DB RLS."""
     try:
-        from amfs_postgres.tenant_context import set_tls_tenant_account_id
+        from amfs_postgres.tenant_context import (
+            get_request_tenant_account_id,
+            set_tls_tenant_account_id,
+        )
     except ImportError:
         return
 
-    set_tls_tenant_account_id(None)
+    if get_request_tenant_account_id() is not None:
+        return
+
     secret = os.environ.get("AMFS_DASHBOARD_PROXY_SECRET", "")
     if not secret:
         return