// Zero-shot: The model figures out the format on its own
const zeroShotPrompt = "Classify this support ticket as 'billing', 'technical', or 'general': " +
  "'My payment was charged twice last month'";

// Few-shot: Providing examples teaches the model your exact format
const fewShotPrompt = `Classify each support ticket. Respond with only the category.
 
Ticket: "I can't log into my account after resetting my password"
Category: technical
 
Ticket: "Can I get a refund for my annual subscription?"
Category: billing
 
Ticket: "What are your business hours?"
Category: general
 
Ticket: "My payment was charged twice last month"
Category:`;

const cotSystemPrompt = `You are a pricing calculator for a SaaS product.
 
When calculating prices, think through each step:
1. Identify the base plan and its price
2. Apply any quantity discounts
3. Add or remove add-ons
4. Apply promotional discounts last
5. Show the final total
 
Always show your reasoning before the final answer.`;
 
const userMessage = "We need 25 seats on the Pro plan ($49/seat/mo) " +
  "with the analytics add-on ($10/seat/mo). We have a 15% annual discount.";
 
// The model will break down the calculation step by step
// rather than jumping to a number that might be wrong

function buildSystemPrompt(context: {
  role: string;
  rules: string[];
  outputFormat: string;
  examples?: string;
}): string {
  return `# Role
${context.role}
 
# Rules
${context.rules.map((r, i) => `${i + 1}. ${r}`).join("\n")}
 
# Output Format
${context.outputFormat}
 
${context.examples ? `# Examples\n${context.examples}` : ""}`;
}
 
// Usage
const systemPrompt = buildSystemPrompt({
  role: "You are a senior code reviewer analyzing TypeScript pull requests.",
  rules: [
    "Focus on bugs, security issues, and performance problems",
    "Ignore stylistic preferences unless they impact readability",
    "Rate severity as 'critical', 'warning', or 'info'",
    "If the code is fine, say so briefly -- do not invent issues",
  ],
  outputFormat: `Respond in JSON format:
{
  "issues": [{ "line": number, "severity": string, "description": string }],
  "summary": "One sentence overall assessment"
}`,
});

import OpenAI from "openai";
import { z } from "zod";
import { zodResponseFormat } from "openai/helpers/zod";
 
// Define your output schema with Zod
const TicketAnalysis = z.object({
  category: z.enum(["billing", "technical", "general", "urgent"]),
  sentiment: z.enum(["positive", "negative", "neutral"]),
  summary: z.string().describe("One sentence summary of the ticket"),
  suggestedAction: z.string().describe("Recommended next step"),
  priority: z.number().min(1).max(5).describe("1 = lowest, 5 = highest"),
});
 
type TicketAnalysis = z.infer<typeof TicketAnalysis>;
 
async function analyzeTicket(ticketText: string): Promise<TicketAnalysis> {
  const openai = new OpenAI();
 
  const response = await openai.beta.chat.completions.parse({
    model: "gpt-4o",
    messages: [
      {
        role: "system",
        content: "Analyze support tickets and extract structured information.",
      },
      { role: "user", content: ticketText },
    ],
    response_format: zodResponseFormat(TicketAnalysis, "ticket_analysis"),
  });
 
  const parsed = response.choices[0].message.parsed;
  if (!parsed) throw new Error("Failed to parse response");
 
  return parsed;
}

import Anthropic from "@anthropic-ai/sdk";
import { z } from "zod";
 
async function analyzeWithClaude(ticketText: string): Promise<TicketAnalysis> {
  const anthropic = new Anthropic();
 
  const response = await anthropic.messages.create({
    model: "claude-sonnet-4-20250514",
    max_tokens: 512,
    system: `Analyze support tickets. Respond ONLY with valid JSON matching this schema:
{
  "category": "billing" | "technical" | "general" | "urgent",
  "sentiment": "positive" | "negative" | "neutral",
  "summary": "string",
  "suggestedAction": "string",
  "priority": 1-5
}`,
    messages: [{ role: "user", content: ticketText }],
  });
 
  const text = response.content.find((b) => b.type === "text")?.text;
  if (!text) throw new Error("No text in response");
 
  // Parse and validate with Zod
  const parsed = JSON.parse(text);
  return TicketAnalysis.parse(parsed);
}

import { encoding_for_model, type TiktokenModel } from "tiktoken";
 
function countTokens(text: string, model: TiktokenModel = "gpt-4o"): number {
  const encoder = encoding_for_model(model);
  const tokens = encoder.encode(text);
  encoder.free();
  return tokens.length;
}
 
interface ContextBudget {
  system: number;
  examples: number;
  retrievedDocs: number;
  conversationHistory: number;
  userMessage: number;
  reservedForOutput: number;
}
 
function buildManagedContext(config: {
  maxContextTokens: number;
  systemPrompt: string;
  examples: string[];
  retrievedDocs: string[];
  conversationHistory: Array<{ role: string; content: string }>;
  userMessage: string;
  maxOutputTokens: number;
}): { messages: Array<{ role: string; content: string }>; budget: ContextBudget } {
  const budget: ContextBudget = {
    system: countTokens(config.systemPrompt),
    examples: 0,
    retrievedDocs: 0,
    conversationHistory: 0,
    userMessage: countTokens(config.userMessage),
    reservedForOutput: config.maxOutputTokens,
  };
 
  let remainingTokens =
    config.maxContextTokens - budget.system - budget.userMessage - budget.reservedForOutput;
 
  // 1. Add examples (highest priority after system prompt)
  const includedExamples: string[] = [];
  for (const example of config.examples) {
    const tokens = countTokens(example);
    if (remainingTokens - tokens > 0) {
      includedExamples.push(example);
      budget.examples += tokens;
      remainingTokens -= tokens;
    }
  }
 
  // 2. Add retrieved documents
  const includedDocs: string[] = [];
  for (const doc of config.retrievedDocs) {
    const tokens = countTokens(doc);
    if (remainingTokens - tokens > 0) {
      includedDocs.push(doc);
      budget.retrievedDocs += tokens;
      remainingTokens -= tokens;
    }
  }
 
  // 3. Add conversation history (most recent first)
  const includedHistory: Array<{ role: string; content: string }> = [];
  for (const msg of [...config.conversationHistory].reverse()) {
    const tokens = countTokens(msg.content);
    if (remainingTokens - tokens > 0) {
      includedHistory.unshift(msg);
      budget.conversationHistory += tokens;
      remainingTokens -= tokens;
    } else {
      break; // Stop adding history when budget is exhausted
    }
  }
 
  // Assemble the final messages array
  const systemContent = [
    config.systemPrompt,
    includedExamples.length > 0
      ? "\n## Examples\n" + includedExamples.join("\n---\n")
      : "",
    includedDocs.length > 0
      ? "\n## Relevant Documents\n" + includedDocs.join("\n---\n")
      : "",
  ]
    .filter(Boolean)
    .join("\n");
 
  return {
    messages: [
      { role: "system", content: systemContent },
      ...includedHistory,
      { role: "user", content: config.userMessage },
    ],
    budget,
  };
}

// prompts/ticket-classifier.ts
export const TICKET_CLASSIFIER = {
  version: "1.3.0",
  model: "gpt-4o-mini" as const,
  temperature: 0,
  systemPrompt: `You are a support ticket classifier for an e-commerce platform.
 
# Categories
- billing: Payment issues, refunds, charges, invoices
- technical: Bugs, errors, login problems, performance issues
- shipping: Delivery status, tracking, address changes
- general: Everything else
 
# Rules
1. Choose exactly ONE category
2. If a ticket spans multiple categories, pick the PRIMARY concern
3. Respond with only the category name, nothing else`,
 
  // Track changes
  changelog: [
    { version: "1.3.0", change: "Added shipping category" },
    { version: "1.2.0", change: "Added rule about multi-category tickets" },
    { version: "1.1.0", change: "Switched from gpt-4o to gpt-4o-mini" },
    { version: "1.0.0", change: "Initial version" },
  ],
};