Building Compassionate AI

// agent/loop.ts — the perceive / infer / act / learn cycle
export async function step(ctx: AgentContext, userInput: string): Promise<Response> {
  const obs    = observe(userInput, ctx);              // 1. perceive
  const belief = inferBeliefState(obs, ctx.belief);    // 2. update hypothesis
  const cands  = proposeInterventions(belief);         // 3. what COULD we do?
  const scored = scoreInterventions(cands, belief);    // 4. score by compassion
  const choice = selectIntervention(scored, belief);   // 5. policy has final say
  const reply  = generateResponse(choice, belief);     // 6. speak within contract
  ctx.belief   = belief;                               //    carry state forward
  logInteraction(ctx, obs, belief, scored, choice, reply);
  return reply;
}

// agent/observe.ts
export type Observation = {
  text: string;
  signals: {
    crisis_markers: string[];     // surface cues only — never the sole basis
    consent_markers: string[];    // "yes", "ok", "let's try", "sure"
    refusal_markers: string[];    // "no", "not now", "stop", "don't"
    affect_words: string[];       // "exhausted", "numb", "panicking"
    asked_question: boolean;
  };
};

export function observe(text: string, _ctx: AgentContext): Observation {
  const lower = text.toLowerCase();
  const find = (list: string[]) => list.filter(w => lower.includes(w));
  return {
    text,
    signals: {
      crisis_markers: find(CRISIS_LEXICON),
      consent_markers: find(["yes","ok","okay","sure","let's","please do","i'd like"]),
      refusal_markers: find(["no","not now","stop","don't","rather not","leave it"]),
      affect_words: find(AFFECT_LEXICON),
      asked_question: text.includes("?"),
    },
  };
}

// schemas/BeliefState.ts
// The agent's running hypothesis about the person. Every field is a GUESS,
// and the "unknown" / uncertainty fields exist so the agent can say so.

export type Level = "low" | "medium" | "high" | "unknown";
export type Risk  = "low" | "medium" | "high" | "crisis" | "unknown";

export type BeliefState = {
  user_goal: string | null;              // what they seem to want from this turn
  distress_level: Risk;                  // how activated they seem right now
  emotional_tone: string[];              // observed affect words, not labels
  cognitive_fusion: Level;               // "hooked" by a thought as literal truth
  experiential_avoidance: Level;         // pushing a feeling away vs. making room
  values_clarity: Level;                 // do they know what matters to them here?
  consent_level: "explicit" | "implicit" | "absent";
  risk_level: Risk;                      // safety, distinct from distress
  uncertainty: "low" | "medium" | "high";// the agent's confidence in THIS state
  last_intervention: string | null;      // so we don't repeat or pile on
};

export function emptyBeliefState(): BeliefState {
  return {
    user_goal: null,
    distress_level: "unknown",
    emotional_tone: [],
    cognitive_fusion: "unknown",
    experiential_avoidance: "unknown",
    values_clarity: "unknown",
    consent_level: "absent",   // default: we have NOT been invited to intervene
    risk_level: "unknown",
    uncertainty: "high",       // default: we know nothing yet
    last_intervention: null,
  };
}

// agent/inferBeliefState.ts
// Deterministic heuristics FIRST. They are transparent, testable, and cheap.
// An LLM-based inferer can implement the same signature later (see note).

export function inferBeliefState(obs: Observation, prev: BeliefState): BeliefState {
  const next: BeliefState = { ...prev, last_intervention: prev.last_intervention };
  const s = obs.signals;

  // --- risk: surface markers RAISE suspicion; they never LOWER it ---
  if (s.crisis_markers.length > 0) {
    next.risk_level = "crisis";
    next.uncertainty = "medium"; // a flag is not certainty; verify with the user
  }

  // --- consent: explicit only when clearly given, and not overridden by refusal ---
  if (s.refusal_markers.length > 0) next.consent_level = "absent";
  else if (s.consent_markers.length > 0) next.consent_level = "explicit";

  // --- distress from affect intensity (heuristic) ---
  if (s.affect_words.length >= 2) next.distress_level = "high";
  else if (s.affect_words.length === 1) next.distress_level = "medium";

  next.emotional_tone = s.affect_words;

  // --- fusion / avoidance: cheap linguistic tells, held loosely ---
  const t = obs.text.toLowerCase();
  if (/\b(always|never|everyone|no one|can't stop|i am a)\b/.test(t))
    next.cognitive_fusion = "high";
  if (/\b(don't want to feel|make it go away|distract|numb|avoid)\b/.test(t))
    next.experiential_avoidance = "high";

  // --- overall uncertainty: short or ambiguous input => stay humble ---
  if (obs.text.trim().split(/\s+/).length < 4) next.uncertainty = "high";

  return next;
}

// schemas/Intervention.ts
export type Intervention =
  | "validate"               // reflect feeling back, no fixing
  | "ask_consent"            // "would you like to…?"
  | "reflect"                // mirror content so they feel heard
  | "defusion_exercise"      // unhook from a thought-as-truth
  | "grounding_exercise"     // come back to the body / present
  | "values_clarification"   // "what matters to you here?"
  | "committed_action"       // one tiny values-aligned step
  | "clarifying_question"    // resolve the agent's own uncertainty
  | "safety_check"           // gentle, direct check on safety
  | "human_escalation"       // route to a person / crisis resource
  | "refusal_or_boundary";   // decline what we shouldn't do

// agent/proposeInterventions.ts
// Enumerate what is even ON THE TABLE given the state. Scoring ranks them;
// policy (§8) can still veto. Proposing is generous; selecting is strict.

export function proposeInterventions(b: BeliefState): Intervention[] {
  const out = new Set<Intervention>();

  // Validation and reflection are almost always admissible — they cost little
  // and they honor the person before anything else happens.
  out.add("validate");
  out.add("reflect");

  if (b.risk_level === "crisis") {
    out.add("safety_check");
    out.add("human_escalation");
    return [...out]; // in crisis, nothing else is proposed (see policy)
  }

  if (b.uncertainty === "high") out.add("clarifying_question");
  if (b.consent_level === "absent") out.add("ask_consent");

  if (b.consent_level === "explicit") {
    if (b.distress_level === "high") out.add("grounding_exercise");
    if (b.cognitive_fusion === "high") out.add("defusion_exercise");
    if (b.experiential_avoidance === "high") out.add("values_clarification");
    if (b.values_clarity === "low") out.add("values_clarification");
    if (b.values_clarity === "high") out.add("committed_action");
  }

  return [...out];
}

// act/grounding.ts — content is an INVITATION, never an instruction
export const GROUNDING = {
  name: "grounding_exercise",
  // Phrased as an offer with an exit at every step.
  invite: "We can slow this down together if you'd like.",
  steps: [
    "If it feels okay, let your feet press into the floor.",
    "Notice five things you can see, in your own time.",
    "There's no right way to do this, and you can stop whenever.",
  ],
  // Every exercise ships with its own opt-out and a hand-off line.
  optOut: "Or we can skip this entirely — your call.",
};

// schemas/InterventionScore.ts
export type InterventionScore = {
  intervention: Intervention;
  reduces_suffering: number;   // 0–5: does it ease distress?
  respects_autonomy: number;   // 0–5: does it leave the person in control?
  truthful: number;            // 0–5: no overclaiming, no false comfort
  non_coercive: number;        // 0–5: invitation, not pressure
  act_consistent: number;      // 0–5: accepting, values-oriented, non-fixing
  safety: number;              // 0–5: does it protect, or expose?
  usefulness: number;          // 0–5: is it actually relevant right now?
  uncertainty_penalty: number; // subtracted: cost of acting while unsure
  total_score: number;
};

// agent/scoreInterventions.ts
const clamp = (n: number) => Math.max(0, Math.min(5, n));

export function scoreInterventions(
  cands: Intervention[], b: BeliefState,
): InterventionScore[] {
  return cands.map((intervention) => {
    // Base profiles encode "what is this move good and bad at?"
    // Then we adjust for the current belief state.
    let reduces = 2, autonomy = 4, truthful = 5, nonCoerce = 4,
        act = 3, safety = 4, useful = 3;

    switch (intervention) {
      case "validate":
        reduces = 3; autonomy = 5; nonCoerce = 5; act = 5; useful = 4; break;
      case "ask_consent":
        autonomy = 5; nonCoerce = 5; act = 5; useful = 4; break;
      case "grounding_exercise":
        // great for high distress, but only with consent
        reduces = b.distress_level === "high" ? 5 : 3;
        useful  = b.distress_level === "high" ? 5 : 2;
        nonCoerce = b.consent_level === "explicit" ? 5 : 1;
        break;
      case "defusion_exercise":
        useful = b.cognitive_fusion === "high" ? 5 : 2;
        nonCoerce = b.consent_level === "explicit" ? 5 : 1;
        break;
      case "values_clarification":
        useful = (b.values_clarity === "low" ||
                  b.experiential_avoidance === "high") ? 5 : 3;
        break;
      case "clarifying_question":
        // shines exactly when we're unsure
        useful = b.uncertainty === "high" ? 5 : 2;
        autonomy = 5; nonCoerce = 5; break;
      case "safety_check":
      case "human_escalation":
        safety = 5; useful = b.risk_level === "crisis" ? 5 : 1; break;
      case "committed_action":
        useful = b.values_clarity === "high" ? 5 : 1; break;
    }

    // The uncertainty penalty: acting decisively while unsure is costly,
    // EXCEPT for the humble moves (ask, clarify, validate) which are how
    // we reduce uncertainty in the first place.
    const decisive = !["validate","ask_consent","clarifying_question",
                       "safety_check","human_escalation"].includes(intervention);
    const uncertainty_penalty =
      decisive && b.uncertainty === "high" ? 3 :
      decisive && b.uncertainty === "medium" ? 1 : 0;

    const total =
      clamp(reduces) + clamp(autonomy) + clamp(truthful) + clamp(nonCoerce) +
      clamp(act) + clamp(safety) + clamp(useful) - uncertainty_penalty;

    return {
      intervention,
      reduces_suffering: clamp(reduces), respects_autonomy: clamp(autonomy),
      truthful: clamp(truthful), non_coercive: clamp(nonCoerce),
      act_consistent: clamp(act), safety: clamp(safety),
      usefulness: clamp(useful), uncertainty_penalty,
      total_score: total,
    };
  });
}

// agent/selectIntervention.ts
// Scoring RANKS. Policy DECIDES. The order of these guards is the safety model:
// the highest-stakes condition is checked first and short-circuits everything.

export function selectIntervention(
  scored: InterventionScore[], b: BeliefState,
): Intervention {
  // 1. CRISIS overrides all optimization. No ACT, no exercises, no cleverness.
  if (b.risk_level === "crisis") {
    return preferOneOf(scored, ["human_escalation", "safety_check"]);
  }

  // 2. No consent => we may only validate, reflect, clarify, or ASK.
  if (b.consent_level === "absent") {
    return preferOneOf(scored,
      ["validate", "ask_consent", "clarifying_question", "reflect"]);
  }

  // 3. High uncertainty => resolve it before acting on a person.
  if (b.uncertainty === "high") {
    return preferOneOf(scored, ["clarifying_question", "validate"]);
  }

  // 4. High distress => ground before any cognitive work.
  if (b.distress_level === "high") {
    return preferOneOf(scored, ["grounding_exercise", "validate"]);
  }

  // 5. Otherwise, trust the compassion score.
  return [...scored].sort((a, z) => z.total_score - a.total_score)[0].intervention;
}

// Pick the highest-scoring intervention from an allow-list, falling back to
// "validate" — the safest possible move — if none are present.
function preferOneOf(scored: InterventionScore[], allow: Intervention[]): Intervention {
  const inAllow = scored
    .filter(s => allow.includes(s.intervention))
    .sort((a, z) => z.total_score - a.total_score);
  return inAllow[0]?.intervention ?? "validate";
}

// safety/crisisPolicy.ts
export const CRISIS_RESPONSE = {
  // The agent does NOT counsel, analyze, or run exercises here.
  // It validates briefly, states its limits honestly, and points to humans.
  template: (region: ResourceRegion) => [
    "I'm really glad you told me, and I want to make sure you get support",
    "from a person right now — that matters more than anything I can offer.",
    region.line,            // e.g. a local crisis line / emergency number
    "If you're in immediate danger, please contact emergency services.",
    "I'm here to stay with you while you reach out.",
  ].join(" "),
};

// detectRisk is intentionally conservative: it ESCALATES on doubt.
export function detectRisk(obs: Observation, modelSignal?: number): Risk {
  if (obs.signals.crisis_markers.length > 0) return "crisis";
  if (modelSignal !== undefined && modelSignal > 0.5) return "crisis";
  // absence of markers is NOT evidence of safety — stay "unknown", not "low"
  return "unknown";
}

// safety/boundaries.ts
// Pure, side-effect-free predicates. If any returns true, the planned action
// is forbidden no matter how it scored. These are the agent's conscience.

export const FORBIDDEN = {
  diagnoses: (text: string) =>
    /\b(you (have|are)|sounds like) (depression|bipolar|ptsd|adhd|ocd|anxiety disorder)\b/i
      .test(text),

  claimsToBeTherapist: (text: string) =>
    /\b(as your therapist|i'm a (licensed )?(therapist|doctor|psychologist))\b/i
      .test(text),

  pushesWithoutConsent: (plan: Intervention, b: BeliefState) =>
    REQUIRES_CONSENT.includes(plan) && b.consent_level !== "explicit",

  coachesDuringCrisis: (plan: Intervention, b: BeliefState) =>
    b.risk_level === "crisis" &&
    !["safety_check", "human_escalation"].includes(plan),

  takesRealWorldAction: (plan: ActionRequest) =>
    plan.hasExternalEffect && !plan.userExplicitlyAuthorized,
};

const REQUIRES_CONSENT: Intervention[] =
  ["grounding_exercise", "defusion_exercise",
   "values_clarification", "committed_action"];

// agent/generateResponse.ts
// The response CONTRACT turns chosen-intervention into words, and enforces shape:
//   validate → offer choice → at most ONE small move → no diagnosis → no overclaim.
// Structure is a safety device: it makes coercion and overreach hard to express.

export function generateResponse(choice: Intervention, b: BeliefState): Response {
  const parts: string[] = [];

  // 1. Always lead with validation (unless pure crisis routing).
  if (choice !== "human_escalation") {
    parts.push(validationFor(b)); // "That sounds really heavy."
  }

  // 2. Offer a CHOICE, not a command. Two options + an exit.
  switch (choice) {
    case "grounding_exercise":
      parts.push("We can slow this down. Would a short grounding exercise help,",
                 "or would it feel better to just name what's here right now?");
      break;
    case "defusion_exercise":
      parts.push("If you're open to it, we could look at that thought together —",
                 "or we can just sit with it. Up to you.");
      break;
    case "clarifying_question":
      parts.push(clarifyingQuestionFor(b));
      break;
    case "human_escalation":
      parts.push(CRISIS_RESPONSE.template(b /* region */ as any));
      break;
    case "validate":
    default:
      parts.push("I'm here. Is there a part of this you'd like to stay with?");
  }

  const text = parts.join(" ");
  assertContract(text, b); // throws in dev if a FORBIDDEN predicate fires
  return { text, intervention: choice };
}

// index.ts — the v0 CLI. Type a message; see the agent's full reasoning.
import readline from "node:readline/promises";
import { emptyBeliefState } from "./schemas/BeliefState";
import { observe } from "./agent/observe";
import { inferBeliefState } from "./agent/inferBeliefState";
import { proposeInterventions } from "./agent/proposeInterventions";
import { scoreInterventions } from "./agent/scoreInterventions";
import { selectIntervention } from "./agent/selectIntervention";
import { generateResponse } from "./agent/generateResponse";
import { logInteraction } from "./logs/logger";

async function main() {
  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
  let belief = emptyBeliefState();

  while (true) {
    const userInput = await rl.question("\nyou › ");
    if (userInput.trim() === "/exit") break;

    const obs    = observe(userInput, { belief });
    belief       = inferBeliefState(obs, belief);
    const cands  = proposeInterventions(belief);
    const scored = scoreInterventions(cands, belief);
    const choice = selectIntervention(scored, belief);
    const reply  = generateResponse(choice, belief);
    belief.last_intervention = choice;

    logInteraction({ belief }, obs, belief, scored, choice, reply);

    // The whole point of v0: make the reasoning legible.
    console.log(JSON.stringify({
      belief_state: belief,
      candidate_interventions: cands,
      scores: scored.map(s => ({ i: s.intervention, total: s.total_score })),
      selected_intervention: choice,
      response: reply.text,
    }, null, 2));
  }
  rl.close();
}
main();

// logs/logger.ts — every belief update is recorded. Audit is a feature.
export function logInteraction(ctx, obs, belief, scored, choice, reply) {
  const record = {
    ts: new Date().toISOString(),
    input: obs.text,
    belief,                          // the full hypothesis at decision time
    scores: scored,                  // why each option ranked where it did
    selected: choice,
    response: reply.text,
    // NEVER log secrets; treat transcripts as sensitive health-adjacent data.
  };
  appendToSecureStore(record);       // encrypted at rest, access-controlled
}

// tests/policySelection.test.ts — test the RULES before anything else.
import { selectIntervention } from "../src/agent/selectIntervention";
import { scoreInterventions } from "../src/agent/scoreInterventions";
import { proposeInterventions } from "../src/agent/proposeInterventions";
import { emptyBeliefState } from "../src/schemas/BeliefState";

const decide = (patch: Partial<BeliefState>) => {
  const b = { ...emptyBeliefState(), ...patch };
  return selectIntervention(scoreInterventions(proposeInterventions(b), b), b);
};

test("crisis routes to a human, never to an exercise", () => {
  const choice = decide({ risk_level: "crisis", distress_level: "high",
                          consent_level: "explicit" });
  expect(["human_escalation", "safety_check"]).toContain(choice);
});

test("no consent means we ask, not act", () => {
  const choice = decide({ consent_level: "absent", distress_level: "high" });
  expect(["validate", "ask_consent", "clarifying_question", "reflect"])
    .toContain(choice);
});

test("high distress grounds before cognitive work", () => {
  const choice = decide({ distress_level: "high", consent_level: "explicit",
                          uncertainty: "low", risk_level: "low" });
  expect(choice).toBe("grounding_exercise");
});

test("high uncertainty clarifies instead of guessing", () => {
  const choice = decide({ uncertainty: "high", consent_level: "explicit" });
  expect(choice).toBe("clarifying_question");
});