"""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