amfs-http-server 0.3.41__tar.gz → 0.3.43__tar.gz

{amfs_http_server-0.3.41 → amfs_http_server-0.3.43}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.5
 Name: amfs-http-server
-Version: 0.3.41
+Version: 0.3.43
 Summary: AMFS HTTP/REST API server with SSE support
 License-Expression: Apache-2.0
 Requires-Python: >=3.11
 Requires-Dist: amfs-core>=0.3.37
-Requires-Dist: amfs>=0.5.27
+Requires-Dist: amfs>=0.5.28
 Requires-Dist: fastapi>=0.115
 Requires-Dist: httpx>=0.27
 Requires-Dist: sse-starlette>=2.0

{amfs_http_server-0.3.41 → amfs_http_server-0.3.43}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "amfs-http-server"
-version = "0.3.41"
+version = "0.3.43"
 description = "AMFS HTTP/REST API server with SSE support"
 requires-python = ">=3.11"
 license = "Apache-2.0"
@@ -13,7 +13,7 @@ dependencies = [
     # this tree is what test_dependency_floors forbids.
     # 0.5.18 for AgentMemory.as_agent, which the agent detail page calls to list
     # an agent's entries as that agent rather than as the server.
-    "amfs>=0.5.27",
+    "amfs>=0.5.28",
     # 0.3.23 is real in the silent way: the write path calls
     # adapter.scope_counts(), which is a default on AdapterABC from 0.3.23. On an
     # older core the adapters that do not override it — filesystem, S3 — have no

{amfs_http_server-0.3.41 → amfs_http_server-0.3.43}/src/amfs_http/server.py

@@ -1610,7 +1610,7 @@ async def health_v1() -> dict[str, str]:
 
 
 @app.get("/api/v1/auth/whoami")
-async def whoami(
+def whoami(
     request: Request,
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
@@ -2304,7 +2304,7 @@ async def list_entity_summaries(
 
 
 @app.post("/api/v1/aggregate")
-async def aggregate_entries_endpoint(
+def aggregate_entries_endpoint(
     request: Request,
     req: AggregateRequest,
     _auth: str | None = Depends(verify_api_key),
@@ -3545,7 +3545,7 @@ async def get_stats(
 
 
 @app.post("/api/v1/verify")
-async def verify_integrity(
+def verify_integrity(
     request: Request,
     body: dict[str, Any] = {},
     _auth: str | None = Depends(verify_api_key),
@@ -3576,7 +3576,7 @@ _COMMIT_WRITE_OPTIONS = ("confidence", "memory_type", "pattern_refs", "shared")
 
 
 @app.post("/api/v1/commits")
-async def create_commit(
+def create_commit(
     body: dict[str, Any],
     request: Request,
     _auth: str | None = Depends(verify_api_key),
@@ -3640,56 +3640,52 @@ async def create_commit(
     # from the moment this deploys. The body wins when both are present.
     agent_id = body.get("agent_id") or request.headers.get("x-amfs-agent-id")
     session_id = body.get("session_id")
-    original_agent = mem._tagger.agent_id if agent_id else None
-    original_session = mem._tagger.session_id if session_id else None
 
-    try:
-        if agent_id:
-            mem._tagger.agent_id = agent_id
-            try:
-                # The gateway ensures its agent when the session opens, so this
-                # is normally a no-op. It is here for a client committing as an
-                # agent this server has not seen, where the entry insert would
-                # otherwise fail on a name nothing has registered.
-                mem._adapter.ensure_agent(agent_id, mem.namespace)
-            except Exception:  # noqa: BLE001
-                logger.warning(
-                    "ensure_agent failed for %s — committing anyway", agent_id,
-                    exc_info=True,
-                )
-            _link_agent_owner_once(request, agent_id, mem.namespace)
+    # A per-request handle carries the caller's identity (``AgentMemory.as_agent``).
+    # Swapping the shared tagger and restoring it in a ``finally`` was atomic
+    # only while this body ran on the event loop; on the threadpool two commits
+    # would stamp each other's writes.
+    handle = mem
+    if agent_id or session_id:
+        handle = mem.as_agent(agent_id or mem.agent_id)
         if session_id:
-            mem._tagger.session_id = session_id
-
-        with mem.transaction(message) as tx:
-            for w in writes:
-                options = {k: w[k] for k in _COMMIT_WRITE_OPTIONS if k in w}
-                # Arrives over the wire as a string, and the write path wants
-                # the enum. An unknown one is refused rather than dropped:
-                # writing the entry with a default type would put the wrong
-                # metadata on the right memory, and nothing later can tell that
-                # happened.
-                if "memory_type" in options:
-                    raw = str(options["memory_type"])
-                    try:
-                        options["memory_type"] = MemoryType(raw)
-                    except ValueError as exc:
-                        raise HTTPException(
-                            status_code=422,
-                            detail=(
-                                f"Invalid memory_type {raw!r}. Valid: "
-                                + ", ".join(m.value for m in MemoryType)
-                            ),
-                        ) from exc
-                tx.write(w["entity_path"], w["key"], w.get("value"), **options)
-    finally:
-        # Restored even when the transaction raised. This memory is a process
-        # singleton, so a tagger left holding one caller's name would sign the
-        # next caller's writes with it.
-        if original_agent is not None:
-            mem._tagger.agent_id = original_agent
-        if original_session is not None:
-            mem._tagger.session_id = original_session
+            handle._tagger.session_id = session_id
+
+    if agent_id:
+        try:
+            # The gateway ensures its agent when the session opens, so this
+            # is normally a no-op. It is here for a client committing as an
+            # agent this server has not seen, where the entry insert would
+            # otherwise fail on a name nothing has registered.
+            mem._adapter.ensure_agent(agent_id, mem.namespace)
+        except Exception:  # noqa: BLE001
+            logger.warning(
+                "ensure_agent failed for %s — committing anyway", agent_id,
+                exc_info=True,
+            )
+        _link_agent_owner_once(request, agent_id, mem.namespace)
+
+    with handle.transaction(message) as tx:
+        for w in writes:
+            options = {k: w[k] for k in _COMMIT_WRITE_OPTIONS if k in w}
+            # Arrives over the wire as a string, and the write path wants
+            # the enum. An unknown one is refused rather than dropped:
+            # writing the entry with a default type would put the wrong
+            # metadata on the right memory, and nothing later can tell that
+            # happened.
+            if "memory_type" in options:
+                raw = str(options["memory_type"])
+                try:
+                    options["memory_type"] = MemoryType(raw)
+                except ValueError as exc:
+                    raise HTTPException(
+                        status_code=422,
+                        detail=(
+                            f"Invalid memory_type {raw!r}. Valid: "
+                            + ", ".join(m.value for m in MemoryType)
+                        ),
+                    ) from exc
+            tx.write(w["entity_path"], w["key"], w.get("value"), **options)
 
     commit = tx.commit
     return {
@@ -3704,7 +3700,7 @@ async def create_commit(
 
 
 @app.get("/api/v1/commits")
-async def list_commits(
+def list_commits(
     request: Request,
     limit: int = Query(50, ge=1, le=500),
     branch: str | None = Query(None),
@@ -3752,7 +3748,7 @@ async def list_commits(
 
 
 @app.get("/api/v1/commits/{commit_id}")
-async def get_commit(
+def get_commit(
     request: Request,
     commit_id: str,
     _auth: str | None = Depends(verify_api_key),
@@ -3769,7 +3765,7 @@ async def get_commit(
 
 
 @app.post("/api/v1/merge-base")
-async def merge_base(
+def merge_base(
     body: dict[str, Any],
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
@@ -3939,7 +3935,7 @@ def _infer_tags(
 
 
 @app.put("/api/v1/agents/{agent_id:path}/profile")
-async def update_agent_profile(
+def update_agent_profile(
     request: Request,
     agent_id: str,
     body: dict[str, Any],
@@ -3960,7 +3956,7 @@ async def update_agent_profile(
 
 
 @app.put("/api/v1/agents/{agent_id:path}/capabilities")
-async def update_agent_capabilities(
+def update_agent_capabilities(
     request: Request,
     agent_id: str,
     body: dict[str, Any],
@@ -3976,7 +3972,7 @@ async def update_agent_capabilities(
 
 
 @app.put("/api/v1/agents/{agent_id:path}/contracts")
-async def update_agent_contracts(
+def update_agent_contracts(
     request: Request,
     agent_id: str,
     body: dict[str, Any],
@@ -3992,7 +3988,7 @@ async def update_agent_contracts(
 
 
 @app.get("/api/v1/agents/discover")
-async def discover_agents(
+def discover_agents(
     request: Request,
     capability: str | None = Query(None),
     entity_path: str | None = Query(None),
@@ -4027,7 +4023,7 @@ def _require_entry_visible(request: Request, entity_path: str, key: str) -> None
 
 
 @app.post("/api/v1/diff")
-async def compute_diff(
+def compute_diff(
     request: Request,
     body: dict[str, Any],
     _auth: str | None = Depends(verify_api_key),
@@ -4042,7 +4038,7 @@ async def compute_diff(
 
 
 @app.post("/api/v1/patches")
-async def create_patch(
+def create_patch(
     request: Request,
     body: dict[str, Any],
     _auth: str | None = Depends(verify_api_key),
@@ -4787,7 +4783,7 @@ async def commit_outcome(
 
 
 @app.get("/api/v1/outcomes")
-async def list_outcomes(
+def list_outcomes(
     request: Request,
     entity_path: str | None = Query(None),
     since: str | None = Query(None),
@@ -4815,7 +4811,7 @@ async def list_outcomes(
 
 
 @app.post("/api/v1/context")
-async def record_context(
+def record_context(
     req: ContextRequest,
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
@@ -4825,7 +4821,7 @@ async def record_context(
 
 
 @app.get("/api/v1/explain")
-async def explain(
+def explain(
     request: Request,
     outcome_ref: str | None = Query(None),
     _auth: str | None = Depends(verify_api_key),
@@ -4997,7 +4993,7 @@ async def save_trace(
 # NOTE: must be registered before /api/v1/traces/{trace_id} so "share-stats"
 # isn't captured as a trace_id.
 @app.get("/api/v1/traces/share-stats")
-async def get_share_stats(
+def get_share_stats(
     request: Request,
     since: datetime | None = Query(None),
     pair_limit: int = Query(20, ge=1, le=100),
@@ -5034,7 +5030,7 @@ async def get_trace(
 
 
 @app.post("/api/v1/traces/{trace_id}/explain")
-async def explain_trace(
+def explain_trace(
     request: Request,
     trace_id: str,
     _auth: str | None = Depends(verify_api_key),
@@ -5442,7 +5438,7 @@ async def list_agents(
 
 
 @app.get("/api/v1/reuse")
-async def reuse_summary(
+def reuse_summary(
     request: Request,
     days: int = 7,
     limit: int = 10,
@@ -5519,7 +5515,7 @@ async def reuse_summary(
 
 
 @app.get("/api/v1/agents/{agent_id:path}/memory-graph")
-async def agent_memory_graph(
+def agent_memory_graph(
     request: Request,
     agent_id: str,
     _auth: str | None = Depends(verify_api_key),
@@ -5690,7 +5686,7 @@ async def agent_cross_reads(
 
 
 @app.get("/api/v1/agents/{agent_id:path}/recall/{entity_path:path}/{key}")
-async def agent_recall(
+def agent_recall(
     request: Request,
     agent_id: str,
     entity_path: str,
@@ -5706,13 +5702,10 @@ async def agent_recall(
     if vis is not None and vis.should_filter() and not vis.is_agent_visible(agent_id):
         raise HTTPException(status_code=404, detail="Agent not found")
 
-    mem = _get_memory()
-    original_agent = mem._tagger.agent_id
-    mem._tagger.agent_id = agent_id
-    try:
-        entry = mem.recall(entity_path, key)
-    finally:
-        mem._tagger.agent_id = original_agent
+    # Acting as the agent through a per-request handle, not by swapping the
+    # shared tagger: these routes run on the threadpool now, and a swap there
+    # is a race (``AgentMemory.as_agent``).
+    entry = _get_memory().as_agent(agent_id).recall(entity_path, key)
     if entry is None:
         return {"status": "not_found", "agentId": agent_id,
                 "entityPath": entity_path, "key": key}
@@ -5720,7 +5713,7 @@ async def agent_recall(
 
 
 @app.get("/api/v1/agents/{agent_id:path}/entries")
-async def agent_entries(
+def agent_entries(
     request: Request,
     agent_id: str,
     entity_path: str | None = Query(None),
@@ -5741,7 +5734,7 @@ async def agent_entries(
 
 
 @app.get("/api/v1/agents/{agent_id:path}/read-from/{source_agent_id}/{entity_path:path}/{key}")
-async def agent_read_from(
+def agent_read_from(
     request: Request,
     agent_id: str,
     source_agent_id: str,
@@ -5764,15 +5757,8 @@ async def agent_read_from(
     # from another — and that edge is what the authority ranking is built on,
     # so a cross-agent read over HTTP never counted for anything.
     #
-    # Swapping the tagger is how the rest of this file attributes work to the
-    # caller (see agent_recall above): the memory is a process singleton, so a
-    # tagger left holding one caller's name would sign the next caller's reads.
-    original_agent = mem._tagger.agent_id
-    mem._tagger.agent_id = agent_id
-    try:
-        entry = mem.read_from(source_agent_id, entity_path, key)
-    finally:
-        mem._tagger.agent_id = original_agent
+    # A per-request handle attributes the read to the caller (see agent_recall).
+    entry = mem.as_agent(agent_id).read_from(source_agent_id, entity_path, key)
 
     if entry is None:
         return {"status": "not_found", "sourceAgentId": source_agent_id,
@@ -5973,7 +5959,7 @@ class LogEventRequest(BaseModel):
 
 
 @app.post("/api/v1/timeline/events")
-async def log_timeline_event(
+def log_timeline_event(
     request: Request,
     body: LogEventRequest,
     _auth: str | None = Depends(verify_api_key),
@@ -6024,7 +6010,7 @@ class UpsertGraphEdgeRequest(BaseModel):
 
 
 @app.post("/api/v1/graph/edges")
-async def upsert_graph_edge_endpoint(
+def upsert_graph_edge_endpoint(
     body: UpsertGraphEdgeRequest,
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
@@ -6048,7 +6034,7 @@ async def upsert_graph_edge_endpoint(
 
 
 @app.get("/api/v1/agents/enriched")
-async def list_agents_enriched(
+def list_agents_enriched(
     request: Request,
     histograms: bool = True,
     _auth: str | None = Depends(verify_api_key),
@@ -6078,7 +6064,7 @@ async def list_agents_enriched(
 
 
 @app.get("/api/v1/agent-groups")
-async def list_agent_groups(
+def list_agent_groups(
     request: Request,
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
@@ -6151,7 +6137,7 @@ async def update_agent_group_endpoint(
 
 
 @app.delete("/api/v1/agent-groups/{group_id}")
-async def delete_agent_group_endpoint(
+def delete_agent_group_endpoint(
     group_id: str,
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
@@ -6226,7 +6212,7 @@ async def reorder_agent_groups_endpoint(
 
 
 @app.get("/api/v1/agent-groups/suggestions")
-async def agent_group_suggestions(
+def agent_group_suggestions(
     request: Request,
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
@@ -6263,7 +6249,7 @@ async def agent_group_suggestions(
 
 
 @app.post("/api/v1/agent-groups/suggestions/{cluster_id}/accept", status_code=201)
-async def accept_cluster_suggestion(
+def accept_cluster_suggestion(
     cluster_id: str,
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
@@ -6302,7 +6288,7 @@ async def accept_cluster_suggestion(
 
 
 @app.post("/api/v1/agent-groups/suggestions/{cluster_id}/dismiss")
-async def dismiss_cluster_suggestion_endpoint(
+def dismiss_cluster_suggestion_endpoint(
     cluster_id: str,
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
@@ -6312,32 +6298,86 @@ async def dismiss_cluster_suggestion_endpoint(
     return {"dismissed": True}
 
 
+# The cluster compile walks every agent in the namespace and is pure Python
+# CPU — minutes on an account with thousands of agents. The dashboard's Agents
+# page POSTs it on every mount, so without a guard two tabs or one reload queue
+# a second full compile behind the first while the process is pinned at one
+# core. One compile at a time per process, and a compile that finished within
+# the window is reused rather than repeated; the caller's ``ok`` is unchanged
+# because it only ever waited for the suggestions to be refreshed.
+_CLUSTER_RECOMPUTE_MIN_INTERVAL_S = float(
+    os.environ.get("AMFS_CLUSTER_RECOMPUTE_MIN_INTERVAL_S", "300"),
+)
+_cluster_recompute_lock = threading.Lock()
+_cluster_recompute_last: dict[str, float] = {}
+
+
+def _recompute_window_key(request: Request, namespace: str) -> str:
+    """Who the reuse window belongs to.
+
+    A multi-tenant deployment runs every account under one namespace and keeps
+    them apart with row-level security, so the namespace alone would let the
+    first account's compile mark every other account on the instance as fresh.
+    The account the compile will actually run under is the one on the RLS
+    context — the same ContextVar the Postgres connection reads — so that is
+    the key, whichever middleware branch authenticated the request.
+    ``request.state.account_id`` is the fallback for a deployment whose
+    middleware sets the request state but not the RLS context; a single-tenant
+    server has neither and the namespace is the whole story.
+    """
+    account_id: Any = None
+    try:
+        from amfs_postgres.tenant_context import get_request_tenant_account_id
+
+        account_id = get_request_tenant_account_id()
+    except ImportError:
+        pass
+    if not account_id:
+        account_id = getattr(request.state, "account_id", None)
+    return f"{account_id or ''}:{namespace}"
+
+
 @app.post("/api/v1/agent-groups/recompute")
-async def recompute_clusters(
+def recompute_clusters(
+    request: Request,
+    force: bool = False,
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
-    """Trigger recomputation of agent clusters."""
+    """Trigger recomputation of agent clusters.
+
+    Runs on the threadpool (plain ``def``): the compile is CPU-bound Python and
+    used to freeze the event loop for its whole duration. ``force=true`` skips
+    the reuse window but still waits its turn behind a compile in flight. The
+    window is per tenant account; the lock is per process, because the compile
+    is what pins the core.
+    """
     try:
         from amfs_cortex.compiler import DigestCompiler
         from amfs_postgres.adapter import PostgresAdapter
-
-        mem = _get_memory()
-        adapter = mem._adapter
-        if not isinstance(adapter, PostgresAdapter):
-            return JSONResponse(
-                status_code=400,
-                content={"error": "Cluster recomputation requires Postgres adapter"},
-            )
-        compiler = DigestCompiler(
-            adapter=adapter,
-            namespace=mem.namespace,
-        )
-        compiler.compile(f"cluster:account:{mem.namespace}")
     except ImportError:
         return JSONResponse(
             status_code=400,
             content={"error": "amfs-cortex package is required for recomputation"},
         )
+    mem = _get_memory()
+    adapter = mem._adapter
+    if not isinstance(adapter, PostgresAdapter):
+        return JSONResponse(
+            status_code=400,
+            content={"error": "Cluster recomputation requires Postgres adapter"},
+        )
+    ns = mem.namespace
+    window_key = _recompute_window_key(request, ns)
+    with _cluster_recompute_lock:
+        last = _cluster_recompute_last.get(window_key)
+        if (
+            not force
+            and last is not None
+            and time.monotonic() - last < _CLUSTER_RECOMPUTE_MIN_INTERVAL_S
+        ):
+            return {"ok": True, "skipped": "recent"}
+        DigestCompiler(adapter=adapter, namespace=ns).compile(f"cluster:account:{ns}")
+        _cluster_recompute_last[window_key] = time.monotonic()
     return {"ok": True}
 
 
@@ -6350,7 +6390,7 @@ SNAPSHOT_ENTITY = "_system/agent-snapshots"
 
 
 @app.post("/api/v1/agents/{agent_id:path}/snapshots")
-async def create_snapshot(
+def create_snapshot(
     request: Request,
     agent_id: str,
     req: CreateSnapshotRequest,
@@ -6370,17 +6410,12 @@ async def create_snapshot(
         "data": req.snapshot_data,
     }
 
-    original_agent = mem._tagger.agent_id
-    mem._tagger.agent_id = agent_id
-    try:
-        mem.write(
-            SNAPSHOT_ENTITY,
-            f"{agent_id}/{snapshot_id}",
-            snapshot_value,
-            confidence=1.0,
-        )
-    finally:
-        mem._tagger.agent_id = original_agent
+    mem.as_agent(agent_id).write(
+        SNAPSHOT_ENTITY,
+        f"{agent_id}/{snapshot_id}",
+        snapshot_value,
+        confidence=1.0,
+    )
 
     try:
         mem._adapter.log_event(Event(
@@ -6408,7 +6443,7 @@ async def create_snapshot(
 
 
 @app.get("/api/v1/agents/{agent_id:path}/snapshots")
-async def list_snapshots(
+def list_snapshots(
     request: Request,
     agent_id: str,
     _auth: str | None = Depends(verify_api_key),
@@ -6436,7 +6471,7 @@ async def list_snapshots(
 
 
 @app.get("/api/v1/agents/{agent_id:path}/snapshots/{snapshot_id}")
-async def get_snapshot(
+def get_snapshot(
     request: Request,
     agent_id: str,
     snapshot_id: str,
@@ -6454,7 +6489,7 @@ async def get_snapshot(
 
 
 @app.delete("/api/v1/agents/{agent_id:path}/snapshots/{snapshot_id}")
-async def delete_snapshot(
+def delete_snapshot(
     request: Request,
     agent_id: str,
     snapshot_id: str,
@@ -6472,7 +6507,7 @@ async def delete_snapshot(
 
 
 @app.post("/api/v1/agents/{agent_id:path}/snapshots/{snapshot_id}/recover")
-async def recover_snapshot(
+def recover_snapshot(
     request: Request,
     agent_id: str,
     snapshot_id: str,
@@ -6527,7 +6562,7 @@ async def recover_snapshot(
 
 
 @app.post("/api/v1/rollback")
-async def rollback(
+def rollback(
     request: Request,
     body: dict[str, Any],
     _auth: str | None = Depends(verify_api_key),
@@ -6604,7 +6639,7 @@ async def rollback(
 
 
 @app.get("/api/v1/agents/{agent_id:path}/branches")
-async def agent_branches(
+def agent_branches(
     request: Request,
     agent_id: str,
     _auth: str | None = Depends(verify_api_key),
@@ -6629,7 +6664,7 @@ async def agent_branches(
 
 
 @app.get("/api/v1/agents/{agent_id:path}/pull-requests")
-async def agent_pull_requests(
+def agent_pull_requests(
     request: Request,
     agent_id: str,
     _auth: str | None = Depends(verify_api_key),
@@ -6947,7 +6982,7 @@ def list_audit_log(
 
 
 @app.get("/api/v1/patterns")
-async def list_patterns(
+def list_patterns(
     request: Request,
     entity_path: str | None = Query(None),
     limit: int = Query(100),
@@ -7724,7 +7759,7 @@ def _filter_graph_edges(request: Request, edges: list) -> list:
 
 
 @app.get("/api/v1/pro/graph/neighbors")
-async def graph_neighbors(
+def graph_neighbors(
     request: Request,
     entity: str = Query(...),
     relation: str | None = Query(None),
@@ -7841,7 +7876,7 @@ async def expertise_graph(
 
 
 @app.post("/api/v1/pro/graph/backfill")
-async def graph_backfill(
+def graph_backfill(
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
     """Backfill knowledge graph edges from existing entries and outcomes.
@@ -8050,7 +8085,7 @@ async def stream(
 
 
 @app.get("/api/v1/admin/config")
-async def get_system_config(
+def get_system_config(
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
     """Return system configuration and active Pro module status."""
@@ -8086,7 +8121,7 @@ async def get_system_config(
 
 
 @app.get("/api/v1/connectors")
-async def list_connectors(
+def list_connectors(
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
     """List available and installed connectors."""
@@ -8387,7 +8422,7 @@ async def get_briefing(
 
 
 @app.get("/api/v1/cortex/status")
-async def cortex_status(
+def cortex_status(
     request: Request,
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
@@ -8427,7 +8462,7 @@ async def cortex_status(
 
 
 @app.get("/api/v1/cortex/digests")
-async def list_cortex_digests(
+def list_cortex_digests(
     request: Request,
     digest_type: str | None = Query(None),
     scope: str | None = Query(None),
@@ -8464,7 +8499,7 @@ async def list_cortex_digests(
 
 
 @app.get("/api/v1/cortex/activity")
-async def cortex_activity(
+def cortex_activity(
     request: Request,
     limit: int = Query(default=50, le=200),
     _auth: str | None = Depends(verify_api_key),
@@ -8486,7 +8521,7 @@ async def cortex_activity(
 
 
 @app.post("/api/v1/cortex/recompile")
-async def cortex_recompile(
+def cortex_recompile(
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
     """Trigger a full digest recompilation."""
@@ -8502,7 +8537,7 @@ async def cortex_recompile(
 
 
 @app.post("/api/v1/cortex/consolidate")
-async def run_consolidation(
+def run_consolidation(
     request: Request,
     body: dict[str, Any] | None = None,
     _auth: str | None = Depends(verify_api_key),
@@ -8539,7 +8574,7 @@ async def run_consolidation(
 
 
 @app.get("/api/v1/cortex/consolidation/candidates")
-async def list_consolidation_candidates(
+def list_consolidation_candidates(
     request: Request,
     entity_path: str = Query(...),
     branch: str = Query("main"),
@@ -8566,7 +8601,7 @@ async def list_consolidation_candidates(
 
 
 @app.get("/api/v1/cortex/consolidation/proposals")
-async def list_consolidation_proposals(
+def list_consolidation_proposals(
     request: Request,
     entity_path: str | None = Query(None),
     status: str | None = Query(None),
@@ -8656,7 +8691,7 @@ async def list_consolidation_proposals(
 
 
 @app.get("/api/v1/cortex/consolidation/status")
-async def consolidation_status(
+def consolidation_status(
     request: Request,
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
@@ -8762,23 +8797,19 @@ async def ingest_webhook(
         event_id=event_id,
     )
 
-    original_agent = mem._tagger.agent_id
-    mem._tagger.agent_id = f"webhook/{connector_name}"
     persisted = 0
-    try:
-        for r in results:
-            if r.success and r.action == "write":
-                entry = mem.write(
-                    r.entity_path,
-                    r.key,
-                    r.details,
-                    confidence=1.0,
-                    memory_type=MemoryType.EXPERIENCE,
-                )
-                _sse_manager.broadcast(entry)
-                persisted += 1
-    finally:
-        mem._tagger.agent_id = original_agent
+    as_webhook = mem.as_agent(f"webhook/{connector_name}")
+    for r in results:
+        if r.success and r.action == "write":
+            entry = as_webhook.write(
+                r.entity_path,
+                r.key,
+                r.details,
+                confidence=1.0,
+                memory_type=MemoryType.EXPERIENCE,
+            )
+            _sse_manager.broadcast(entry)
+            persisted += 1
 
     return {
         "results": [r.model_dump(mode="json") for r in results],
@@ -8788,7 +8819,7 @@ async def ingest_webhook(
 
 
 @app.post("/api/v1/events")
-async def ingest_event(
+def ingest_event(
     body: EventRequest,
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
@@ -8799,19 +8830,14 @@ async def ingest_event(
     """
     mem = _get_memory()
 
-    original_agent = mem._tagger.agent_id
-    mem._tagger.agent_id = f"external/{body.source}"
-    try:
-        entry = mem.write(
-            body.entity_path,
-            body.key,
-            body.value,
-            confidence=1.0,
-            memory_type=MemoryType.EXPERIENCE,
-        )
-        _sse_manager.broadcast(entry)
-    finally:
-        mem._tagger.agent_id = original_agent
+    entry = mem.as_agent(f"external/{body.source}").write(
+        body.entity_path,
+        body.key,
+        body.value,
+        confidence=1.0,
+        memory_type=MemoryType.EXPERIENCE,
+    )
+    _sse_manager.broadcast(entry)
 
     return {
         "status": "ok",