agentcache-core 0.9.9__py3-none-any.whl

agentcache/routes/memories.py

@@ -0,0 +1,116 @@
+"""
+Memory routes blueprint.
+
+Handles:
+  POST /agentmemory/remember
+  POST /agentmemory/agent/remember
+  GET  /agentmemory/memories
+  POST /agentmemory/forget
+"""
+
+from flask import Blueprint, jsonify, request
+
+from .. import legacy as functions
+from ..core import KV
+from ._deps import get_kv, get_observation_store
+from .auth import require_auth
+
+
+def create_memories_bp(kv=None):
+    """Blueprint factory — receives kv at registration time (falls back to get_kv())."""
+    bp = Blueprint("memories", __name__)
+
+    def _kv():
+        return kv if kv is not None else get_kv()
+
+    # ------------------------------------------------------------------
+    # POST /agentmemory/remember
+    # ------------------------------------------------------------------
+
+    @bp.route("/agentcache/remember", methods=["POST"])
+    @bp.route("/agentmemory/remember", methods=["POST"])
+    @require_auth
+    def api_remember():
+        try:
+            body = request.get_json(force=True) or {}
+            res = functions.remember(_kv(), body)
+            return jsonify(res), 201
+        except Exception as e:
+            return jsonify({"error": str(e)}), 400
+
+    # ------------------------------------------------------------------
+    # POST /agentmemory/agent/remember
+    # ------------------------------------------------------------------
+
+    @bp.route("/agentcache/agent/remember", methods=["POST"])
+    @bp.route("/agentmemory/agent/remember", methods=["POST"])
+    @require_auth
+    def api_agent_remember():
+        try:
+            body = request.get_json(force=True) or {}
+            content = body.get("content")
+            if not content:
+                return jsonify({"error": "content is required"}), 400
+
+            agent_id = body.get("agentId")
+            project = body.get("project")
+            mem_type = body.get("type") or "fact"
+
+            concepts = body.get("concepts") or []
+            if isinstance(concepts, str):
+                concepts = [c.strip() for c in concepts.split(",") if c.strip()]
+
+            files = body.get("files") or []
+            if isinstance(files, str):
+                files = [f.strip() for f in files.split(",") if f.strip()]
+
+            payload = {
+                "content": content,
+                "type": mem_type,
+                "concepts": concepts,
+                "files": files,
+                "project": project,
+            }
+            if agent_id:
+                payload["agentId"] = agent_id
+
+            res = functions.remember(_kv(), payload)
+            return jsonify(res), 201
+        except Exception as e:
+            return jsonify({"error": str(e)}), 400
+
+    # ------------------------------------------------------------------
+    # GET /agentmemory/memories
+    # ------------------------------------------------------------------
+
+    @bp.route("/agentcache/memories", methods=["GET"])
+    @bp.route("/agentmemory/memories", methods=["GET"])
+    @require_auth
+    def api_memories_list():
+        latest_only = request.args.get("latest", "false").lower() == "true"
+        limit = int(request.args.get("limit", "500"))
+        all_mems = _kv().list(KV.memories)
+        if latest_only:
+            all_mems = [m for m in all_mems if m.get("isLatest") is not False]
+        all_mems.sort(key=lambda m: m.get("createdAt", ""), reverse=True)
+        return jsonify({"memories": all_mems[:limit], "total": len(all_mems)}), 200
+
+    # ------------------------------------------------------------------
+    # POST /agentmemory/forget
+    # ------------------------------------------------------------------
+
+    @bp.route("/agentcache/forget", methods=["POST"])
+    @bp.route("/agentmemory/forget", methods=["POST"])
+    @require_auth
+    def api_forget():
+        try:
+            body = request.get_json(force=True) or {}
+            res = get_observation_store().forget(body)
+            return jsonify(res), 200
+        except Exception as e:
+            return jsonify({"error": str(e)}), 400
+
+    return bp
+
+
+memories_bp = create_memories_bp(None)

agentcache/routes/migration.py

@@ -0,0 +1,32 @@
+"""
+Migration route blueprint.
+
+Handles:
+  POST /agentmemory/migrate
+"""
+
+from flask import Blueprint, jsonify, request
+
+from .. import legacy as functions
+from ._deps import get_kv
+from .auth import require_auth
+
+migration_bp = Blueprint("migration", __name__)
+
+
+# ---------------------------------------------------------------------------
+# POST /agentcache/migrate
+# ---------------------------------------------------------------------------
+
+
+@migration_bp.route("/agentcache/migrate", methods=["POST"])
+@migration_bp.route("/agentmemory/migrate", methods=["POST"])
+@require_auth
+def api_migrate():
+    try:
+        body = request.get_json(force=True) or {}
+        dry_run = bool(body.get("dry_run", False))
+        result = functions.migrate_sessions_to_folders(get_kv(), dry_run)
+        return jsonify(result), 200
+    except Exception as e:
+        return jsonify({"error": str(e)}), 400

agentcache/routes/observations.py

@@ -0,0 +1,253 @@
+"""
+Observation routes blueprint.
+
+Handles:
+  POST /agentcache/observe
+  POST /agentcache/agent/observe
+  GET  /agentcache/folder/observations
+  GET  /agentcache/folders
+  POST /agentcache/folder/dedup
+"""
+
+import datetime
+from typing import Optional
+
+from flask import Blueprint, jsonify, request
+
+from ..core.kv_scopes import KV
+from ..core.observation_store import ObservationStore
+from ._deps import get_observation_store
+from .auth import require_auth
+
+
+def _datetime_now_iso() -> str:
+    return (
+        datetime.datetime.now(datetime.timezone.utc).isoformat().replace("+00:00", "Z")
+    )
+
+
+def create_observations_bp(
+    observation_store: Optional[ObservationStore] = None,
+) -> Blueprint:
+    bp = Blueprint("observations", __name__)
+
+    def get_store() -> ObservationStore:
+        return (
+            observation_store
+            if observation_store is not None
+            else get_observation_store()
+        )
+
+    def get_kv():
+        return get_store().kv
+
+    @bp.route("/agentcache/observe", methods=["POST"])
+    @bp.route("/agentmemory/observe", methods=["POST"])
+    @require_auth
+    def api_observe():
+        body = {}
+        try:
+            body = request.get_json(force=True) or {}
+            folder_path = body.get("folderPath")
+            agent_id = body.get("agentId")
+            text = body.get("text") or body.get("content") or ""
+
+            if not folder_path or not agent_id or not text:
+                return (
+                    jsonify({"error": "folderPath, agentId, and text are required"}),
+                    400,
+                )
+
+            payload = {
+                "folderPath": folder_path,
+                "agentId": agent_id,
+                "text": text,
+                "timestamp": body.get("timestamp") or _datetime_now_iso(),
+                "type": body.get("type"),
+                "title": body.get("title"),
+                "concepts": body.get("concepts"),
+                "files": body.get("files"),
+                "importance": body.get("importance"),
+            }
+            res = get_store().ingest(payload)
+            return jsonify(res), 201
+        except Exception as e:
+            import traceback
+
+            tb = traceback.format_exc()
+            print(
+                f"[observe] 400 — keys={list(body.keys())} {type(e).__name__}: {e}\n{tb}"
+            )
+            return (
+                jsonify(
+                    {
+                        "error": str(e),
+                        "detail": type(e).__name__,
+                        "keys": list(body.keys()),
+                        "tb": tb,
+                    }
+                ),
+                400,
+            )
+
+    @bp.route("/agentcache/agent/observe", methods=["POST"])
+    @bp.route("/agentmemory/agent/observe", methods=["POST"])
+    @require_auth
+    def api_agent_observe():
+        try:
+            body = request.get_json(force=True) or {}
+            folder_path = body.get("folderPath")
+            agent_id = body.get("agentId")
+            text = body.get("text") or body.get("content") or ""
+
+            if not folder_path or not agent_id or not text:
+                return (
+                    jsonify({"error": "folderPath, agentId, and text are required"}),
+                    400,
+                )
+
+            timestamp = body.get("timestamp") or _datetime_now_iso()
+
+            payload = {
+                "folderPath": folder_path,
+                "agentId": agent_id,
+                "text": text,
+                "timestamp": timestamp,
+                "type": body.get("type"),
+                "title": body.get("title"),
+                "concepts": body.get("concepts"),
+                "files": body.get("files"),
+                "importance": body.get("importance"),
+            }
+
+            res = get_store().ingest(payload)
+            return jsonify(res), 201
+        except ValueError as e:
+            print(
+                f"[agent_observe] 400 ValueError — body keys: {list(body.keys())} — {e}"
+            )
+            return jsonify({"error": str(e)}), 400
+        except Exception as e:
+            import traceback
+
+            print(
+                f"[agent_observe] 400 error — body keys: {list(body.keys())} — {type(e).__name__}: {e}"
+            )
+            print(traceback.format_exc())
+            return jsonify({"error": str(e), "detail": type(e).__name__}), 400
+
+    @bp.route("/agentcache/folders", methods=["GET"])
+    @bp.route("/agentmemory/folders", methods=["GET"])
+    @require_auth
+    def api_folders():
+        from .. import legacy
+
+        folders = sorted(
+            get_kv().list(KV.folders),
+            key=lambda x: x.get("lastUpdated", ""),
+            reverse=True,
+        )
+        if legacy.is_agent_scope_isolated():
+            aid = legacy.get_agent_id()
+            if aid:
+                folders = [f for f in folders if f.get("agentId") == aid]
+        return jsonify({"folders": folders}), 200
+
+    @bp.route("/agentcache/folder/observations", methods=["GET"])
+    @bp.route("/agentmemory/folder/observations", methods=["GET"])
+    @require_auth
+    def api_folder_observations():
+        fp = request.args.get("folderPath")
+        aid = request.args.get("agentId")
+        if not fp or not aid:
+            return jsonify({"error": "folderPath and agentId are required"}), 400
+        from .. import legacy
+
+        if legacy.is_agent_scope_isolated():
+            current_aid = legacy.get_agent_id()
+
+            if current_aid and aid != current_aid:
+                return (
+                    jsonify(
+                        {
+                            "error": "Unauthorized: Agent scope is isolated to another agent"
+                        }
+                    ),
+                    403,
+                )
+        observations = sorted(
+            get_kv().list(KV.folder_obs(fp, aid)),
+            key=lambda x: x.get("timestamp", ""),
+            reverse=True,
+        )
+        return (
+            jsonify({"observations": observations, "folderPath": fp, "agentId": aid}),
+            200,
+        )
+
+    @bp.route("/agentcache/session/start", methods=["POST"])
+    @bp.route("/agentmemory/session/start", methods=["POST"])
+    @require_auth
+    def api_session_start():
+        import uuid
+
+        body = request.get_json(force=True) or {}
+        session_id = body.get("sessionId") or f"compat_{uuid.uuid4().hex[:16]}"
+        return (
+            jsonify(
+                {
+                    "sessionId": session_id,
+                    "status": "active",
+                    "message": "Session model migrated to folder-based. Use /agentmemory/agent/observe.",
+                }
+            ),
+            200,
+        )
+
+    @bp.route("/agentcache/session/end", methods=["POST"])
+    @bp.route("/agentmemory/session/end", methods=["POST"])
+    @require_auth
+    def api_session_end():
+        return (
+            jsonify({"success": True, "message": "Session model is now folder-based."}),
+            200,
+        )
+
+    @bp.route("/agentcache/folder/dedup", methods=["POST"])
+    @bp.route("/agentmemory/folder/dedup", methods=["POST"])
+    @require_auth
+    def api_folder_dedup():
+        try:
+            body = request.get_json(force=True) or {}
+            folder_path = body.get("folderPath") or None
+            agent_id = body.get("agentId") or None
+            res = get_store().dedup(folder_path, agent_id)
+            return jsonify(res), 200
+        except Exception as e:
+            return jsonify({"error": str(e)}), 400
+
+    @bp.route("/agentcache/observations", methods=["GET"])
+    @bp.route("/agentmemory/observations", methods=["GET"])
+    @require_auth
+    def api_observations_legacy():
+        session_id = request.args.get("sessionId", "")
+        if not session_id:
+            return jsonify({"observations": [], "sessionId": ""}), 200
+
+        try:
+            obs = sorted(
+                get_kv().list(KV.observations(session_id)),
+                key=lambda x: x.get("timestamp", ""),
+                reverse=True,
+            )
+            return jsonify({"observations": obs, "sessionId": session_id}), 200
+        except Exception as e:
+            return (
+                jsonify({"observations": [], "sessionId": session_id, "error": str(e)}),
+                200,
+            )
+
+    return bp
+
+
+observations_bp = create_observations_bp()

agentcache/routes/search.py

@@ -0,0 +1,80 @@
+"""
+Search and timeline routes blueprint.
+
+Handles:
+  POST /agentmemory/search
+  POST /agentmemory/timeline
+"""
+
+from flask import Blueprint, jsonify, request
+
+from ._deps import get_kv, get_observation_store, get_search_service
+from .auth import require_auth
+
+search_bp = Blueprint("search", __name__)
+
+
+# ---------------------------------------------------------------------------
+# POST /agentcache/search
+# ---------------------------------------------------------------------------
+
+
+@search_bp.route("/agentcache/search", methods=["POST"])
+@search_bp.route("/agentmemory/search", methods=["POST"])
+@require_auth
+def api_search():
+    try:
+        body = request.get_json(force=True) or {}
+        query = body.get("query")
+        if not query or not query.strip():
+            return jsonify({"error": "query is required"}), 400
+        limit = body.get("limit") or 10
+        folder_path = body.get("folderPath")
+        agent_id = body.get("agentId")
+
+        search_svc = get_search_service()
+        if search_svc is not None:
+            res = search_svc.search(
+                query=query,
+                limit=limit,
+                folder_path=folder_path,
+                agent_id=agent_id,
+                kv=get_kv(),
+            )
+        else:
+            res = []
+        return jsonify(res), 200
+    except Exception as e:
+        return jsonify({"error": str(e)}), 400
+
+
+# ---------------------------------------------------------------------------
+# POST /agentcache/timeline
+# ---------------------------------------------------------------------------
+
+
+@search_bp.route("/agentcache/timeline", methods=["POST"])
+@search_bp.route("/agentmemory/timeline", methods=["POST"])
+@require_auth
+def api_timeline():
+    try:
+        body = request.get_json(force=True) or {}
+        folder_path = body.get("folderPath")
+        agent_id = body.get("agentId")
+        limit = body.get("limit") or 100
+        before = body.get("before")
+        after = body.get("after")
+        obs_store = get_observation_store()
+        if obs_store is not None:
+            result = obs_store.timeline(
+                limit=limit,
+                folder_path=folder_path,
+                agent_id=agent_id,
+                before=before,
+                after=after,
+            )
+        else:
+            result = []
+        return jsonify({"observations": result}), 200
+    except Exception as e:
+        return jsonify({"error": str(e)}), 400