Ein Support-Ticket in einen belegten Antwortentwurf triagieren

const BASE = "https://openapi.felo.ai";
const headers = {
  Authorization: `Bearer ${process.env.FELO_API_KEY}`,
  "Content-Type": "application/json",
};

async function felo<T>(path: string, body?: unknown): Promise<T> {
  const res = await fetch(`${BASE}${path}`, {
    method: body ? "POST" : "GET",
    headers,
    body: body ? JSON.stringify(body) : undefined,
  });
  if (!res.ok) throw new Error(`${res.status}: ${await res.text()}`);
  return res.json() as Promise<T>;
}

const redact = (text: string) =>
  text
    .replace(/[\w.+-]+@[\w.-]+\.\w+/g, "[email]")
    .replace(/\b(?:acct|account|order|invoice)[-_ ]?\w+\b/gi, "[id]")
    .replace(/\b(?:\d[ -]?){13,19}\b/g, "[card]");

type Ticket = {
  id: string;
  product: string;
  subject: string;
  body: string;
  plan?: string;
  sensitive?: boolean;
};

const ticket: Ticket = {
  id: "T-1042",
  product: "Acme Workspace",
  subject: "Why did my plan renew?",
  body: "I was charged again and cannot find the renewal date on my account.",
  plan: "team",
};

const summary = redact(`${ticket.subject}\n\n${ticket.body}`).slice(0, 1500);

type ChatData = {
  data: {
    answer: string;
    resources: { link: string; title: string; snippet: string }[];
  };
};

const triage = await felo<ChatData>("/v2/chat", {
  query: `Classify this support question by intent and priority, and list what is missing:\n\n${summary}`,
});

console.log(triage.data.answer);

type Hit = { title: string; content: string; score: number };

const KB = process.env.SUPPORT_LIVEDOC_ID!; // the help-center LiveDoc short_id

const retrieved = await felo<{ data: Hit[] }>(
  `/v2/livedocs/${KB}/resources/retrieve`,
  { query: summary },
);

const hits = retrieved.data.filter((hit) => hit.score >= 0.7).slice(0, 4);

if (hits.length === 0) {
  console.log("No grounded evidence: escalate instead of drafting");
}

type XData = {
  data: {
    tweets: {
      content: string;
      author: { username: string };
      created_at: string;
      url: string;
    }[];
  };
};

const since = Math.floor((Date.now() - 48 * 60 * 60 * 1000) / 1000);

const incident = await felo<XData>("/v2/x/tweet/search", {
  query: `"${ticket.product}" (outage OR "not working" OR error)`,
  limit: 20,
  since_time: since,
});

const reports = incident.data.tweets.map((post) => ({
  text: post.content,
  handle: post.author.username,
  at: post.created_at.slice(0, 10),
  link: post.url,
}));

type Route = "draft" | "ask-customer" | "escalate";

function decideRoute(): { route: Route; reason: string } {
  if (hits.length === 0) {
    return { route: "escalate", reason: "no grounded evidence in the knowledge base" };
  }
  if (ticket.sensitive) {
    return { route: "escalate", reason: "an account or billing action is requested" };
  }
  if (reports.length >= 3) {
    return { route: "escalate", reason: "public reports suggest a wider issue" };
  }
  if (!ticket.plan) {
    return { route: "ask-customer", reason: "the plan is needed to answer the question" };
  }
  return { route: "draft", reason: "the documentation covers the question" };
}

const decision = decideRoute();

const packet = [
  `# Triage — ${ticket.id}`,
  "",
  `Route: ${decision.route} (${decision.reason})`,
  "",
  "## Intent and priority",
  triage.data.answer,
  "",
  "## Evidence",
  ...hits.map((hit) => `- ${hit.title} (score ${hit.score})`),
  "",
  "## Public signal",
  ...(reports.length
    ? reports.map((report) => `- @${report.handle} (${report.at}): ${report.text} — ${report.link}`)
    : ["No public reports in the last 48 hours."]),
  "",
  "## Reply draft",
  "[Written by the host Agent from the evidence above — human review required]",
].join("\n");

console.log(packet);

type LiveDocData = { data: { short_id: string } };

const log = await felo<LiveDocData>("/v2/livedocs", {
  name: "Support triage log",
  description: "One document resource per triaged ticket",
});

await felo(`/v2/livedocs/${log.data.short_id}/resources/doc`, {
  title: `Triage — ${ticket.id}`,
  content: packet,
});

console.log(log.data.short_id); // reuse it for the next ticket