amfs-http-server 0.2.0__tar.gz → 0.3.1__tar.gz

{amfs_http_server-0.2.0 → amfs_http_server-0.3.1}/PKG-INFO

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

{amfs_http_server-0.2.0 → amfs_http_server-0.3.1}/pyproject.toml

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

{amfs_http_server-0.2.0 → amfs_http_server-0.3.1}/src/amfs_http/auth.py

@@ -26,6 +26,10 @@ def _check_db_key(api_key: str) -> bool:
 
     Keys are stored as SHA-256 hex digests, so we hash the incoming raw key
     before comparing.
+
+    Uses SECURITY DEFINER functions to bypass RLS — this connection does not
+    set amfs.current_account_id, so direct table queries would return nothing
+    when FORCE ROW LEVEL SECURITY is enabled.
     """
     try:
         import psycopg
@@ -39,16 +43,13 @@ def _check_db_key(api_key: str) -> bool:
 
         with psycopg.connect(dsn, row_factory=dict_row) as conn:
             row = conn.execute(
-                "SELECT id FROM amfs_api_keys "
-                "WHERE key_hash = %s AND active = TRUE "
-                "AND (expires_at IS NULL OR expires_at > NOW()) "
-                "LIMIT 1",
+                "SELECT * FROM amfs_authenticate_api_key(%s)",
                 (key_hash,),
             ).fetchone()
             if row:
                 conn.execute(
-                    "UPDATE amfs_api_keys SET last_used = NOW() WHERE id = %s",
-                    (row["id"],),
+                    "SELECT amfs_touch_api_key_usage(%s)",
+                    (row["key_id"],),
                 )
             return row is not None
     except Exception:

{amfs_http_server-0.2.0 → amfs_http_server-0.3.1}/src/amfs_http/models.py

@@ -38,6 +38,7 @@ class SearchRequest(BaseModel):
     limit: int = 100
     sort_by: str = "confidence"
     branch: str = "main"
+    depth: int = 3
 
 
 class ContextRequest(BaseModel):

{amfs_http_server-0.2.0 → amfs_http_server-0.3.1}/src/amfs_http/server.py

@@ -33,6 +33,7 @@ from amfs.config import load_config_or_default
 from pydantic import BaseModel, Field
 from amfs_core.models import (
     AMFSConfig,
+    DecisionTrace,
     Event,
     EventType,
     GraphEdge,
@@ -400,10 +401,11 @@ async def write_entry(
 async def list_entries(
     entity_path: str | None = Query(None),
     branch: str = Query("main"),
+    include_superseded: bool = Query(False),
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
     mem = _get_memory()
-    entries = mem.list(entity_path, branch=branch)
+    entries = mem.list(entity_path, branch=branch, include_superseded=include_superseded)
     return {"entries": [_entry_to_response(e) for e in entries]}
 
 
@@ -429,6 +431,7 @@ async def search_entries(
         pattern_ref=req.pattern_ref,
         sort_by=req.sort_by,
         limit=req.limit,
+        depth=req.depth,
     )
     try:
         results = mem._adapter.search(sq, branch=branch)
@@ -462,6 +465,176 @@ async def get_stats(
     return json.loads(json.dumps(stats.model_dump(mode="json"), default=str))
 
 
+# ──────────────────────────────────────────────────────────────────────
+# Integrity verification
+# ──────────────────────────────────────────────────────────────────────
+
+
+@app.post("/api/v1/verify")
+async def verify_integrity(
+    body: dict[str, Any] = {},
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    mem = _get_memory()
+    entity_path = body.get("entity_path")
+    return mem.verify(entity_path)
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Atomic commits
+# ──────────────────────────────────────────────────────────────────────
+
+
+@app.post("/api/v1/commits")
+async def create_commit(
+    body: dict[str, Any],
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    mem = _get_memory()
+    writes = body.get("writes", [])
+    message = body.get("message", "")
+    with mem.transaction(message) as tx:
+        for w in writes:
+            tx.write(w["entity_path"], w["key"], w.get("value"))
+    return {
+        "commit_id": tx.commit.id if tx.commit else None,
+        "message": message,
+        "entries_written": len(writes),
+    }
+
+
+@app.get("/api/v1/commits")
+async def list_commits(
+    limit: int = Query(50, ge=1, le=500),
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    mem = _get_memory()
+    commits = mem.commit_log(limit=limit)
+    return {
+        "commits": [json.loads(json.dumps(c.model_dump(mode="json"), default=str)) for c in commits],
+        "count": len(commits),
+    }
+
+
+@app.get("/api/v1/commits/{commit_id}")
+async def get_commit(
+    commit_id: str,
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    mem = _get_memory()
+    commit = mem.get_commit(commit_id)
+    if commit is None:
+        from fastapi import HTTPException
+        raise HTTPException(status_code=404, detail="Commit not found")
+    return json.loads(json.dumps(commit.model_dump(mode="json"), default=str))
+
+
+@app.post("/api/v1/merge-base")
+async def merge_base(
+    body: dict[str, Any],
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    mem = _get_memory()
+    ancestor = mem.common_ancestor(body["commit_a"], body["commit_b"])
+    return {
+        "ancestor_commit_id": ancestor,
+        "commit_a": body["commit_a"],
+        "commit_b": body["commit_b"],
+    }
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Agent binding
+# ──────────────────────────────────────────────────────────────────────
+
+
+@app.put("/api/v1/agents/{agent_id}/profile")
+async def update_agent_profile(
+    agent_id: str,
+    body: dict[str, Any],
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    from amfs_core.models import AgentProfile
+
+    mem = _get_memory()
+    profile = AgentProfile.model_validate(body)
+    agent = mem._adapter.update_agent_profile(agent_id, profile)
+    return json.loads(json.dumps(agent.model_dump(mode="json"), default=str))
+
+
+@app.put("/api/v1/agents/{agent_id}/capabilities")
+async def update_agent_capabilities(
+    agent_id: str,
+    body: dict[str, Any],
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    from amfs_core.models import AgentCapability
+
+    mem = _get_memory()
+    capabilities = [AgentCapability.model_validate(c) for c in body.get("capabilities", [])]
+    agent = mem._adapter.update_agent_capabilities(agent_id, capabilities)
+    return json.loads(json.dumps(agent.model_dump(mode="json"), default=str))
+
+
+@app.put("/api/v1/agents/{agent_id}/contracts")
+async def update_agent_contracts(
+    agent_id: str,
+    body: dict[str, Any],
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    from amfs_core.models import MemoryContract
+
+    mem = _get_memory()
+    contracts = [MemoryContract.model_validate(c) for c in body.get("contracts", [])]
+    agent = mem._adapter.update_agent_contracts(agent_id, contracts)
+    return json.loads(json.dumps(agent.model_dump(mode="json"), default=str))
+
+
+@app.get("/api/v1/agents/discover")
+async def discover_agents(
+    capability: str | None = Query(None),
+    entity_path: str | None = Query(None),
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    mem = _get_memory()
+    agents = mem.discover_agents(capability=capability, entity_path=entity_path)
+    return {
+        "agents": [json.loads(json.dumps(a.model_dump(mode="json"), default=str)) for a in agents],
+        "count": len(agents),
+    }
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Diff & patch
+# ──────────────────────────────────────────────────────────────────────
+
+
+@app.post("/api/v1/diff")
+async def compute_diff(
+    body: dict[str, Any],
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    mem = _get_memory()
+    return mem.diff(
+        body["entity_path"],
+        body["key"],
+        body.get("old_version"),
+    )
+
+
+@app.post("/api/v1/patches")
+async def create_patch(
+    body: dict[str, Any],
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    mem = _get_memory()
+    return mem.create_patch(
+        body["entity_path"],
+        body["key"],
+        body.get("source_version"),
+    )
+
+
 # ──────────────────────────────────────────────────────────────────────
 # History
 # ──────────────────────────────────────────────────────────────────────
@@ -541,6 +714,8 @@ def _auto_seal_trace(mem: AgentMemory) -> str | None:
     if store is None:
         return None
     try:
+        from uuid import UUID as _UUID
+
         now = datetime.now(timezone.utc)
         causal = [
             TraceEntry(
@@ -569,7 +744,20 @@ def _auto_seal_trace(mem: AgentMemory) -> str | None:
         seq = _seal_sequence.get(session_id, 0)
         parent_hash = store.get_latest_hash(session_id)
 
+        trace_id = _UUID(oss_trace.id) if oss_trace.id else None
+
+        account_id = None
+        try:
+            from amfs_postgres.tenant_context import get_request_tenant_account_id
+            tid = get_request_tenant_account_id()
+            if tid:
+                account_id = _UUID(tid)
+        except (ImportError, ValueError):
+            pass
+
         imm = ImmutableDecisionTrace(
+            **({"id": trace_id} if trace_id else {}),
+            **({"account_id": account_id} if account_id else {}),
             agent_id=mem.agent_id,
             session_id=session_id,
             sequence_number=seq,
@@ -578,7 +766,7 @@ def _auto_seal_trace(mem: AgentMemory) -> str | None:
             decision_summary=getattr(oss_trace, "decision_summary", None),
             causal_entries=causal,
             external_contexts=contexts,
-            created_at=datetime.now(timezone.utc),
+            created_at=now,
         )
         sealed = seal(
             imm,
@@ -710,6 +898,19 @@ async def list_traces(
     return {"traces": [t.model_dump(mode="json") for t in traces]}
 
 
+@app.post("/api/v1/traces")
+async def save_trace(
+    req: Request,
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    """Persist a decision trace (used by HttpAdapter.save_trace)."""
+    body = await req.json()
+    trace = DecisionTrace.model_validate(body)
+    mem = _get_memory()
+    saved = mem._adapter.save_trace(trace)
+    return saved.model_dump(mode="json")
+
+
 @app.get("/api/v1/traces/{trace_id}")
 async def get_trace(
     trace_id: str,
@@ -928,11 +1129,37 @@ async def list_agents(
                 "entries_written": 0,
                 "entities_touched": set(),
                 "last_active": e.provenance.written_at,
+                "first_seen": e.provenance.written_at,
             }
         agent_data[aid]["entries_written"] += 1
         agent_data[aid]["entities_touched"].add(e.entity_path)
         if e.provenance.written_at > agent_data[aid]["last_active"]:
             agent_data[aid]["last_active"] = e.provenance.written_at
+        if e.provenance.written_at and (
+            agent_data[aid]["first_seen"] is None
+            or e.provenance.written_at < agent_data[aid]["first_seen"]
+        ):
+            agent_data[aid]["first_seen"] = e.provenance.written_at
+
+    agent_registration: dict[str, dict[str, Any]] = {}
+    known_agent_ids = list(agent_data.keys())
+    if known_agent_ids:
+        try:
+            from amfs_postgres.adapter import PostgresAdapter
+            adapter = mem._adapter
+            if isinstance(adapter, PostgresAdapter):
+                with adapter._pool.connection() as conn:
+                    with conn.cursor() as cur:
+                        placeholders = ", ".join(["%s"] * len(known_agent_ids))
+                        cur.execute(
+                            f"SELECT agent_id, created_at FROM amfs_agents "
+                            f"WHERE namespace = %s AND agent_id IN ({placeholders})",
+                            [adapter._namespace, *known_agent_ids],
+                        )
+                        for row in cur.fetchall():
+                            agent_registration[row["agent_id"]] = {"created_at": row["created_at"]}
+        except (ImportError, Exception):
+            pass
 
     agent_descriptions: dict[str, dict[str, Any]] = {}
     try:
@@ -949,11 +1176,14 @@ async def list_agents(
     agents = []
     for ad in sorted(agent_data.values(), key=lambda x: x["entries_written"], reverse=True):
         desc_info = agent_descriptions.get(ad["agent_id"], {})
+        reg = agent_registration.get(ad["agent_id"], {})
+        created = reg.get("created_at") or ad.get("first_seen")
         agents.append({
             "agentId": ad["agent_id"],
             "entriesWritten": ad["entries_written"],
             "entitiesTouched": len(ad["entities_touched"]),
             "lastActive": ad["last_active"].isoformat() if ad["last_active"] else None,
+            "createdAt": created.isoformat() if created else None,
             "description": desc_info.get("description", ""),
             "platform": desc_info.get("platform", ""),
         })
@@ -987,6 +1217,7 @@ async def agent_memory_graph(
             "writtenAt": e.provenance.written_at.isoformat(),
         })
 
+    # Build read counts from both traces (causal_entries) and timeline events.
     read_entities: dict[str, dict[str, int]] = {}
     for t in traces:
         for ce in t.causal_entries:
@@ -996,6 +1227,26 @@ async def agent_memory_graph(
                 read_entities[ep] = {}
             read_entities[ep][key] = read_entities[ep].get(key, 0) + 1
 
+    # Supplement with READ events from the timeline (persisted independently).
+    total_read_events = 0
+    try:
+        read_events = mem._adapter.list_events(
+            agent_id, mem.namespace, event_type="read", limit=10000,
+        )
+        cross_read_events = mem._adapter.list_events(
+            agent_id, mem.namespace, event_type="cross_agent_read", limit=10000,
+        )
+        for ev in read_events + cross_read_events:
+            ep = ev.details.get("entity_path", "")
+            key = ev.details.get("key", "")
+            if ep and key:
+                if ep not in read_entities:
+                    read_entities[ep] = {}
+                read_entities[ep][key] = read_entities[ep].get(key, 0) + 1
+        total_read_events = len(read_events) + len(cross_read_events)
+    except Exception:
+        pass
+
     entry_authors: dict[str, str] = {}
     for e in entries:
         entry_authors[f"{e.entity_path}/{e.key}"] = e.provenance.agent_id
@@ -1026,6 +1277,7 @@ async def agent_memory_graph(
         "nodes": nodes,
         "traceCount": len(traces),
         "totalWritten": len(written_by_agent),
+        "totalReads": total_read_events,
         "crossAgentReads": cross_agent_reads,
     }
 
@@ -1452,6 +1704,72 @@ async def recover_snapshot(
     }
 
 
+# ──────────────────────────────────────────────────────────────────────
+# Rollback
+# ──────────────────────────────────────────────────────────────────────
+
+
+@app.post("/api/v1/rollback")
+async def rollback(
+    body: dict[str, Any],
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    """Rollback an agent's memory to a specific event or timestamp.
+
+    Accepts either ``target_event_id`` (looks up the event to get its
+    timestamp and agent) or ``target_timestamp`` + ``agent_id``.
+    """
+    mem = _get_memory()
+    target_event_id = body.get("target_event_id")
+    target_timestamp = body.get("target_timestamp")
+    agent_id = body.get("agent_id")
+
+    if target_event_id:
+        event = mem._adapter.get_event(target_event_id, mem.namespace)
+        if event is None:
+            raise HTTPException(status_code=404, detail="Event not found")
+        timestamp = event.created_at
+        agent_id = agent_id or event.agent_id
+    elif target_timestamp:
+        if not agent_id:
+            raise HTTPException(
+                status_code=400,
+                detail="agent_id is required when using target_timestamp",
+            )
+        timestamp = datetime.fromisoformat(target_timestamp)
+    else:
+        raise HTTPException(
+            status_code=400,
+            detail="Provide target_event_id or target_timestamp",
+        )
+
+    count = mem._adapter.rollback_to_timestamp(
+        agent_id, "main", timestamp, mem.namespace,
+    )
+
+    try:
+        mem._adapter.log_event(Event(
+            namespace=mem.namespace,
+            agent_id=agent_id,
+            branch="main",
+            event_type=EventType.ROLLBACK,
+            summary=f"Rolled back to {timestamp.isoformat()}",
+            details={
+                "rolled_back_to": timestamp.isoformat(),
+                "entries_restored": count,
+                "source_event_id": target_event_id,
+            },
+        ))
+    except Exception:
+        logger.debug("Failed to log rollback event", exc_info=True)
+
+    return {
+        "entries_restored": count,
+        "rolled_back_to": timestamp.isoformat(),
+        "agent_id": agent_id,
+    }
+
+
 # ──────────────────────────────────────────────────────────────────────
 # Agent-scoped branches & pull requests
 # ──────────────────────────────────────────────────────────────────────
@@ -2874,9 +3192,10 @@ async def cortex_status(
 @app.get("/api/v1/cortex/digests")
 async def list_cortex_digests(
     digest_type: str | None = Query(None),
+    scope: str | None = Query(None),
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
-    """List all compiled digests."""
+    """List compiled digests, optionally filtered by type and scope."""
     try:
         from amfs_postgres.adapter import PostgresAdapter
         from amfs_core.models import DigestType
@@ -2885,13 +3204,18 @@ async def list_cortex_digests(
         adapter = mem._adapter
         if isinstance(adapter, PostgresAdapter):
             dt = DigestType(digest_type) if digest_type else None
-            digests = adapter.list_digests(digest_type=dt)
+            namespace = getattr(adapter, "_namespace", "default")
+            digests = adapter.list_digests(digest_type=dt, namespace=namespace)
+            if scope:
+                digests = [d for d in digests if d.scope == scope]
             return {
                 "digests": [d.model_dump(mode="json") for d in digests],
                 "total": len(digests),
             }
-    except (ImportError, ValueError, Exception):
+    except (ImportError, ValueError):
         pass
+    except Exception:
+        logger.exception("Failed to list cortex digests")
 
     return {"digests": [], "total": 0}
 
@@ -2914,6 +3238,17 @@ async def cortex_activity(
     return {"events": [], "total": 0, "throughput": [], "stats": None}
 
 
+@app.post("/api/v1/cortex/recompile")
+async def cortex_recompile(
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    """Trigger a full digest recompilation."""
+    if not _cortex_worker:
+        raise HTTPException(status_code=503, detail="Cortex worker not running")
+    count = _cortex_worker._compiler.recompile_all()
+    return {"recompiled": count}
+
+
 @app.post("/api/v1/webhooks/{connector_name}")
 async def ingest_webhook(
     connector_name: str,
@@ -3122,6 +3457,8 @@ def main() -> None:
                 logger.info("Embedded Cortex worker started")
             except ImportError:
                 logger.warning("--with-cortex requires amfs-cortex package")
+            except Exception:
+                logger.exception("Failed to start embedded Cortex worker — server will run without Cortex")
         else:
             logger.warning("--with-cortex requires AMFS_POSTGRES_DSN")