File size: 13,480 Bytes

fbf3c28

#!/usr/bin/env python3
from fastapi import FastAPI
from pydantic import BaseModel, Field
from typing import List, Optional, Dict, Any
import os, json
import requests
import base64
import threading

app = FastAPI(title="Nova Tools Server", version="0.1.0")

# Feature Flags (controlled by environment variables)
ENABLE_NATS = os.getenv("ENABLE_NATS", "1") == "1"
ENABLE_QDRANT = os.getenv("ENABLE_QDRANT", "1") == "1"
ENABLE_REDIS = os.getenv("ENABLE_REDIS", "1") == "1"
ENABLE_EMBED = os.getenv("ENABLE_EMBED", "1") == "1"
ENABLE_BROWSER = os.getenv("ENABLE_BROWSER", "1") == "1"

# --------- Models ---------
class BusPublishBody(BaseModel):
    subject: str
    message: str
    url: Optional[str] = None


class KVBody(BaseModel):
    key: str
    value: Optional[str] = None
    host: str = Field(default="127.0.0.1")
    port: int = Field(default=18010) # Changed from 18000 to 18010


class QdrantEnsureBody(BaseModel):
    collection: str
    size: int
    distance: str = Field(default="Cosine")
    url: str = Field(default_factory=lambda: os.getenv("QDRANT_URL", "http://127.0.0.1:17000"))


class QdrantUpsertBody(BaseModel):
    collection: str
    points: List[Dict[str, Any]]
    url: str = Field(default_factory=lambda: os.getenv("QDRANT_URL", "http://127.0.0.1:17000"))


class QdrantQueryBody(BaseModel):
    collection: str
    vector: List[float]
    top: int = 5
    url: str = Field(default_factory=lambda: os.getenv("QDRANT_URL", "http://127.0.0.1:17000"))


class EmbedBody(BaseModel):
    texts: List[str]
    model: str = Field(default_factory=lambda: os.getenv("EMBED_MODEL", "BAAI/bge-m3"))
    api_base: str = Field(default_factory=lambda: os.getenv("EMBED_API_BASE", "http://127.0.0.1:17592/v1"))
    local: bool = Field(default_factory=lambda: os.getenv("EMBED_LOCAL", "0") == "1")


# --------- Endpoints ---------
if ENABLE_NATS:
    @app.post("/bus/publish")
    def bus_publish(body: BusPublishBody):
        import asyncio
        try:
            import nats  # type: ignore
        except Exception as e:
            return {"ok": False, "error": f"nats-py not installed: {e}"}

        async def _run():
            url = body.url or os.getenv("NATS_URL", "nats://127.0.0.1:18222")
            nc = await nats.connect(url)
            await nc.publish(body.subject, body.message.encode("utf-8"))
            await nc.flush()
            await nc.close()
            return {"ok": True}

        return asyncio.run(_run())

if ENABLE_REDIS:
    @app.post("/kv/set")
    def kv_set(body: KVBody):
        try:
            import redis  # type: ignore
        except Exception as e:
            return {"ok": False, "error": f"redis not installed: {e}"}
        try:
            r = redis.Redis(host=body.host, port=body.port, decode_responses=True)
            r.set(body.key, body.value or "")
            return {"ok": True}
        except Exception as e:
            return {"ok": False, "error": str(e)}


    @app.post("/kv/get")
    def kv_get(body: KVBody):
        try:
            import redis  # type: ignore
        except Exception as e:
            return {"ok": False, "error": f"redis not installed: {e}"}
        try:
            r = redis.Redis(host=body.host, port=body.port, decode_responses=True)
            v = r.get(body.key)
            return {"ok": True, "value": v}
        except Exception as e:
            return {"ok": False, "error": str(e)}


    @app.post("/kv/delete")
    def kv_delete(body: KVBody):
        try:
            import redis  # type: ignore
        except Exception as e:
            return {"ok": False, "error": f"redis not installed: {e}"}
        try:
            r = redis.Redis(host=body.host, port=body.port, decode_responses=True)
            r.delete(body.key)
            return {"ok": True}
        except Exception as e:
            return {"ok": False, "error": str(e)}

if ENABLE_QDRANT:
    @app.post("/qdrant/ensure")
    def qdrant_ensure(body: QdrantEnsureBody):
        payload = {"vectors": {"size": body.size, "distance": body.distance}, "optimizers_config": {"default_segment_number": 1}}
        r = requests.put(f"{body.url}/collections/{body.collection}", json=payload, timeout=10)
        return {"status": r.status_code, "data": r.json() if r.content else None}


    @app.post("/qdrant/upsert")
    def qdrant_upsert(body: QdrantUpsertBody):
        r = requests.put(f"{body.url}/collections/{body.collection}/points", params={"wait": "true"}, json={"points": body.points}, timeout=15)
        return {"status": r.status_code, "data": r.json() if r.content else None}


    @app.post("/qdrant/query")
    def qdrant_query(body: QdrantQueryBody):
        r = requests.post(f"{body.url}/collections/{body.collection}/points/search", json={"vector": body.vector, "limit": body.top}, timeout=10)
        return {"status": r.status_code, "data": r.json() if r.content else None}

# Note: The /embed endpoint may fail due to permission issues when downloading models.
# This is a host system configuration issue and cannot be fixed by the tools server.
if ENABLE_EMBED:
    @app.post("/embed")
    def embed(body: EmbedBody):
        if not body.local:
            url = f"{body.api_base}/embeddings"
            req = {"model": body.model, "input": body.texts}
            try:
                resp = requests.post(url, json=req, timeout=30)
                j = resp.json()
                if resp.status_code == 200 and "data" in j:
                    vecs = [d.get("embedding") for d in j["data"]]
                    return {"ok": True, "embeddings": vecs}
                # fallthrough to local if API not ready
            except Exception:
                pass

        # Local fallback via sentence-transformers
        try:
            from sentence_transformers import SentenceTransformer
            device = os.getenv("EMBED_DEVICE", "cpu")
            model = SentenceTransformer(body.model, device=device)
            vecs = model.encode(body.texts, normalize_embeddings=True).tolist()
            return {"ok": True, "embeddings": vecs}
        except Exception as e:
            return {"ok": False, "error": f"local embed failed: {e}"}


    class MemoryUpsertBody(BaseModel):
        collection: str
        items: List[Dict[str, Any]]  # each: {id: str, text: str, payload: {...}}
        model: str = Field(default_factory=lambda: os.getenv("EMBED_MODEL", "BAAI/bge-m3"))
        url: str = Field(default_factory=lambda: os.getenv("QDRANT_URL", "http://127.0.0.1:17000"))
        local: bool = Field(default_factory=lambda: os.getenv("EMBED_LOCAL", "1") == "1")


    @app.post("/memory/upsert_text")
    def memory_upsert_text(body: MemoryUpsertBody):
        texts = [it.get("text", "") for it in body.items]
        emb_res = embed(EmbedBody(texts=texts, model=body.model, api_base=os.getenv("EMBED_API_BASE", "http://127.0.0.1:17592/v1"), local=body.local))
        if not emb_res.get("ok"):
            return {"ok": False, "error": emb_res.get("error")}
        vecs = emb_res.get("embeddings", [])
        points = []
        for it, v in zip(body.items, vecs):
            points.append({"id": it.get("id"), "vector": v, "payload": it.get("payload", {})})
        up = requests.put(f"{body.url}/collections/{body.collection}/points", params={"wait": "true"}, json={"points": points}, timeout=15)
        try:
            data = up.json()
        except Exception:
            data = None
        return {"ok": up.status_code == 200, "status": up.status_code, "data": data}


    class MemorySearchBody(BaseModel):
        collection: str
        text: str
        top: int = 5
        model: str = Field(default_factory=lambda: os.getenv("EMBED_MODEL", "BAAI/bge-m3"))
        url: str = Field(default_factory=lambda: os.getenv("QDRANT_URL", "http://127.0.0.1:17000"))
        local: bool = Field(default_factory=lambda: os.getenv("EMBED_LOCAL", "1") == "1")


    @app.post("/memory/search_text")
    def memory_search_text(body: MemorySearchBody):
        """
        Embed the input text and perform a nearest-neighbor search in Qdrant.
        Returns the raw Qdrant response including payloads when available.
        """
        # Get embedding for the query text
        emb_res = embed(EmbedBody(texts=[body.text], model=body.model, api_base=os.getenv("EMBED_API_BASE", "http://127.0.0.1:17592/v1"), local=body.local))
        if not emb_res.get("ok"):
            return {"ok": False, "error": emb_res.get("error", "embed failed")}
        vecs = emb_res.get("embeddings", [])
        if not vecs:
            return {"ok": False, "error": "no embedding produced"}
        vector = vecs[0]

        # Perform search against Qdrant
        try:
            resp = requests.post(
                f"{body.url}/collections/{body.collection}/points/search",
                json={"vector": vector, "limit": body.top, "with_payload": True, "with_vectors": False},
                timeout=15,
            )
            data = resp.json() if resp.content else None
            return {"ok": resp.status_code == 200, "status": resp.status_code, "data": data}
        except Exception as e:
            return {"ok": False, "error": str(e)}

if ENABLE_BROWSER:
    # --------------- Playwright MCP-like endpoints ---------------
    _BROWSER_LOCK = threading.Lock()
    _SESSIONS: Dict[str, Dict[str, Any]] = {}


    class BrowserStartBody(BaseModel):
        headless: bool = True
        slow_mo_ms: int = 0


    class BrowserSession(BaseModel):
        session_id: str


    @app.post("/browser/start", response_model=BrowserSession)
    def browser_start(body: BrowserStartBody):
        try:
            from playwright.sync_api import sync_playwright  # type: ignore
        except Exception as e:
            return {"session_id": "", "error": f"playwright not installed: {e}"}

        with _BROWSER_LOCK:
            p = sync_playwright().start()
            browser = p.chromium.launch(headless=body.headless, slow_mo=body.slow_mo_ms or 0)
            context = browser.new_context()
            page = context.new_page()
            sid = f"sess_{len(_SESSIONS)+1}"
            _SESSIONS[sid] = {"p": p, "browser": browser, "context": context, "page": page}
            return {"session_id": sid}


    class BrowserNavBody(BaseModel):
        session_id: str
        url: str
        wait_selector: Optional[str] = None
        timeout_ms: int = 10000


    @app.post("/browser/goto")
    def browser_goto(body: BrowserNavBody):
        s = _SESSIONS.get(body.session_id)
        if not s:
            return {"ok": False, "error": "invalid session"}
        page = s["page"]
        page.goto(body.url, timeout=body.timeout_ms)
        if body.wait_selector:
            page.wait_for_selector(body.wait_selector, timeout=body.timeout_ms)
        return {"ok": True, "url": page.url}


    class BrowserQueryBody(BaseModel):
        session_id: str
        selector: str
        attr: Optional[str] = None
        all: bool = True
        timeout_ms: int = 5000


    @app.post("/browser/query")
    def browser_query(body: BrowserQueryBody):
        s = _SESSIONS.get(body.session_id)
        if not s:
            return {"ok": False, "error": "invalid session"}
        page = s["page"]
        page.wait_for_selector(body.selector, timeout=body.timeout_ms)
        if body.all:
            els = page.query_selector_all(body.selector)
        else:
            el = page.query_selector(body.selector)
            els = [el] if el else []
        out = []
        for el in els:
            if not el:
                continue
            if body.attr:
                out.append(el.get_attribute(body.attr))
            else:
                try:
                    out.append(el.inner_text())
                except Exception:
                    out.append(el.text_content())
        return {"ok": True, "values": out}


    class BrowserClickBody(BaseModel):
        session_id: str
        selector: str
        timeout_ms: int = 5000


    @app.post("/browser/click")
    def browser_click(body: BrowserClickBody):
        s = _SESSIONS.get(body.session_id)
        if not s:
            return {"ok": False, "error": "invalid session"}
        page = s["page"]
        page.wait_for_selector(body.selector, timeout=body.timeout_ms)
        page.click(body.selector, timeout=body.timeout_ms)
        return {"ok": True}


    class BrowserScreenshotBody(BaseModel):
        session_id: str
        full_page: bool = False


    @app.post("/browser/screenshot")
    def browser_screenshot(body: BrowserScreenshotBody):
        s = _SESSIONS.get(body.session_id)
        if not s:
            return {"ok": False, "error": "invalid session"}
        page = s["page"]
        buf = page.screenshot(full_page=body.full_page)
        b64 = base64.b64encode(buf).decode("ascii")
        return {"ok": True, "image_base64": b64}


    class BrowserCloseBody(BaseModel):
        session_id: str


    @app.post("/browser/close")
    def browser_close(body: BrowserCloseBody):
        s = _SESSIONS.pop(body.session_id, None)
        if not s:
            return {"ok": True}
        try:
            s["browser"].close()
        except Exception:
            pass
        try:
            s["p"].stop()
        except Exception:
            pass
        return {"ok": True}


if __name__ == "__main__":
    import uvicorn
    port = int(os.getenv("TOOLS_SERVER_PORT", "18190"))
    uvicorn.run(app, host="127.0.0.1", port=port)