┌─────────────────────────────────────────────────────────────────────────┐
│                    สถาปัตยกรรมการแยกหน้าที่                                │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│   ┌──────────────┐    ┌──────────────┐    ┌──────────────┐            │
│   │   Trigger    │───▶│ Orchestrator │───▶│   Executor   │            │
│   │   Layer      │    │   Layer      │    │   Layer      │            │
│   └──────────────┘    └──────────────┘    └──────────────┘            │
│           │                  │                   │                     │
│           ▼                  ▼                   ▼                     │
│   ┌──────────────┐    ┌──────────────┐    ┌──────────────┐            │
│   │  Validation  │    │   Routing    │    │   Agents     │            │
│   │  & Sanitize  │    │   Logic      │    │   & Tools    │            │
│   └──────────────┘    └──────────────┘    └──────────────┘            │
│                              │                   │                     │
│                              ▼                   ▼                   │
│                       ┌──────────────┐    ┌──────────────┐            │
│                       │   Memory     │    │   Response   │            │
│                       │   Manager    │    │   Formatter  │            │
│                       └──────────────┘    └──────────────┘            │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

// การตรวจสอบ Fail-Fast ใน n8n Function node
const input = $input.first().json;

// ตรวจสอบฟิลด์ที่จำเป็น
const requiredFields = ['query', 'userId', 'sessionId'];
for (const field of requiredFields) {
  if (!input[field]) {
    throw new Error(`ขาดฟิลด์ที่จำเป็น: ${field}`);
  }
}

// ตรวจสอบประเภทข้อมูล
if (typeof input.query !== 'string' || input.query.length > 10000) {
  throw new Error('คำถามไม่ถูกต้อง: ต้องเป็นสตริงที่มีความยาวไม่เกิน 10,000 ตัวอักษร');
}

// ตรวจสอบกฎธุรกิจ
if (input.userId.startsWith('test_') && $env.NODE_ENV === 'production') {
  throw new Error('ไม่อนุญาตให้ใช้ ID ผู้ใช้ทดสอบในโปรดักชั่น');
}

return [{ json: { validated: input } }];

┌─────────────────────────────────────────────────────────────────────────┐
│                    กระบวนการ Graceful Degradation                          │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│   Request ──▶ Primary Agent ──┬──▶ Success ──▶ Full Response           │
│          │                    │                                        │
│          │                    └──▶ Failure ──▶ Fallback Agent            │
│          │                           │                                   │
│          │                           └──▶ Success ──▶ Reduced Response   │
│          │                                             + Warning        │
│          │                                                              │
│          └──▶ Both Fail ──▶ Static Response ──▶ Human Handoff           │
│                              + Alert                                   │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

// Supervisor Node - เวิร์กโฟลว์หลัก
const input = $input.first().json;
const task = input.task;

// กำหนดงานย่อยสำหรับ Worker
const subtasks = [
  { agent: 'research', task: `ค้นคว้า: ${task}`, priority: 1 },
  { agent: 'analysis', task: `วิเคราะห์ผลลัพธ์สำหรับ: ${task}`, priority: 2, dependsOn: ['research'] },
  { agent: 'synthesis', task: `สังเคราะห์ผลลัพธ์สำหรับ: ${task}`, priority: 3, dependsOn: ['analysis'] }
];

// ดำเนินการ Worker ผ่าน sub-workflows
const results = await Promise.all(
  subtasks.map(subtask => 
    $runWorkflow(`worker-${subtask.agent}`, { input: subtask })
  )
);

// Supervisor ตรวจสอบและรวมผลลัพธ์
const supervisorPrompt = `
คุณเป็นเอเจนต์ Supervisor ตรวจสอบผลลัพธ์ของ Worker เหล่านี้และสร้างคำตอบสุดท้าย:

ผลลัพธ์การค้นคว้า: ${results[0].output}
ผลลัพธ์การวิเคราะห์: ${results[1].output}
ผลลัพธ์การสังเคราะห์: ${results[2].output}

งานต้นฉบับ: ${task}

ให้คำตอบสุดท้ายที่ครอบคลุมซึ่งรวมผลงานของ Worker ทั้งหมด
`;

return [{ json: { subtasks, supervisorPrompt } }];

┌─────────────────────────────────────────────────────────────────────────┐
│                    ลำดับชั้นการประกอบ                                    │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  ระดับ 4: เวิร์กโฟลว์ระบบ                                              │
│  ┌─────────────────────────────────────────────────────────────────┐   │
│  │                    ระบบบริการลูกค้า                               │   │
│  └─────────────────────────────────────────────────────────────────┘   │
│                              │                                          │
│                              ▼                                          │
│  ระดับ 3: เวิร์กโฟลว์กระบวนการ                                              │
│  ┌────────────────┐  ┌────────────────┐  ┌────────────────┐           │
│  │การกำหนดเส้นทาง  │  │  การแก้ไข     │  │   การยกระดับ   │           │
│  │   ตั๋ว         │  │   ปัญหา       │  │    ปัญหา       │           │
│  └────────────────┘  └────────────────┘  └────────────────┘           │
│                                                                         │
│  ระดับ 2: เวิร์กโฟลว์เอเจนต์                                                │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐  │
│  │ Research │  │ Analyze  │  │ Suggest  │  │ Validate │  │ Respond  │  │
│  │  Agent   │  │  Agent   │  │ Solution │  │ Solution │  │  Agent   │  │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘  └──────────┘  │
│                                                                         │
│  ระดับ 1: เวิร์กโฟลว์เครื่องมือ                                                 │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐                 │
│  │  Search  │  │ Retrieve │  │   LLM    │  │  Store   │                 │
│  │   Web    │  │   Docs   │  │  Call    │  │  Memory  │                 │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘                 │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────┐
│                    การจำแนกประเภทหน่วยความจำ                              │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  หน่วยความจำระยะสั้น (Session)                                           │
│  ├── ประวัติการสนทนา                                                      │
│  ├── บริบทการทำงาน                                                        │
│  ├── ผลลัพธ์การเรียกเครื่องมือ                                              │
│  └── TTL: นาทีถึงชั่วโมง                                                  │
│                                                                         │
│  หน่วยความจำระยะกลาง (ผู้ใช้)                                              │
│  ├── การตั้งค่าผู้ใช้                                                     │
│  ├── รูปแบบการโต้ตอบ                                                     │
│  ├── ผลลัพธ์ก่อนหน้า                                                      │
│  └── TTL: วันถึงสัปดาห์                                                   │
│                                                                         │
│  หน่วยความจำระยะยาว (ระบบ)                                                 │
│  ├── ฐานความรู้                                                          │
│  ├── รูปแบบที่เรียนรู้                                                     │
│  ├── บริบทองค์กร                                                         │
│  └── TTL: ถาวร                                                          │
│                                                                         │
│  หน่วยความจำเหตุการณ์ (Event)                                              │
│  ├── การโต้ตอบเฉพาะ                                                      │
│  ├── จุดตัดสินใจ                                                         │
│  ├── ผลลัพธ์และฟีดแบ็ก                                                    │
│  └── TTL: ถาวรพร้อมการลดลงตามเวลา                                           │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────┐
│                    การจัดสรรงบประมาณหน้าต่างบริบท                          │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  หน้าต่างบริบททั้งหมด: 200,000 token (Claude 4.6)                          │
│                                                                         │
│  ┌────────────────────────────────────────────────────────────────┐   │
│  │ System Prompt & คำสั่ง:                       2,000 token (1%)  │   │
│  ├────────────────────────────────────────────────────────────────┤   │
│  │ เครื่องมือและฟังก์ชันที่มี:                    8,000 token (4%)  │   │
│  ├────────────────────────────────────────────────────────────────┤   │
│  │ ประวัติการสนทนา:                            30,000 token (15%) │   │
│  ├────────────────────────────────────────────────────────────────┤   │
│  │ บริบทที่ดึงมา (RAG):                         60,000 token (30%)│   │
│  ├────────────────────────────────────────────────────────────────┤   │
│  │ หน่วยความจำและสถานะเอเจนต์:                 20,000 token (10%)│   │
│  ├────────────────────────────────────────────────────────────────┤   │
│  │ พื้นที่ทำงาน (การคิด):                       40,000 token (20%)│   │
│  ├────────────────────────────────────────────────────────────────┤   │
│  │ สำรองสำหรับ Output:                          40,000 token (20%)│   │
│  └────────────────────────────────────────────────────────────────┘   │
│                                                                         │
│  จัดสรรทั้งหมด: 200,000 token                                             │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────┐
│                    สถานะ Circuit Breaker                                 │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│                         ┌──────────────┐                                │
│                    ┌────│   CLOSED   │────┐                          │
│                    │    │  (Normal)  │    │                          │
│                    │    └──────────────┘    │                          │
│         Success    │            │            │  เกินเกณฑ์               │
│         threshold  │            │ failures   │  ความล้มเหลว             │
│         exceeded   │            ▼            │                          │
│                    │    ┌──────────────┐    │                          │
│                    └────│    OPEN      │────┘                          │
│                         │  (Blocked)   │                               │
│                         └───────┬──────┘                                │
│                                 │                                       │
│                                 │ Timeout หมดลง                         │
│                                 ▼                                       │
│                         ┌──────────────┐                                │
│                         │ HALF-OPEN    │                                │
│                         │  (Testing)   │                                │
│                         └───────┬──────┘                                │
│                                 │                                       │
│                    ┌────────────┴────────────┐                          │
│                    │                            │                         │
│                    ▼                            ▼                        │
│            ┌──────────────┐          ┌──────────────┐                   │
│            │   Success    │          │   Failure    │                   │
│            │  ปิด circuit │          │  เปิด circuit │                   │
│            └──────────────┘          └──────────────┘                   │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

// การใช้งาน Retry ระดับโปรดักชั่น
class RetryPolicy {
  constructor(config = {}) {
    this.maxRetries = config.maxRetries || 3;
    this.baseDelay = config.baseDelay || 1000;
    this.maxDelay = config.maxDelay || 30000;
    this.exponentialBase = config.exponentialBase || 2;
    this.jitterFactor = config.jitterFactor || 0.1;
    
    // ข้อผิดพลาดที่สมควรลองใหม่
    this.retryableErrors = config.retryableErrors || [
      'ETIMEDOUT',
      'ECONNRESET',
      'ECONNREFUSED',
      'EPIPE',
      'RateLimitError',
      'ServiceUnavailableError',
      'TimeoutError'
    ];
    
    // ข้อผิดพลาดที่ไม่ควรลองใหม่
    this.nonRetryableErrors = config.nonRetryableErrors || [
      'AuthenticationError',
      'AuthorizationError',
      'ValidationError',
      'BadRequestError'
    ];
  }
  
  async execute(operation, context = {}) {
    const attempts = [];
    
    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
      const startTime = Date.now();
      
      try {
        const result = await operation();
        
        // บันทึกการกู้คืนสำเร็จ
        if (attempt > 0) {
          await this.logRecovery(context, attempt, attempts);
        }
        
        return {
          success: true,
          result,
          attempts: attempt + 1,
          duration: Date.now() - context.startTime
        };
        
      } catch (error) {
        const duration = Date.now() - startTime;
        attempts.push({
          attempt: attempt + 1,
          error: error.message,
          errorType: error.name,
          duration
        });
        
        // ตรวจสอบว่าควรลองใหม่หรือไม่
        if (!this.shouldRetry(error, attempt)) {
          throw this.enhanceError(error, attempts);
        }
        
        // คำนวณความล่าช้า
        const delay = this.calculateDelay(attempt);
        
        // บันทึกความพยายามลองใหม่
        await this.logRetry(context, attempt, error, delay);
        
        // รอก่อนลองใหม่
        await this.sleep(delay);
      }
    }
    
    throw new Error(`เกินจำนวนครั้งลองใหม่สูงสุดหลังจาก ${this.maxRetries + 1} ครั้ง`);
  }
}

┌─────────────────────────────────────────────────────────────────────────┐
│                    สถาปัตยกรรม Dead Letter Queue                           │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│   เวิร์กโฟลว์หลัก                                                         │
│   ┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐        │
│   │  Input   │───▶│  Process │───▶│  Output  │───▶│ Complete │        │
│   └──────────┘    └────┬─────┘    └──────────┘    └──────────┘        │
│                        │                                               │
│                        │ ล้มเหลวหลังจากลองใหม่สูงสุด                  │
│                        ▼                                               │
│                   ┌──────────┐                                          │
│                   │   DLQ    │                                          │
│                   │  Queue   │                                          │
│                   └────┬─────┘                                          │
│                        │                                               │
│                        ▼                                               │
│   ┌──────────────────────────────────────────────────────────────┐   │
│   │                     ไปป์ไลน์ประมวลผล DLQ                        │   │
│   │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐     │   │
│   │  │ จำแนก   │──▶│ วิเคราะห์ │──▶│ ซ่อมแซม  │──▶│ ฉีดกลับ  │     │   │
│   │  │ ข้อผิด  │  │ รูปแบบ   │  │ ความพยายาม│  │ หรือแจ้ง │     │   │
│   │  └──────────┘  └──────────┘  └──────────┘  └──────────┘     │   │
│   └──────────────────────────────────────────────────────────────┘   │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────┐
│                    เสาหลักสามเสาของความสามารถในการสังเกต                  │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐         │
│  │     METRICS     │  │      LOGS       │  │     TRACES      │         │
│  ├─────────────────┤  ├─────────────────┤  ├─────────────────┤         │
│  │                 │  │                 │  │                 │         │
│  │ การใช้ Token    │  │ คำสั่งเอเจนต์    │  │ กระแสคำขอ      │         │
│  │ Latency P99     │  │ การตอบสนองเอเจนต์│  │ การเรียกบริการ  │         │
│  │ อัตราความผิด   │  │ การดำเนินการเครื่องมือ│  │ การสืบค้น DB    │         │
│  │ ต้นทุนต่อคำขอ   │  │ การเข้าถึงหน่วยความจำ│  │ Cache Hits      │         │
│  │ ความลึกของคิว  │  │ การเปลี่ยนสถานะ │  │ ข้ามบริการ      │         │
│  │ สถานะ Circuit   │  │ จุดตัดสินใจ    │  │ การส่งต่อ Async │         │
│  │                 │  │                 │  │                 │         │
│  │ Time Series DB  │  │  Log Aggregator │  │  Trace Backend  │         │
│  │ (Prometheus)    │  │   (Loki/ELK)    │  │  (Jaeger/OTel)  │         │
│  └─────────────────┘  └─────────────────┘  └─────────────────┘         │
│                                                                         │
│                         ┌──────────────┐                               │
│                         │  Dashboards  │                               │
│                         │  & Alerts    │                               │
│                         └──────────────┘                               │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────┐
│                    พีระมิดการทดสอบสำหรับระบบ AI                           │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│                           ┌──────────┐                                 │
│                           │  E2E     │  <-- การทดสอบเวิร์กโฟลว์เต็ม     │
│                           │  Tests   │     (smoke, เส้นทางสำคัญ)      │
│                           └────┬─────┘                                 │
│                          ┌─────┴─────┐                                 │
│                         ┌────────────┐                                  │
│                         │ Integration │  <-- สถานการณ์มัลติเอเจนต์       │
│                         │   Tests   │     (การประสานงาน, ความล้มเหลว) │
│                         └─────┬─────┘                                  │
│                        ┌──────┴──────┐                                  │
│                       ┌────────────────┐                                 │
│                       │   Agent Unit   │  <-- การทดสอบเอเจนต์เดี่ยว     │
│                       │     Tests      │     (prompts, เครื่องมือ, หน่วยความจำ) │
│                       └──────────────┘                                 │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

// Connection Pooling HTTP สำหรับ API AI
const http = require('http');
const https = require('https');

const httpAgent = new http.Agent({
  keepAlive: true,
  maxSockets: 50,
  maxFreeSockets: 10,
  timeout: 30000,
  freeSocketTimeout: 30000
});

const httpsAgent = new https.Agent({
  keepAlive: true,
  maxSockets: 50,
  maxFreeSockets: 10,
  timeout: 30000,
  freeSocketTimeout: 30000
});

// ใช้ agents ในคำขอ
const response = await $httpRequest({
  method: 'POST',
  url: 'http://ai-gateway:8080/v1/chat/completions',
  agent: httpAgent,  // ใช้ซ้ำการเชื่อมต่อ
  body: request
});

┌─────────────────────────────────────────────────────────────────────────┐
│                    สถาปัตยกรรมชั้นความปลอดภัย                              │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  ┌─────────────────────────────────────────────────────────────────┐   │
│  │                      ความปลอดภัยรอบนอก                         │   │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐      │   │
│  │  │  AuthN   │  │  AuthZ   │  │   Rate   │  │   DDoS   │      │   │
│  │  │  (JWT)   │  │  (RBAC)  │  │  Limit   │  │   WAF    │      │   │
│  │  └──────────┘  └──────────┘  └──────────┘  └──────────┘      │   │
│  └─────────────────────────────────────────────────────────────────┘   │
│                              │                                          │
│                              ▼                                          │
│  ┌─────────────────────────────────────────────────────────────────┐   │
│  │                      ความปลอดภัยแอปพลิเคชัน                       │   │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐      │   │
│  │  │  Input   │  │  Prompt  │  │  Output  │  │  Audit   │      │   │
│  │  │Sanitizer │  │ Injection│  │  Filter  │  │   Log    │      │   │
│  │  └──────────┘  └──────────┘  └──────────┘  └──────────┘      │   │
│  └─────────────────────────────────────────────────────────────────┘   │
│                              │                                          │
│                              ▼                                          │
│  ┌─────────────────────────────────────────────────────────────────┐   │
│  │                       ความปลอดภัยข้อมูล                          │   │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐      │   │
│  │  │ Encryption│  │  Token   │  │  Memory  │  │   PII    │      │   │
│  │  │  at Rest │  │  Masking │  │  Isolation│  │  Detection│      │   │
│  │  └──────────┘  └──────────┘  └──────────┘  └──────────┘      │   │
│  └─────────────────────────────────────────────────────────────────┘   │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

// เวิร์กโฟลว์บริการลูกค้าสมบูรณ์
const SupportSystemWorkflow = {
  name: 'customer-support-v2',
  
  async execute(request) {
    const context = {
      userId: request.userId,
      sessionId: request.sessionId,
      traceId: generateTraceId(),
      startTime: Date.now()
    };
    
    const logger = createLogger(context);
    const metrics = new MetricsCollector();
    
    logger.info('ได้รับคำขอการสนับสนุน', {
      category: request.category,
      priority: request.priority
    });
    
    try {
      // ขั้นตอนที่ 1: จำแนกและกำหนดเส้นทาง
      const classification = await this.classifyRequest(request, context);
      
      // ขั้นตอนที่ 2: ดึงบริบท
      const memory = await this.retrieveContext(request, context);
      
      // ขั้นตอนที่ 3: ดำเนินการเอเจนต์ที่เหมาะสม
      const response = await this.executeAgent(classification, memory, context);
      
      // ขั้นตอนที่ 4: ตรวจสอบและ post-process
      const validated = await this.validateResponse(response, context);
      
      // ขั้นตอนที่ 5: เก็บการโต้ตอบ
      await this.storeInteraction(request, validated, context);
      
      // ขั้นตอนที่ 6: ส่งการตอบสนอง
      return await this.sendResponse(validated, context);
      
    } catch (error) {
      logger.error('เวิร์กโฟลว์การสนับสนุนล้มเหลว', error);
      return await this.handleError(error, request, context);
    }
  },
  
  async classifyRequest(request, context) {
    const retryPolicy = new RetryPolicy({ maxRetries: 3 });
    
    return await retryPolicy.execute(async () => {
      const result = await $httpRequest({
        method: 'POST',
        url: 'http://ai-gateway:8080/v1/chat/completions',
        body: {
          model: 'claude-haiku-4.5',
          messages: [{
            role: 'user',
            content: `จำแนกคำขอการสนับสนุนนี้:\n${request.message}`
          }],
          max_tokens: 100
        }
      });
      
      return {
        category: result.choices[0].message.content,
        confidence: 0.9
      };
    });
  }
};

┌─────────────────────────────────────────────────────────────────────────┐
│                    Blue-Green Deployment                               │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│   สถานะปัจจุบัน (Blue Active)                                            │
│   ┌──────────┐         ┌──────────┐                                    │
│   │  Traffic │────────▶│   Blue   │                                    │
│   │  Router  │         │ (Active) │                                    │
│   └────┬─────┘         └──────────┘                                    │
│        │                                                                │
│        │     ┌──────────┐                                              │
│        └────▶│  Green   │ (Idle)                                         │
│              │ (New Ver)│                                              │
│              └──────────┘                                              │
│                                                                         │
│   หลังการสลับ                                                             │
│   ┌──────────┐         ┌──────────┐                                    │
│   │  Traffic │────────▶│  Green   │                                    │
│   │  Router  │         │ (Active) │                                    │
│   └────┬─────┘         └──────────┘                                    │
│        │                                                                │
│        │     ┌──────────┐                                              │
│        └────▶│   Blue   │ (Standby)                                      │
│              │ (Old Ver)│                                              │
│              └──────────┘                                              │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘