// AI content generation endpoint
async function generateArticleDraft(topic, keywords) {
  const response = await openai.chat.completions.create({
    model: "gpt-4",
    messages: [
      {
        role: "system",
        content: "You are an expert content writer. Generate SEO-optimized article drafts."
      },
      {
        role: "user",
        content: `Write a 1000-word article about ${topic}. Include keywords: ${keywords}`
      }
    ],
    temperature: 0.7,
    max_tokens: 2000
  });

  return response.choices[0].message.content;
}

// AI support ticket classification
async function classifyAndRespond(ticketContent) {
  const classification = await anthropic.messages.create({
    model: "claude-sonnet-4-5-20250514",
    max_tokens: 1024,
    messages: [{
      role: "user",
      content: `Classify this support ticket and provide a response:

      Ticket: ${ticketContent}

      Categories: billing, technical, account, feature_request
      Urgency: low, medium, high

      Return JSON with classification and suggested response.`
    }]
  });

  const result = JSON.parse(classification.content[0].text);

// Route to human if high urgency or complex  
  if (result.urgency === "high" || result.confidence < 0.8) {
    return { action: "escalate_to_human", data: result };
  }

  return { action: "auto_respond", data: result };
}

CUSTOMER_ONBOARDING_WORKFLOW

[New Customer Signs Up]
         ↓
    [Trigger: Webhook]
         ↓
    ┌────────────────┐
    │ Create Account │ ← Database
    │ in Database    │
    └────────────────┘
         ↓
    ┌────────────────┐
    │ Send Welcome   │ ← Email Service (SendGrid)
    │ Email          │
    └────────────────┘
         ↓
    ┌────────────────┐
    │ Add to CRM     │ ← Salesforce API
    └────────────────┘
         ↓
    ┌────────────────┐
    │ Schedule       │ ← Calendar API
    │ Onboarding Call│
    └────────────────┘
         ↓
    ┌────────────────┐
    │ Send Slack     │ ← Slack Webhook
    │ Notification   │
    └────────────────┘
         ↓
    [Workflow Complete]

CONTENT_APPROVAL_WORKFLOW

[Writer Submits Draft]
         ↓
    ┌─────────────────────┐
    │ AI Checks:          │
    │ - Grammar/Spelling  │
    │ - SEO Keywords      │
    │ - Brand Voice       │
    │ - Readability Score │
    └─────────────────────┘
         ↓
    ┌──────────┬──────────┐
    │ Pass?    │  Fail?   │
    └──────────┴──────────┘
         │            │
         ↓            ↓
    [Send to      [Return to
     Editor]       Writer with
                   Feedback]
         ↓
    ┌─────────────────┐
    │ Editor Reviews  │
    └─────────────────┘
         ↓
    ┌──────────┬──────────┐
    │ Approve? │ Reject?  │
    └──────────┴──────────┘
         │            │
         ↓            ↓
    [Publish to    [Loop back
     Website]       to Writer]

// Workflow orchestration example
const contentWorkflow = {
  id: "content_approval",

  steps: [
    {
      name: "ai_quality_check",
      action: async (draft) => {
        const analysis = await aiCheck(draft);
        return analysis.score > 0.8 ? "pass" : "fail";
      }
    },
    {
      name: "editor_review",
      condition: (prevResult) => prevResult === "pass",
      action: async (draft) => {
        await sendToEditor(draft);
        return await waitForApproval();
      }
    },
    {
      name: "publish",
      condition: (prevResult) => prevResult === "approved",
      action: async (draft) => {
        await publishToWebsite(draft);
        await notifySocialTeam(draft);
      }
    }
  ]
};

async function extractInvoiceData(pdfBuffer) {
// Convert PDF to text  
  const pdfText = await extractTextFromPDF(pdfBuffer);

// Use AI to extract structured data  
  const response = await openai.chat.completions.create({
    model: "gpt-4",
    messages: [
      {
        role: "system",
        content: `Extract invoice data into JSON format:
        {
          "vendor": string,
          "invoice_number": string,
          "date": "YYYY-MM-DD",
          "due_date": "YYYY-MM-DD",
          "total_amount": number,
          "line_items": [{"description": string, "amount": number}]
        }`
      },
      { role: "user", content: pdfText }
    ],
    response_format: { type: "json_object" }
  });

  const invoiceData = JSON.parse(response.choices[0].message.content);

// Validate extracted data  
  if (!invoiceData.vendor || !invoiceData.total_amount) {
    throw new Error("Failed to extract required fields");
  }

  return invoiceData;
}

// Hybrid: Traditional automation + AI
async function processCustomerRequest(request) {
// Traditional: Check business rules first (fast, cheap)  
  if (request.amount > 10000) {
    return { action: "require_manager_approval", reason: "exceeds_limit" };
  }

// AI: Handle complex decision-making  
  const aiAnalysis = await analyzeRequestWithAI(request);

// Traditional: Route based on AI output  
  if (aiAnalysis.sentiment === "angry") {
    return { action: "escalate_to_senior", priority: "high" };
  }

  return { action: "standard_processing", priority: "normal" };
}