Act on Each Verdict

curl -X POST "https://api.zerodrift.ai/api/v3/content/validate" \
  -H "x-api-key: $ZERODRIFT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "Our fund guarantees 20% returns with zero risk!",
    "model_engine": "anchor_3_0",
    "mode": "sync"
  }'

import os
import time
import logging
from dataclasses import dataclass

import requests

API = "https://api.zerodrift.ai"
HEADERS = {"x-api-key": os.environ["ZERODRIFT_API_KEY"]}
NUMERIC_THRESHOLD = 0.85
TERMINAL = {"completed", "done", "failed"}


@dataclass
class Outcome:
    verdict: str  # "pass" | "fix" | "block" | "escalate"
    text: str | None
    rules: list[str]


def payload(job: dict) -> dict:
    inner = job.get("result")
    return inner if isinstance(inner, dict) else job


def confident(value) -> bool:
    if isinstance(value, str):
        return value == "high"
    try:
        return float(value) >= NUMERIC_THRESHOLD
    except (TypeError, ValueError):
        return False


def wait_for_job(poll_url: str, timeout_s: int = 180) -> dict:
    delay, waited = 1.0, 0.0
    while waited < timeout_s:
        r = requests.get(f"{API}{poll_url}", headers=HEADERS, timeout=10)
        r.raise_for_status()
        job = r.json()
        if job["status"] in TERMINAL:
            if job["status"] == "failed":
                raise RuntimeError(job.get("error", "enforcement failed"))
            return job
        time.sleep(delay)
        waited += delay
        delay = min(delay * 2, 5.0)
    raise TimeoutError(poll_url)


def violations_of(job: dict) -> list[dict]:
    body = payload(job)
    return body.get("violations_by_line") or body.get("violations") or []


def rule_label(entry: dict) -> str | None:
    return (
        entry.get("rule_ref")
        or entry.get("rule_id")
        or entry.get("signal_name")
        or entry.get("rule_name")
    )


def collect_rules(job: dict) -> list[str]:
    labels = set()
    for v in violations_of(job):
        if v.get("rules_violated"):
            for rv in v["rules_violated"]:
                if rule_label(rv):
                    labels.add(rule_label(rv))
        elif rule_label(v):
            labels.add(rule_label(v))
    return sorted(labels)


def apply_fixes(content: str, job: dict) -> str | None:
    items = violations_of(job)
    if not items:
        return None
    text = content
    for v in items:
        fix = v.get("best_fix") or v.get("fix") or {}
        action = fix.get("action") or "replace"
        suggested = fix.get("suggested_text")
        conf = fix.get("confidence", v.get("confidence"))
        if action != "replace" or not suggested or not confident(conf):
            return None
        if "line_number" in v:
            lines = text.split("\n")
            lines[v["line_number"] - 1] = suggested
            text = "\n".join(lines)
        else:
            quote = v.get("quote") or v.get("line_text")
            if not quote or quote not in text:
                return None
            text = text.replace(quote, suggested)
    return text


def enforce(
    content: str,
    *,
    scenario: str | None = None,
    scope: dict | None = None,
    meta: dict | None = None,
) -> Outcome:
    body = {
        "content": content,
        "model_engine": "anchor_3_0",
        "mode": "sync",
    }
    if scenario:
        body["document_category"] = scenario
    if scope:
        body["validation_scope"] = scope
    if meta:
        body["metadata"] = meta

    r = requests.post(
        f"{API}/api/v3/content/validate",
        headers=HEADERS,
        json=body,
        timeout=30,
    )
    r.raise_for_status()
    job = r.json()
    if job.get("mode") == "async":
        job = wait_for_job(job["poll"]["url"])

    rules = collect_rules(job)
    status = payload(job).get("overall_status")

    if status == "approved":
        return Outcome("pass", content, rules)
    if status == "do not send":
        logging.warning("blocked job=%s rules=%s", job.get("job_id"), rules)
        return Outcome("block", None, rules)

    fixed = apply_fixes(content, job)
    if fixed is None:
        return Outcome("escalate", None, rules)
    return Outcome("fix", fixed, rules)


outcome = enforce("Our fund guarantees 20% returns with zero risk!")
print(outcome)

type Verdict = "pass" | "fix" | "block" | "escalate";

export interface Outcome {
  verdict: Verdict;
  text: string | null;
  rules: string[];
}

const API = "https://api.zerodrift.ai";
const HEADERS = {
  "x-api-key": process.env.ZERODRIFT_API_KEY!,
  "Content-Type": "application/json",
};
const NUMERIC_THRESHOLD = 0.85;
const TERMINAL = new Set(["completed", "done", "failed"]);

function payload(job: any) {
  return job?.result && typeof job.result === "object" ? job.result : job;
}

function confident(value: unknown) {
  if (typeof value === "string") return value === "high";
  const n = Number(value);
  return Number.isFinite(n) && n >= NUMERIC_THRESHOLD;
}

export async function waitForJob(pollUrl: string, timeoutMs = 180_000) {
  let delay = 1000;
  let waited = 0;
  while (waited < timeoutMs) {
    const r = await fetch(`${API}${pollUrl}`, { headers: HEADERS });
    if (!r.ok) throw new Error(`ZeroDrift ${r.status}`);
    const job = await r.json();
    if (job.status === "failed") throw new Error(job.error ?? "enforcement failed");
    if (TERMINAL.has(job.status)) return job;
    await new Promise((res) => setTimeout(res, delay));
    waited += delay;
    delay = Math.min(delay * 2, 5000);
  }
  throw new Error(`timeout ${pollUrl}`);
}

function violationsOf(job: any): any[] {
  const body = payload(job);
  return body.violations_by_line ?? body.violations ?? [];
}

function ruleLabel(entry: any): string | undefined {
  return entry?.rule_ref || entry?.rule_id || entry?.signal_name || entry?.rule_name;
}

function collectRules(job: any): string[] {
  const labels = new Set<string>();
  for (const v of violationsOf(job)) {
    if (v.rules_violated) {
      for (const rv of v.rules_violated) {
        const label = ruleLabel(rv);
        if (label) labels.add(label);
      }
    } else {
      const label = ruleLabel(v);
      if (label) labels.add(label);
    }
  }
  return [...labels].sort();
}

function applyFixes(content: string, job: any): string | null {
  const items = violationsOf(job);
  if (!items.length) return null;
  let text = content;
  for (const v of items) {
    const fix = v.best_fix ?? v.fix ?? {};
    const action = fix.action ?? "replace";
    const suggested = fix.suggested_text;
    const conf = fix.confidence ?? v.confidence;
    if (action !== "replace" || !suggested || !confident(conf)) return null;
    if (v.line_number != null) {
      const lines = text.split("\n");
      lines[v.line_number - 1] = suggested;
      text = lines.join("\n");
    } else {
      const quote = v.quote ?? v.line_text;
      if (!quote || !text.includes(quote)) return null;
      text = text.replaceAll(quote, suggested);
    }
  }
  return text;
}

export async function enforce(
  content: string,
  opts: { scenario?: string; scope?: object; meta?: object } = {},
): Promise<Outcome> {
  const body: Record<string, unknown> = {
    content,
    model_engine: "anchor_3_0",
    mode: "sync",
  };
  if (opts.scenario) body.document_category = opts.scenario;
  if (opts.scope) body.validation_scope = opts.scope;
  if (opts.meta) body.metadata = opts.meta;

  const r = await fetch(`${API}/api/v3/content/validate`, {
    method: "POST",
    headers: HEADERS,
    body: JSON.stringify(body),
  });
  if (!r.ok) throw new Error(`ZeroDrift ${r.status}`);
  let job = await r.json();
  if (job.mode === "async") job = await waitForJob(job.poll.url);

  const rules = collectRules(job);
  const status = payload(job).overall_status;

  if (status === "approved") return { verdict: "pass", text: content, rules };
  if (status === "do not send") return { verdict: "block", text: null, rules };

  const fixed = applyFixes(content, job);
  if (fixed == null) return { verdict: "escalate", text: null, rules };
  return { verdict: "fix", text: fixed, rules };
}

const outcome = await enforce("Our fund guarantees 20% returns with zero risk!");
console.log(outcome);