Build a support agent

npm install @team-plain/webhooks

import { verifyPlainWebhook } from "@team-plain/webhooks";

app.post("/webhooks/plain", async (req, res) => {
  const result = verifyPlainWebhook(
    req.body, // raw body string, see the warning below
    req.header("plain-request-signature")!,
    process.env.PLAIN_WEBHOOK_SECRET!,
  );

  if (result.error) {
    return res.status(400).send(result.error.message);
  }

  const event = result.data;

  // event.payload is a discriminated union, narrow on eventType
  switch (event.payload.eventType) {
    case "thread.thread_created":
      await onThreadCreated(event.payload);
      break;
    case "thread.email_received":
      await onEmailReceived(event.payload);
      break;
  }

  res.sendStatus(200);
});

if (event.payload.eventType === "thread.thread_created") {
  const thread = event.payload.thread;

  // Example filters, adapt to whatever your agent cares about
  if (thread.priority !== 0) return; // only urgent threads
  if (thread.labels.some(l => l.labelType.name === "no-bot")) return;

  await runAgent(thread);
}

function isAssignedToMe(thread: { assignee?: { id: string } | null }): boolean {
  // Your machine user's ID is on its settings page in Plain.
  return thread.assignee?.id === process.env.AGENT_MACHINE_USER_ID;
}

// Fires when a thread is assigned
if (event.payload.eventType === "thread.thread_assignment_transitioned") {
  if (!isAssignedToMe(event.payload.thread)) return;
  await runAgent(event.payload.thread);
}

// Fires when an email arrives on a thread
if (event.payload.eventType === "thread.email_received") {
  if (!isAssignedToMe(event.payload.thread)) return;
  await runAgent(event.payload.thread);
}

await plain.mutation.assignThread({
  input: {
    threadId: thread.id,
    machineUserId: process.env.AGENT_MACHINE_USER_ID,
  },
});

const thread = await plain.query.thread({
  threadId: "th_01H8H46YPB2S4MAJM382FG9423",
});

async function getThreadAsLlmText(threadId: string): Promise<string> {
  const thread = await plain.query.thread({ threadId });
  const parts: string[] = [];

  let page = await thread.timelineEntries({ first: 50 });
  while (true) {
    for (const entry of page.nodes) {
      if (entry.llmText) parts.push(entry.llmText);
    }

    const next = await page.fetchNext();
    if (!next) break;
    page = next;
  }

  return parts.join("\n\n");
}

npm install @team-plain/graphql

import { PlainClient } from "@team-plain/graphql";

const plain = new PlainClient({ apiKey: process.env.PLAIN_API_KEY! });

const result = await plain.mutation.replyToThread({
  input: {
    threadId: thread.id,
    textContent: "Thanks for reaching out, let me look into this.",
    markdownContent: "Thanks for reaching out, let me look into this.",
  },
});

if (result.error) {
  console.error(result.error.message);
}

const result = await plain.mutation.addGeneratedReply({
  input: {
    threadId: thread.id,
    timelineEntryId: customerMessage.id,
    markdown: "Hi! You can reset your password under **Settings → Security**.",
  },
});

await plain.mutation.createNote({
  input: {
    customerId: thread.customer.id,
    threadId: thread.id,
    text: "Customer asked for a refund. Confidence: low. Escalating.",
    markdown: "Customer asked for a refund. **Confidence: low.** Escalating.",
  },
});

await plain.mutation.addLabels({
  input: {
    threadId: thread.id,
    labelTypeIds: ["lt_01HB8BTNTZ58730MX8H5VMKFD5"],
  },
});

await plain.mutation.assignThread({
  input: {
    threadId: thread.id,
    userId: "u_01FSVKMHFDHJ3H5XFM20EMCBQN", // for example whoever is on call
  },
});

await plain.mutation.unassignThread({
  input: { threadId: thread.id },
});

await plain.mutation.updateThreadAgentStatus({
  input: {
    threadId: thread.id,
    agentStatus: "IN_PROGRESS",
  },
});