Your AIAI Workflow,
Live in Production
Before Lunch.

import OpenAI from "openai";
import { z } from "zod";

const ai = new OpenAI();

// ── Schemas ──
const TicketInfoSchema = z.object({
  customer: z.string(),
  product: z.string(),
  category: z.enum(["billing", "technical", "account", "other"]),
  summary: z.string(),
});

const PrioritySchema = z.object({
  level: z.enum(["high", "medium", "low"]),
  reasoning: z.string(),
});

// ── Step 1: Extract ticket info ──
async function extractInfo(ticket: string) {
  const res = await ai.chat.completions.create({
    model: "gpt-4o",
    messages: [
      {
        role: "system",
        content:
          "Extract structured info from this support ticket.\n"
          + "Return JSON: { customer, product, category, summary }.",
      },
      { role: "user", content: ticket },
    ],
    response_format: { type: "json_object" },
    temperature: 0.1,
  });

  const raw = res.choices[0].message.content;
  if (!raw) throw new Error("Empty response from extractInfo");
  return TicketInfoSchema.parse(JSON.parse(raw));
}

// ── Step 2: Assess priority ──
async function assessPriority(
  info: z.infer<typeof TicketInfoSchema>,
) {
  const res = await ai.chat.completions.create({
    model: "gpt-4o",
    messages: [
      {
        role: "system",
        content:
          "Assess the priority of this support ticket.\n"
          + "Consider category, tone, and urgency.\n"
          + "Return JSON: { level, reasoning }.",
      },
      { role: "user", content: JSON.stringify(info) },
    ],
    response_format: { type: "json_object" },
    temperature: 0.2,
  });

  const raw = res.choices[0].message.content;
  if (!raw) throw new Error("Empty response from assessPriority");
  return PrioritySchema.parse(JSON.parse(raw));
}

// ── Step 3a: Draft escalation ──
async function draftEscalation(
  info: z.infer<typeof TicketInfoSchema>,
  priority: z.infer<typeof PrioritySchema>,
) {
  const res = await ai.chat.completions.create({
    model: "gpt-4o",
    messages: [
      {
        role: "system",
        content:
          "Draft an urgent escalation note for the support lead.\n"
          + "Include: customer name, issue summary, why it's urgent.\n"
          + "Tone: concise, action-oriented.",
      },
      {
        role: "user",
        content: JSON.stringify({ ...info, ...priority }),
      },
    ],
    temperature: 0.3,
    max_tokens: 300,
  });

  const text = res.choices[0].message.content;
  if (!text) throw new Error("Empty response from draftEscalation");
  return text;
}

// ── Step 3b: Draft standard reply ──
async function draftReply(
  info: z.infer<typeof TicketInfoSchema>,
) {
  const res = await ai.chat.completions.create({
    model: "gpt-4o",
    messages: [
      {
        role: "system",
        content:
          "Draft a helpful reply to this support ticket.\n"
          + "Be friendly, acknowledge the issue, offer next steps.\n"
          + "Max 4 sentences.",
      },
      {
        role: "user",
        content: JSON.stringify(info),
      },
    ],
    temperature: 0.7,
    max_tokens: 256,
  });

  const text = res.choices[0].message.content;
  if (!text) throw new Error("Empty response from draftReply");
  return text;
}

// ── Orchestrator ──
async function handleTicket(ticket: string) {
  const info = await extractInfo(ticket);
  const priority = await assessPriority(info);

  if (priority.level === "high") {
    const note = await draftEscalation(info, priority);
    return { action: "escalated" as const, note, info, priority };
  }

  const response = await draftReply(info);
  return { action: "replied" as const, response, info, priority };
}