217 lines
8.7 KiB
Python
217 lines
8.7 KiB
Python
"""
|
||
title: Qortal API Toolkit
|
||
author: crowetic (with assistance from chatgpt)
|
||
git_url: https://gitea.qortal.link/crowetic/AI-Dev
|
||
version: 0.3.0
|
||
license: MIT
|
||
description: Query any Qortal Core HTTP endpoint directly from Open WebUI.
|
||
|
||
HOW-TO
|
||
------
|
||
1. Add this in 'functions' to create the tool function
|
||
2. Add the tool to your model
|
||
3. In any model/preset: *Chat → ⚙️ Tools* → enable **Qortal API Toolkit**.
|
||
4. Ask something like:
|
||
“Get the balance of address Q...”
|
||
The LLM will auto-call `qortal_get`.
|
||
|
||
________ __ .__ _____ __________.___ _____ __ .__
|
||
\_____ \ ____________/ |______ | | / _ \\______ \ |/ ____\_ __ ____ _____/ |_|__| ____ ____
|
||
/ / \ \ / _ \_ __ \ __\__ \ | | / /_\ \| ___/ \ __\ | \/ \_/ ___\ __\ |/ _ \ / \
|
||
/ \_/. ( <_> ) | \/| | / __ \| |_/ | \ | | || | | | / | \ \___| | | ( <_> ) | \
|
||
\_____\ \_/\____/|__| |__| (____ /____|____|__ /____| |___||__| |____/|___| /\___ >__| |__|\____/|___| /
|
||
\__> \/ \/ \/ \/ \/
|
||
|
||
___. __ .__
|
||
\_ |__ ___.__. /\ ___________ ______ _ __ _____/ |_|__| ____
|
||
| __ < | | \/ _/ ___\_ __ \/ _ \ \/ \/ // __ \ __\ |/ ___\
|
||
| \_\ \___ | /\ \ \___| | \( <_> ) /\ ___/| | | \ \___
|
||
|___ / ____| \/ \___ >__| \____/ \/\_/ \___ >__| |__|\___ >
|
||
\/\/ \/ \/ \/
|
||
"""
|
||
|
||
import os, json, requests, asyncio
|
||
from typing import Dict, Any, Optional, Callable
|
||
from pydantic import BaseModel, Field
|
||
|
||
|
||
# ╭─────────────────────────── helpers ───────────────────────────╮
|
||
class _EventEmitter:
|
||
def __init__(self, cb: Callable[[dict], Any] | None):
|
||
self.cb = cb
|
||
|
||
async def emit(self, description, status="in_progress", done=False):
|
||
if self.cb:
|
||
await self.cb(
|
||
{
|
||
"type": "status",
|
||
"data": {
|
||
"status": status,
|
||
"description": description,
|
||
"done": done,
|
||
},
|
||
}
|
||
)
|
||
|
||
|
||
# ╭─────────────────────────── plugin ────────────────────────────╮
|
||
class Tools:
|
||
# ─── user-visible knobs ──────────────────────────────────────
|
||
class Valves(BaseModel):
|
||
QORTAL_URL: str = Field(
|
||
default=os.getenv("QORTAL_API_URL", "https://api.qortal.org"),
|
||
description="Base URL of your Qortal node (http[s]://host:port)",
|
||
)
|
||
OPENAPI_URL: str = Field(
|
||
default=os.getenv("QORTAL_OPENAPI_URL", ""),
|
||
description="Custom location of openapi.json (leave blank for <QORTAL_URL>/openapi.json)",
|
||
)
|
||
HTTP_TIMEOUT: int = Field(default=30, description="Request timeout (seconds)")
|
||
ALLOW_POST: bool = Field(
|
||
default=False,
|
||
description="Enable POST endpoints (requires unlocked API on the node)",
|
||
)
|
||
|
||
def __init__(self):
|
||
self.valves = self.Valves()
|
||
self._openapi_cache: Optional[Dict[str, Any]] = None
|
||
self.headers = {
|
||
"User-Agent": "Open-WebUI Qortal API Toolkit (+https://qortal.org)"
|
||
}
|
||
|
||
# ─── public async methods (tool functions) ───────────────────
|
||
async def qortal_get(
|
||
self,
|
||
endpoint: str,
|
||
path_params: Dict[str, str] | None = None,
|
||
query_params: Dict[str, str] | None = None,
|
||
__event_emitter__: Callable[[dict], Any] | None = None,
|
||
) -> str:
|
||
"""
|
||
Perform a validated **GET** request to the node.
|
||
|
||
• endpoint – e.g. "/addresses/balance/{address}"
|
||
• path_params – dict that fills the {tokens}
|
||
• query_params – optional ?key=value pairs
|
||
"""
|
||
emitter = _EventEmitter(__event_emitter__)
|
||
await emitter.emit(f"GET {endpoint}")
|
||
|
||
if not await self._is_valid_get(endpoint):
|
||
await emitter.emit(
|
||
f"Endpoint '{endpoint}' is not a valid GET per node spec", "error", True
|
||
)
|
||
return json.dumps({"error": "invalid_endpoint"})
|
||
|
||
return await self._do_request(
|
||
"GET", endpoint, path_params, query_params, None, emitter
|
||
)
|
||
|
||
async def qortal_post(
|
||
self,
|
||
endpoint: str,
|
||
path_params: Dict[str, str] | None = None,
|
||
json_body: Dict[str, Any] | None = None,
|
||
__event_emitter__: Callable[[dict], Any] | None = None,
|
||
) -> str:
|
||
"""
|
||
Perform a **POST** request (requires ALLOW_POST = true).
|
||
|
||
• endpoint – e.g. "/arbitrary/publish"
|
||
• path_params – dict that fills the {tokens}
|
||
• json_body – payload sent as JSON
|
||
"""
|
||
emitter = _EventEmitter(__event_emitter__)
|
||
await emitter.emit(f"POST {endpoint}")
|
||
|
||
if not self.valves.ALLOW_POST:
|
||
await emitter.emit(
|
||
"POST disabled in valves; set ALLOW_POST = true to enable",
|
||
"error",
|
||
True,
|
||
)
|
||
return json.dumps({"error": "post_disabled"})
|
||
|
||
return await self._do_request(
|
||
"POST", endpoint, path_params, None, json_body, emitter
|
||
)
|
||
|
||
# ╭──────────────────── internal plumbing ───────────────────╮
|
||
async def _do_request(
|
||
self,
|
||
method: str,
|
||
endpoint: str,
|
||
path_params: Dict[str, Any] | None,
|
||
query_params: Dict[str, Any] | None,
|
||
json_body: Dict[str, Any] | None,
|
||
emitter: _EventEmitter,
|
||
) -> str:
|
||
url = self._build_url(endpoint, path_params)
|
||
|
||
try:
|
||
resp = requests.request(
|
||
method=method,
|
||
url=url,
|
||
params=query_params,
|
||
json=json_body,
|
||
headers=self.headers,
|
||
timeout=self.valves.HTTP_TIMEOUT,
|
||
)
|
||
data: Any
|
||
try:
|
||
data = resp.json()
|
||
except ValueError:
|
||
data = resp.text
|
||
|
||
await emitter.emit(
|
||
f"{method} {endpoint} → {resp.status_code}", "complete", True
|
||
)
|
||
return json.dumps(
|
||
{
|
||
"success": resp.ok,
|
||
"status_code": resp.status_code,
|
||
"url": resp.url,
|
||
"data": data,
|
||
},
|
||
ensure_ascii=False,
|
||
)
|
||
|
||
except Exception as e:
|
||
await emitter.emit(f"Request error: {e}", "error", True)
|
||
return json.dumps({"success": False, "error": str(e)})
|
||
|
||
# ─── spec helpers ───────────────────────────────────────────
|
||
async def _is_valid_get(self, endpoint: str) -> bool:
|
||
endpoint = "/" + endpoint.lstrip("/")
|
||
return endpoint in await self._valid_get_list()
|
||
|
||
async def _valid_get_list(self):
|
||
spec = await self._load_openapi()
|
||
return [
|
||
p for p, verbs in spec.get("paths", {}).items() if "get" in verbs
|
||
]
|
||
|
||
async def _load_openapi(self):
|
||
if self._openapi_cache is not None:
|
||
return self._openapi_cache
|
||
|
||
url = (
|
||
self.valves.OPENAPI_URL
|
||
or f"{self.valves.QORTAL_URL.rstrip('/')}/openapi.json"
|
||
)
|
||
try:
|
||
resp = requests.get(url, headers=self.headers, timeout=self.valves.HTTP_TIMEOUT)
|
||
resp.raise_for_status()
|
||
self._openapi_cache = resp.json()
|
||
except Exception:
|
||
self._openapi_cache = {}
|
||
return self._openapi_cache
|
||
|
||
# ─── misc helpers ───────────────────────────────────────────
|
||
def _build_url(self, endpoint: str, path_params: Dict[str, Any] | None):
|
||
ep = "/" + endpoint.lstrip("/")
|
||
if path_params:
|
||
for k, v in path_params.items():
|
||
ep = ep.replace("{" + k + "}", str(v))
|
||
return self.valves.QORTAL_URL.rstrip("/") + ep
|