Monitoring escalation agent

import OpenAI from 'openai';
import { Mcpmailer } from '@mcpmailer/sdk';

/* ── your provider: this block is the only part that changes ── */
const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

const MODEL = process.env.MODEL;
if (!MODEL) throw new Error('Set MODEL to the model name your provider expects, e.g. export MODEL=gpt-4o-mini');

/** The only provider-specific code in any of these examples. */
async function ask({ system, user, schema }: {
  system: string;
  user: string;
  schema?: object;
}) {
  const res = await client.chat.completions.create({
    model: MODEL,
    messages: [
      { role: 'system', content: system },
      { role: 'user', content: user }
    ],
    // A schema turns the answer into an object instead of prose, which is what
    // the branching examples want. Without one you get the text back.
    ...(schema
      ? { response_format: { type: 'json_schema', json_schema: { name: 'out', schema, strict: true } } }
      : {})
  });

  const text = res.choices[0].message.content ?? '';
  return schema ? JSON.parse(text) : text;
}

/* ── the agent ── */

const mm = new Mcpmailer();
const ROTA = ['ada@acme.com', 'jules@acme.com', 'cto@acme.com'];
const ACK_MS = 10 * 60_000;

export async function page(alert: {
  service: string;
  symptom: string;
  since: string;
  metric: string;
  severity: 'warn' | 'error' | 'critical';
}) {
  if (alert.severity === 'warn') return { paged: false, reason: 'quiet' as const };

  const subject = `${alert.service}: ${alert.symptom} [${alert.severity}]`;
  const body = [
    alert.symptom,
    `Since ${alert.since}.`,
    alert.metric,
    'Runbook: https://acme.com/runbook',
    '',
    'Reply ACK to take it.'
  ].join('\n');

  let threadId: string | undefined;

  for (const [i, who] of ROTA.entries()) {
    const sent = await mm.send({
      to: [who],
      subject,
      // Everything after the first page stays on the incident thread.
      body: i === 0 ? body : `${ROTA[i - 1]} did not acknowledge in 10 minutes.\n\n${body}`,
      style: 'plain'
    });
    threadId ??= (await mm.getMessage(sent.messageId!)).thread_id ?? undefined;

    const ack = await waitForAck(threadId!, who, ACK_MS);
    if (ack) return { paged: true, acknowledgedBy: who, threadId };
  }

  // Rota exhausted. Say so once, to everyone, and stop.
  await mm.send({
    to: ROTA,
    subject: `UNACKNOWLEDGED: ${subject}`,
    body: `Nobody acknowledged in ${(ROTA.length * 10)} minutes.\n\n${body}`
  });
  return { paged: true, acknowledgedBy: null, threadId };
}

async function waitForAck(threadId: string, who: string, ms: number) {
  const deadline = Date.now() + ms;
  while (Date.now() < deadline) {
    const thread = await mm.getThread(threadId);
    // Any reply is an ack: it means they are awake, which is what we measure.
    if (thread.messages.some((m) => m.direction === 'in' && m.from === who)) return true;
    await new Promise((r) => setTimeout(r, 10_000));
  }
  return false;
}