loopable / api /assistant_worklists.py
fsanyoto's picture
Deploy AIOS web (React glide grid + FastAPI slice)
7ce703c verified
Raw History Blame Contribute Delete
10.2 kB
"""Store owner-bound worklist snapshots as tenant-scoped JSON blobs."""
import copy
import datetime
import importlib
import json
import math
import re
import secrets
import time
from urllib.parse import urlsplit
import assistant_artifacts
import assistant_log
COLUMN_TYPES = {"text", "number", "money", "date", "link"}
_WORKLIST_ID = re.compile(r"[0-9a-f]{32}")
def _https(value):
if not isinstance(value, str) or not value or any(c.isspace() or ord(c) < 32 for c in value):
raise ValueError("A worklist link must be an absolute HTTPS URL.")
try:
parsed = urlsplit(value)
port = parsed.port
if (parsed.scheme != "https" or not parsed.hostname or not parsed.netloc
or parsed.username is not None or parsed.password is not None or "\\" in value
or port == 0):
raise ValueError
except ValueError as exc:
raise ValueError("A worklist link must be an absolute HTTPS URL.") from exc
return value
def _links():
try:
return importlib.import_module("loopy_links")
except ModuleNotFoundError as exc:
if exc.name != "loopy_links":
raise
raise ValueError("A secure public link is not configured.") from exc
def _principal(session):
rt = getattr(session, "runtime", None)
username = getattr(session, "uname", None)
if rt is None or not isinstance(username, str) or not username.strip():
raise ValueError("A worklist needs an authenticated owner session.")
if getattr(session, "tenant", None) != assistant_log._tenant_of(rt):
raise ValueError("A worklist needs its owner's tenant runtime.")
return rt, username, assistant_log._hash(rt, username)
def _contains_rows(value):
if isinstance(value, dict):
return "rows" in value or any(_contains_rows(v) for v in value.values())
if isinstance(value, (list, tuple)):
return any(_contains_rows(v) for v in value)
return False
def _provenance(session, tool_call):
if tool_call is None:
tool_call = getattr(session, "tool_call", None)
if tool_call is None:
tool_call = getattr(session, "_tool_call", None)
if (not isinstance(tool_call, dict) or not isinstance(tool_call.get("name"), str)
or not tool_call["name"].strip() or not isinstance(tool_call.get("args"), dict)):
raise ValueError("A worklist needs its producing tool and source arguments.")
if _contains_rows(tool_call["args"]):
raise ValueError("Worklist replay arguments must not contain stored rows.")
call = {"name": tool_call["name"], "args": copy.deepcopy(tool_call["args"])}
json.dumps(call, allow_nan=False)
return call
def _cell(kind, value):
if value is None:
return
if kind == "link":
if value != "":
_https(value)
elif kind in ("number", "money"):
if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value):
raise ValueError("A numeric worklist cell needs a finite number.")
elif not isinstance(value, str):
raise ValueError("A text or date worklist cell needs text.")
elif kind == "date" and value:
try:
datetime.datetime.fromisoformat(value.replace("Z", "+00:00"))
except ValueError as exc:
raise ValueError("A worklist date needs an ISO date or timestamp.") from exc
def _table(columns, rows):
if not isinstance(columns, list) or not columns or not isinstance(rows, list):
raise ValueError("A worklist needs columns and a list of rows.")
keys = []
for column in columns:
if (not isinstance(column, dict) or not isinstance(column.get("key"), str)
or not column["key"].strip() or column["key"] in keys
or not isinstance(column.get("label"), str) or not column["label"].strip()
or not isinstance(column.get("type"), str) or column["type"] not in COLUMN_TYPES):
raise ValueError("A worklist column needs a unique key, label, and supported type.")
keys.append(column["key"])
for row in rows:
if isinstance(row, dict) and set(row) == set(keys):
cells = [row[key] for key in keys]
elif isinstance(row, (list, tuple)) and len(row) == len(keys):
cells = row
else:
raise ValueError("A worklist row must match its columns.")
for column, value in zip(columns, cells):
_cell(column["type"], value)
def _checks(validation, resolve):
if not isinstance(validation, list):
raise ValueError("A worklist needs a list of validation checks.")
for check in validation:
if (not isinstance(check, dict) or set(check) != {"check", "a", "b", "ok"}
or not isinstance(check["check"], str) or not check["check"].strip()
or not isinstance(check["ok"], bool)):
raise ValueError("A validation check needs check, a, b, and a boolean ok.")
if (not isinstance(resolve, dict) or set(resolve) != {"label", "href"}
or not isinstance(resolve["label"], str) or not resolve["label"].strip()):
raise ValueError("A worklist needs a resolution label and link.")
_https(resolve["href"])
def _key(worklist_id):
return f"assistant_worklist_{worklist_id}"
def _path(item):
return f"assistant_worklists/{item['ownerHash']}/{item['id']}.json"
def save(session, title, columns, rows, validation, resolve, *, tool_call=None, door=None):
"""Save all rows and one report artifact with the original producing tool's provenance."""
rt, username, h = _principal(session)
if not all(callable(getattr(rt, name, None)) for name in ("get", "update", "upload_bytes", "download_bytes")):
raise RuntimeError("Worklist storage is not available in this workspace.")
if not isinstance(title, str) or not title.strip():
raise ValueError("A worklist needs a title.")
call = _provenance(session, tool_call)
door = door if door is not None else (getattr(session, "door", None) or getattr(session, "_door", None) or "app")
if not isinstance(door, str) or door not in assistant_artifacts.DOORS:
raise ValueError("That worklist door is not available.")
_table(columns, rows)
_checks(validation, resolve)
links = _links()
_https(links.app_link("#/artifacts"))
from routes_query import _no_dashes
title = _no_dashes(title).strip()[:200]
worklist_id = secrets.token_hex(16)
built_at = assistant_artifacts.timestamp(time.time())
payload = {"title": title, "columns": columns, "rows": rows, "total": len(rows),
"validation": validation, "resolve": resolve, "builtAt": built_at}
data = json.dumps(payload, ensure_ascii=False, allow_nan=False, separators=(",", ":")).encode("utf-8")
item = {"version": 1, "id": worklist_id, "owner": username, "ownerHash": h,
"tenant": session.tenant, "total": len(rows), "size": len(data), "builtAt": built_at}
rt.upload_bytes(_path(item), data, message="Save assistant worklist")
import agent_runtime
sources = agent_runtime.producing_turn_sources(session)
item["artifactId"] = assistant_artifacts.record(rt, username, {
"kind": "report", "ref": worklist_id, "title": title, "door": door,
"toolCall": call, "createdAt": built_at, "frozen_at": built_at, "sources": sources})
rt.update(_key(worklist_id), lambda _raw: copy.deepcopy(item), flush="sync")
return {"id": worklist_id, "link": _https(links.artifact_link(item["artifactId"]))}
def owned_artifact(rt, username, row):
"""Validate an active report against its immutable owner-bound worklist metadata."""
if (not isinstance(row, dict) or row.get("kind") != "report" or row.get("status") != "active"
or (row.get("toolCall") or {}).get("name") not in {"build_chase_list", "build_contact_worklist"}):
return None
item = metadata(rt, row.get("ref"))
if (item is None or item["owner"] != username
or item["ownerHash"] != assistant_log._hash(rt, username)
or item["artifactId"] != row.get("id") or item["builtAt"] != row.get("createdAt")
or row.get("frozen_at", item["builtAt"]) != item["builtAt"]):
return None
return item
def metadata(rt, worklist_id):
"""Read tenant metadata without granting the caller ownership."""
if not isinstance(worklist_id, str) or not _WORKLIST_ID.fullmatch(worklist_id):
return None
item = rt.get(_key(worklist_id))
if (not isinstance(item, dict) or item.get("id") != worklist_id
or item.get("tenant") != assistant_log._tenant_of(rt)
or not isinstance(item.get("owner"), str) or not item["owner"]
or item.get("ownerHash") != assistant_log._hash(rt, item["owner"])
or any(type(item.get(k)) is not int or item[k] < 0 for k in ("total", "size"))
or not isinstance(item.get("builtAt"), str) or not isinstance(item.get("artifactId"), str)):
return None
return copy.deepcopy(item)
def read_page(rt, item, *, offset=0, limit=200):
"""Read a page only after the route has authorized the owner metadata."""
if type(offset) is not int or type(limit) is not int or offset < 0 or limit < 1:
raise ValueError("A worklist page needs a nonnegative offset and positive limit.")
data = rt.download_bytes(_path(item))
if data is None:
return None
if not isinstance(data, (bytes, bytearray, memoryview)) or len(data) != item["size"]:
raise RuntimeError("This worklist could not be read.")
payload = json.loads(bytes(data))
if (not isinstance(payload, dict)
or set(payload) != {"title", "columns", "rows", "total", "validation", "resolve", "builtAt"}
or not isinstance(payload["rows"], list) or len(payload["rows"]) != item["total"]
or payload["total"] != item["total"] or payload["builtAt"] != item["builtAt"]):
raise RuntimeError("This worklist could not be read.")
payload["rows"] = payload["rows"][offset:offset + limit]
return payload