tools.py

"""Hermes async tools for sense-memory.

Identity loaded from env (NOSTRKEY_NSEC, or NOSTRKEY_IDENTITY_FILE +
NOSTRKEY_PASSPHRASE). Relay URLs from MEMORY_RELAY_URLS (comma-
separated) or fall back to MEMORY_RELAY_URL (single).
"""

from __future__ import annotations

import os
from dataclasses import asdict, is_dataclass
from typing import Any

from nostrkey import Identity
from sense_memory import MemoryStore

from tools.registry import tool_error, tool_result


def _load_identity() -> Identity | None:
    nsec = os.environ.get("NOSTRKEY_NSEC", "").strip()
    if nsec:
        return Identity.from_nsec(nsec)
    file_path = os.environ.get("NOSTRKEY_IDENTITY_FILE", "").strip()
    passphrase = os.environ.get("NOSTRKEY_PASSPHRASE", "")
    if file_path and passphrase:
        return Identity.load(file_path, passphrase)
    return None


def _relay_urls() -> list[str]:
    raw = os.environ.get("MEMORY_RELAY_URLS", "").strip()
    if raw:
        return [u.strip() for u in raw.split(",") if u.strip()]
    single = os.environ.get("MEMORY_RELAY_URL", "").strip()
    return [single] if single else []


def _make_store() -> MemoryStore | str:
    identity = _load_identity()
    if identity is None:
        return tool_error("No identity. Set NOSTRKEY_NSEC, or NOSTRKEY_IDENTITY_FILE + NOSTRKEY_PASSPHRASE.")
    relays = _relay_urls()
    if not relays:
        return tool_error("No relay URLs. Set MEMORY_RELAY_URLS (comma-separated) or MEMORY_RELAY_URL.")
    return MemoryStore(identity=identity, relay_url=relays)


def _serialize(obj: Any) -> Any:
    import enum
    if isinstance(obj, enum.Enum):
        return obj.value
    if is_dataclass(obj):
        return _serialize(asdict(obj))
    if isinstance(obj, (list, tuple)):
        return [_serialize(x) for x in obj]
    if isinstance(obj, dict):
        return {k: _serialize(v) for k, v in obj.items()}
    return obj


# -----------------------------
# memory_remember
# -----------------------------

MEMORY_REMEMBER_SCHEMA = {
    "type": "function",
    "function": {
        "name": "memory_remember",
        "description": "Store an encrypted key/value memory. The same key overwrites previous value.",
        "parameters": {
            "type": "object",
            "properties": {
                "key":   {"type": "string", "description": "Memory key (lowercase, no spaces)."},
                "value": {"type": "string", "description": "Memory value (any string)."},
            },
            "required": ["key", "value"],
        },
    },
}


async def handle_memory_remember(args: dict[str, Any], **kw) -> str:
    store = _make_store()
    if isinstance(store, str):
        return store
    try:
        event_id = await store.remember(args["key"], args["value"])
        return tool_result({"event_id": event_id, "key": args["key"]})
    except Exception as e:
        return tool_error(f"memory_remember failed: {type(e).__name__}: {e}")


# -----------------------------
# memory_recall
# -----------------------------

MEMORY_RECALL_SCHEMA = {
    "type": "function",
    "function": {
        "name": "memory_recall",
        "description": "Fetch a single memory by key. Returns null value if not found.",
        "parameters": {
            "type": "object",
            "properties": {"key": {"type": "string"}},
            "required": ["key"],
        },
    },
}


async def handle_memory_recall(args: dict[str, Any], **kw) -> str:
    store = _make_store()
    if isinstance(store, str):
        return store
    try:
        memory = await store.recall(args["key"])
        if memory is None:
            return tool_result({"found": False, "key": args["key"]})
        return tool_result({"found": True, "memory": _serialize(memory)})
    except Exception as e:
        return tool_error(f"memory_recall failed: {type(e).__name__}: {e}")


# -----------------------------
# memory_recall_all
# -----------------------------

MEMORY_RECALL_ALL_SCHEMA = {
    "type": "function",
    "function": {
        "name": "memory_recall_all",
        "description": "Return every memory the agent has stored.",
        "parameters": {"type": "object", "properties": {}, "required": []},
    },
}


async def handle_memory_recall_all(args: dict[str, Any], **kw) -> str:
    store = _make_store()
    if isinstance(store, str):
        return store
    try:
        memories = await store.recall_all()
        return tool_result({"count": len(memories), "memories": _serialize(memories)})
    except Exception as e:
        return tool_error(f"memory_recall_all failed: {type(e).__name__}: {e}")


# -----------------------------
# memory_forget
# -----------------------------

MEMORY_FORGET_SCHEMA = {
    "type": "function",
    "function": {
        "name": "memory_forget",
        "description": "Delete a memory by key (publishes a NIP-09 deletion event).",
        "parameters": {
            "type": "object",
            "properties": {"key": {"type": "string"}},
            "required": ["key"],
        },
    },
}


async def handle_memory_forget(args: dict[str, Any], **kw) -> str:
    store = _make_store()
    if isinstance(store, str):
        return store
    try:
        event_id = await store.forget(args["key"])
        return tool_result({"deletion_event_id": event_id, "key": args["key"]})
    except Exception as e:
        return tool_error(f"memory_forget failed: {type(e).__name__}: {e}")


# -----------------------------
# memory_journal
# -----------------------------

MEMORY_JOURNAL_SCHEMA = {
    "type": "function",
    "function": {
        "name": "memory_journal",
        "description": "Append an entry to the agent's encrypted journal (timestamped, append-only).",
        "parameters": {
            "type": "object",
            "properties": {"content": {"type": "string"}},
            "required": ["content"],
        },
    },
}


async def handle_memory_journal(args: dict[str, Any], **kw) -> str:
    store = _make_store()
    if isinstance(store, str):
        return store
    try:
        event_id = await store.journal(args["content"])
        return tool_result({"event_id": event_id})
    except Exception as e:
        return tool_error(f"memory_journal failed: {type(e).__name__}: {e}")


# -----------------------------
# memory_recent
# -----------------------------

MEMORY_RECENT_SCHEMA = {
    "type": "function",
    "function": {
        "name": "memory_recent",
        "description": "Return the most recent journal entries, newest first.",
        "parameters": {
            "type": "object",
            "properties": {
                "limit": {"type": "integer", "default": 20, "description": "Max entries to return. Cap 100."},
            },
            "required": [],
        },
    },
}


async def handle_memory_recent(args: dict[str, Any], **kw) -> str:
    store = _make_store()
    if isinstance(store, str):
        return store
    try:
        limit = max(1, min(100, int(args.get("limit", 20))))
        entries = await store.recent(limit=limit)
        return tool_result({"count": len(entries), "entries": _serialize(entries)})
    except Exception as e:
        return tool_error(f"memory_recent failed: {type(e).__name__}: {e}")