System One Examples

import os
import requests

SYSTEM_ONE_URL = "https://platform.ai.gloo.com/ai/v2/systemone"

def ask(state, questions: dict) -> dict:
    resp = requests.post(
        SYSTEM_ONE_URL,
        headers={"Authorization": f"Bearer {os.environ['GLOO_API_KEY']}"},
        json={"state": state, "questions": questions},
        timeout=30,
    )
    if not resp.ok:
        raise RuntimeError(f"System One returned {resp.status_code}: {resp.text}")
    return resp.json()

const SYSTEM_ONE_URL = "https://platform.ai.gloo.com/ai/v2/systemone";

async function ask(state: unknown, questions: Record<string, unknown>): Promise<any> {
  const resp = await fetch(SYSTEM_ONE_URL, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.GLOO_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ state, questions }),
  });
  if (!resp.ok) {
    throw new Error(`System One returned ${resp.status}: ${await resp.text()}`);
  }
  return resp.json();
}

PUBLISH_AT = 0.95  # p(ok) at or above this: publish
HIDE_AT = 0.05     # p(ok) at or below this: hide

def moderate(state: dict, questions: dict) -> dict:
    result = ask(state, questions)
    p_ok = result["answers"]["policy"]["probabilities"].get("ok")
    if p_ok is None:
        return {"action": "moderator"}
    if p_ok >= PUBLISH_AT:
        return {"action": "publish"}
    if p_ok <= HIDE_AT:
        return {"action": "hide", "reason": result["answers"]["policy"]["choice"]}
    return {"action": "moderator"}

const PUBLISH_AT = 0.95; // p(ok) at or above this: publish
const HIDE_AT = 0.05; // p(ok) at or below this: hide

async function moderate(state: unknown, questions: Record<string, unknown>) {
  const result = await ask(state, questions);
  const pOk: number | null = result.answers.policy.probabilities.ok ?? null;
  if (pOk === null) return { action: "moderator" };
  if (pOk >= PUBLISH_AT) return { action: "publish" };
  if (pOk <= HIDE_AT) return { action: "hide", reason: result.answers.policy.choice as string };
  return { action: "moderator" };
}

ROUTE_AT = 0.8

def route(state: dict, questions: dict) -> dict:
    answer = ask(state, questions)["answers"]["intent"]
    ranked = sorted(answer["probabilities"].items(), key=lambda kv: kv[1], reverse=True)
    top, p_top = ranked[0]
    if p_top >= ROUTE_AT:
        return {"handler": "talk_to_person" if top == "other" else top}
    return {"clarify": [name for name, _ in ranked if name != "other"][:2]}

const ROUTE_AT = 0.8;

async function route(state: unknown, questions: Record<string, unknown>) {
  const answer = (await ask(state, questions)).answers.intent;
  const ranked = Object.entries(answer.probabilities as Record<string, number>).sort(
    (a, b) => b[1] - a[1],
  );
  const [top, pTop] = ranked[0];
  if (pTop >= ROUTE_AT) return { handler: top === "other" ? "talk_to_person" : top };
  return { clarify: ranked.map(([name]) => name).filter((name) => name !== "other").slice(0, 2) };
}

def check(state: dict, questions: dict) -> list[str]:
    answers = ask(state, questions).get("answers", {})
    urgent = answers.get("urgent", {}).get("noul")
    medical_advice = answers.get("medical_advice", {}).get("noul")
    actions = []
    # A missing probability triggers the action, so a gap never skips a safety step.
    if urgent is None or urgent >= 0.2:
        actions.append("notify_on_call_person")
    if medical_advice is None or medical_advice >= 0.3:
        actions.append("reply_with_see_a_professional_note")
    return actions or ["answer_normally"]

async function check(state: unknown, questions: Record<string, unknown>) {
  const answers = (await ask(state, questions)).answers ?? {};
  const urgent: number | undefined = answers.urgent?.noul;
  const medicalAdvice: number | undefined = answers.medical_advice?.noul;
  const actions: string[] = [];
  // A missing probability triggers the action, so a gap never skips a safety step.
  if (typeof urgent !== "number" || urgent >= 0.2) actions.push("notify_on_call_person");
  if (typeof medicalAdvice !== "number" || medicalAdvice >= 0.3) {
    actions.push("reply_with_see_a_professional_note");
  }
  return actions.length ? actions : ["answer_normally"];
}

ACT_AT = 0.7

def next_step(state: dict, questions: dict) -> dict:
    result = ask(state, questions)
    answer = result["answers"]["next_step"]
    step = answer["choice"]
    if answer["probabilities"][step] >= ACT_AT:
        return {"send": step, "model": result["model"]}
    return {"send": "standard_welcome", "review": True, "model": result["model"]}

const ACT_AT = 0.7;

async function nextStep(state: unknown, questions: Record<string, unknown>) {
  const result = await ask(state, questions);
  const answer = result.answers.next_step;
  const step: string = answer.choice;
  if (answer.probabilities[step] >= ACT_AT) return { send: step, model: result.model };
  return { send: "standard_welcome", review: true, model: result.model };
}