platform/aiml/mlops/agent_tools/tools_data.py

from __future__ import annotations

import json
import os
from typing import Any, Dict

from .registry import ToolRegistry


def _redis_client():
    try:
        import redis  # type: ignore
    except Exception as e:  # pragma: no cover
        return None, f"redis module not available: {e}"
    url = os.getenv("DFLY_URL") or os.getenv("REDIS_URL", "redis://localhost:6379/0")
    try:
        r = redis.from_url(url)
        r.ping()
        return r, None
    except Exception as e:  # pragma: no cover
        return None, str(e)


def _pg_conn():
    try:
        import psycopg2  # type: ignore
    except Exception as e:  # pragma: no cover
        return None, f"psycopg2 not available: {e}"
    dsn = os.getenv("POSTGRES_DSN", "postgresql://postgres:postgres@localhost:5432/elizabeth")
    try:
        conn = psycopg2.connect(dsn)
        return conn, None
    except Exception as e:  # pragma: no cover
        return None, str(e)


def t_redis_set(args: Dict[str, Any]) -> str:
    r, err = _redis_client()
    if err:
        return json.dumps({"error": err})
    key = args.get("key")
    val = args.get("value")
    if not key:
        return json.dumps({"error": "key required"})
    r.set(str(key), str(val))
    return json.dumps({"status": "ok"})


def t_redis_get(args: Dict[str, Any]) -> str:
    r, err = _redis_client()
    if err:
        return json.dumps({"error": err})
    key = args.get("key")
    if not key:
        return json.dumps({"error": "key required"})
    v = r.get(str(key))
    if isinstance(v, (bytes, bytearray)):
        v = v.decode()
    return json.dumps({"value": v})


def t_pg_query(args: Dict[str, Any]) -> str:
    conn, err = _pg_conn()
    if err:
        return json.dumps({"error": err})
    query = args.get("query")
    if not query or not isinstance(query, str):
        return json.dumps({"error": "query required"})
    try:
        with conn:
            with conn.cursor() as cur:
                cur.execute(query)
                try:
                    rows = cur.fetchall()
                except Exception:
                    rows = []
        return json.dumps({"rows": rows[:200]})
    except Exception as e:
        return json.dumps({"error": str(e)})
    finally:
        try:
            conn.close()
        except Exception:
            pass


def register_tools(reg: ToolRegistry) -> None:
    reg.register(
        name="redis_set",
        description="Set a Redis/DragonFly key value.",
        parameters={"type": "object", "properties": {"key": {"type": "string"}, "value": {"type": "string"}}, "required": ["key", "value"]},
        handler=t_redis_set,
    )
    reg.register(
        name="redis_get",
        description="Get a Redis/DragonFly key value.",
        parameters={"type": "object", "properties": {"key": {"type": "string"}}, "required": ["key"]},
        handler=t_redis_get,
    )
    reg.register(
        name="pg_query",
        description="Execute a Postgres query (use with care).",
        parameters={"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]},
        handler=t_pg_query,
    )