Koog Kotlin AI 框架實戰 Day 16：智能 LLM 路由與容錯機制

// Day 4：基礎的多 LLM 設定
val openAIClient = OpenAILLMClient(ApiKeyManager.openAIKey)
val anthropicClient = AnthropicLLMClient(ApiKeyManager.anthropicKey)
val googleClient = GoogleLLMClient(ApiKeyManager.googleKey)

val basicMultiExecutor = BasicMultiLLMSetup(
    openAIClient, anthropicClient, googleClient
)

// Day 16：智能路由與容錯
val intelligentExecutor = IntelligentLLMRouter(
    availableClients = listOf(openAIClient, anthropicClient, googleClient),
    routingStrategy = SmartRoutingStrategy(),
    fallbackStrategy = AutoFailoverStrategy(),
    healthMonitor = ModelHealthMonitor()
)

// 自動選擇最適合的模型，並具備容錯能力
val response = intelligentExecutor.executeWithIntelligence(prompt)

// 檔案：src/main/kotlin/intelligent/QueryComplexityAnalyzer.kt
package intelligent

import ai.koog.prompt.Prompt

enum class QueryComplexity {
    SIMPLE,      // 簡單問答
    MODERATE,    // 中等複雜度
    COMPLEX,     // 複雜分析
    CRITICAL     // 關鍵任務
}

enum class TaskDomain {
    GENERAL_QA,        // 一般問答
    TECHNICAL_SUPPORT, // 技術支援
    CREATIVE_WRITING,  // 創意寫作
    DATA_ANALYSIS,     // 資料分析
    CODE_GENERATION,   // 程式碼生成
    TRANSLATION        // 翻譯
}

class QueryComplexityAnalyzer {

    data class QueryAnalysis(
        val complexity: QueryComplexity,
        val domain: TaskDomain,
        val urgency: Boolean,
        val estimatedTokens: Int
    )

    fun analyzeQuery(prompt: Prompt): QueryAnalysis {
        val content = extractPromptContent(prompt)

        val complexity = determineComplexity(content)
        val domain = identifyDomain(content)
        val urgency = detectUrgency(content)
        val estimatedTokens = estimateTokenUsage(content)

        return QueryAnalysis(complexity, domain, urgency, estimatedTokens)
    }

    private fun extractPromptContent(prompt: Prompt): String {
        return prompt.messages
            .map { it.content }
            .joinToString(" ")
            .lowercase()
    }

    private fun determineComplexity(content: String): QueryComplexity {
        val complexityIndicators = mapOf(
            QueryComplexity.CRITICAL to listOf("緊急", "critical", "urgent", "重要", "立即"),
            QueryComplexity.COMPLEX to listOf("分析", "比較", "評估", "深入", "詳細", "複雜"),
            QueryComplexity.MODERATE to listOf("說明", "解釋", "如何", "為什麼", "建議"),
            QueryComplexity.SIMPLE to listOf("什麼", "哪裡", "什麼時候", "是否", "簡單")
        )

        for ((complexity, indicators) in complexityIndicators) {
            if (indicators.any { indicator -> content.contains(indicator) }) {
                return complexity
            }
        }

        // 根據內容長度判斷
        return when {
            content.length > 500 -> QueryComplexity.COMPLEX
            content.length > 200 -> QueryComplexity.MODERATE
            else -> QueryComplexity.SIMPLE
        }
    }

    private fun identifyDomain(content: String): TaskDomain {
        val domainKeywords = mapOf(
            TaskDomain.TECHNICAL_SUPPORT to listOf("登入", "錯誤", "bug", "問題", "故障", "修復"),
            TaskDomain.CREATIVE_WRITING to listOf("創作", "寫作", "故事", "詩", "創意"),
            TaskDomain.DATA_ANALYSIS to listOf("分析", "數據", "統計", "趨勢", "報告"),
            TaskDomain.CODE_GENERATION to listOf("程式", "程式碼", "代碼", "kotlin", "java"),
            TaskDomain.TRANSLATION to listOf("翻譯", "translate", "英文", "中文")
        )

        for ((domain, keywords) in domainKeywords) {
            if (keywords.any { keyword -> content.contains(keyword) }) {
                return domain
            }
        }

        return TaskDomain.GENERAL_QA
    }

    private fun detectUrgency(content: String): Boolean {
        val urgencyKeywords = listOf("緊急", "urgent", "馬上", "立即", "急", "critical")
        return urgencyKeywords.any { keyword -> content.contains(keyword) }
    }

    private fun estimateTokenUsage(content: String): Int {
        // 簡化的 token 估算：大約每 4 個字元 = 1 token
        return (content.length / 4).coerceAtLeast(50)
    }
}

// 檔案：src/main/kotlin/intelligent/SmartRoutingStrategy.kt
package intelligent

import ai.koog.models.*

class SmartRoutingStrategy {

    // 模型能力評分矩陣
    private val modelCapabilities = mapOf(
        "gpt-4o" to ModelCapability(
            generalQA = 9, technical = 9, creative = 8,
            analysis = 9, coding = 9, translation = 7,
            costLevel = 3, speedLevel = 2
        ),
        "claude-3.5-sonnet" to ModelCapability(
            generalQA = 8, technical = 8, creative = 9,
            analysis = 9, coding = 8, translation = 8,
            costLevel = 2, speedLevel = 2
        ),
        "gemini-pro" to ModelCapability(
            generalQA = 7, technical = 6, creative = 6,
            analysis = 8, coding = 7, translation = 9,
            costLevel = 1, speedLevel = 3
        )
    )

    data class ModelCapability(
        val generalQA: Int,      // 一般問答能力 (1-10)
        val technical: Int,      // 技術支援能力
        val creative: Int,       // 創意寫作能力
        val analysis: Int,       // 資料分析能力
        val coding: Int,         // 程式碼生成能力
        val translation: Int,    // 翻譯能力
        val costLevel: Int,      // 成本等級 (1=低, 3=高)
        val speedLevel: Int      // 速度等級 (1=慢, 3=快)
    )

    fun selectOptimalModel(
        analysis: QueryComplexityAnalyzer.QueryAnalysis,
        availableModels: List<String>,
        prioritizeSpeed: Boolean = false,
        prioritizeCost: Boolean = false
    ): String {

        val scoredModels = availableModels.mapNotNull { modelId ->
            val capability = modelCapabilities[modelId]
            if (capability != null) {
                val score = calculateModelScore(analysis, capability, prioritizeSpeed, prioritizeCost)
                modelId to score
            } else null
        }

        return scoredModels
            .maxByOrNull { it.second }
            ?.first
            ?: availableModels.firstOrNull()
            ?: throw IllegalStateException("沒有可用的模型")
    }

    private fun calculateModelScore(
        analysis: QueryComplexityAnalyzer.QueryAnalysis,
        capability: ModelCapability,
        prioritizeSpeed: Boolean,
        prioritizeCost: Boolean
    ): Double {

        // 基礎能力分數
        val domainScore = when (analysis.domain) {
            TaskDomain.GENERAL_QA -> capability.generalQA
            TaskDomain.TECHNICAL_SUPPORT -> capability.technical
            TaskDomain.CREATIVE_WRITING -> capability.creative
            TaskDomain.DATA_ANALYSIS -> capability.analysis
            TaskDomain.CODE_GENERATION -> capability.coding
            TaskDomain.TRANSLATION -> capability.translation
        }.toDouble()

        // 複雜度匹配分數
        val complexityMultiplier = when (analysis.complexity) {
            QueryComplexity.SIMPLE -> 0.8    // 簡單任務不需要最強模型
            QueryComplexity.MODERATE -> 1.0  // 中等任務標準評分
            QueryComplexity.COMPLEX -> 1.2   // 複雜任務提升權重
            QueryComplexity.CRITICAL -> 1.5  // 關鍵任務最高權重
        }

        var finalScore = domainScore * complexityMultiplier

        // 速度優先
        if (prioritizeSpeed || analysis.urgency) {
            finalScore += capability.speedLevel * 2
        }

        // 成本優先
        if (prioritizeCost && analysis.complexity == QueryComplexity.SIMPLE) {
            finalScore += (4 - capability.costLevel) * 1.5 // 成本越低分數越高
        }

        return finalScore
    }

    fun explainSelection(
        modelId: String,
        analysis: QueryComplexityAnalyzer.QueryAnalysis
    ): String {
        val capability = modelCapabilities[modelId] ?: return "模型資訊不可用"

        return """
            選擇模型：$modelId
            任務領域：${analysis.domain}
            複雜度：${analysis.complexity}
            選擇原因：適合處理 ${analysis.domain} 類型的 ${analysis.complexity} 任務
            預估成本：${when(capability.costLevel) { 1 -> "低"; 2 -> "中"; else -> "高" }}
        """.trimIndent()
    }
}

// 檔案：src/main/kotlin/intelligent/ModelHealthMonitor.kt
package intelligent

import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlin.time.Duration
import kotlin.time.Duration.Companion.seconds
import kotlin.time.TimeSource

class ModelHealthMonitor {

    data class ModelHealth(
        var successCount: Int = 0,
        var failureCount: Int = 0,
        var averageResponseTime: Duration = Duration.ZERO,
        var lastSuccessTime: Long = System.currentTimeMillis(),
        var isHealthy: Boolean = true,
        var healthScore: Double = 100.0
    )

    private val healthMap = mutableMapOf<String, ModelHealth>()
    private val healthMutex = Mutex()

    suspend fun recordSuccess(modelId: String, responseTime: Duration) {
        healthMutex.withLock {
            val health = healthMap.getOrPut(modelId) { ModelHealth() }

            health.successCount++
            health.lastSuccessTime = System.currentTimeMillis()
            health.averageResponseTime = updateAverageResponseTime(health.averageResponseTime, responseTime)

            // 更新健康分數
            health.healthScore = calculateHealthScore(health)
            health.isHealthy = health.healthScore > 70.0
        }
    }

    suspend fun recordFailure(modelId: String, error: Exception) {
        healthMutex.withLock {
            val health = healthMap.getOrPut(modelId) { ModelHealth() }

            health.failureCount++

            // 更新健康分數
            health.healthScore = calculateHealthScore(health)
            health.isHealthy = health.healthScore > 50.0

            println("⚠️ 模型 $modelId 執行失敗：${error.message}")
        }
    }

    suspend fun getHealthyModels(availableModels: List<String>): List<String> {
        return healthMutex.withLock {
            availableModels.filter { modelId ->
                val health = healthMap[modelId]
                health?.isHealthy != false // 預設為健康（首次使用）
            }
        }
    }

    suspend fun getBestPerformingModel(availableModels: List<String>): String? {
        return healthMutex.withLock {
            availableModels
                .filter { modelId ->
                    val health = healthMap[modelId]
                    health?.isHealthy != false
                }
                .maxByOrNull { modelId ->
                    val health = healthMap[modelId] ?: ModelHealth()
                    health.healthScore - (health.averageResponseTime.inWholeSeconds * 2)
                }
        }
    }

    private fun updateAverageResponseTime(current: Duration, new: Duration): Duration {
        return if (current == Duration.ZERO) {
            new
        } else {
            current * 0.8 + new * 0.2 // 指數移動平均
        }
    }

    private fun calculateHealthScore(health: ModelHealth): Double {
        val totalRequests = health.successCount + health.failureCount
        if (totalRequests == 0) return 100.0

        val successRate = health.successCount.toDouble() / totalRequests
        val timeSinceLastSuccess = System.currentTimeMillis() - health.lastSuccessTime
        val stalePenalty = if (timeSinceLastSuccess > 300_000) 20.0 else 0.0 // 5分鐘無成功請求扣分

        return (successRate * 100) - stalePenalty
    }

    suspend fun getHealthReport(): Map<String, ModelHealth> {
        return healthMutex.withLock {
            healthMap.toMap()
        }
    }
}

// 檔案：src/main/kotlin/intelligent/AutoFailoverExecutor.kt
package intelligent

import ai.koog.prompt.Prompt
import ai.koog.agents.executors.PromptExecutor
import ai.koog.models.LLModel
import ai.koog.models.Message
import ai.koog.tools.ToolDescriptor
import kotlinx.coroutines.delay
import kotlin.time.TimeSource

class AutoFailoverExecutor(
    private val executors: Map<String, PromptExecutor>,
    private val healthMonitor: ModelHealthMonitor,
    private val routingStrategy: SmartRoutingStrategy
) : PromptExecutor {

    override suspend fun execute(
        prompt: Prompt,
        model: LLModel,
        tools: List<ToolDescriptor>
    ): List<Message.Response> {
        return executeWithFailover(prompt, model, tools)
    }

    suspend fun executeWithIntelligence(
        prompt: Prompt,
        prioritizeSpeed: Boolean = false,
        prioritizeCost: Boolean = false,
        maxRetries: Int = 3
    ): List<Message.Response> {

        val analyzer = QueryComplexityAnalyzer()
        val analysis = analyzer.analyzeQuery(prompt)

        println("🧠 智能分析結果：${analysis}")

        var attempt = 0
        var lastException: Exception? = null

        while (attempt < maxRetries) {
            try {
                // 取得健康的模型列表
                val healthyModels = healthMonitor.getHealthyModels(executors.keys.toList())

                if (healthyModels.isEmpty()) {
                    throw IllegalStateException("沒有健康的模型可用")
                }

                // 智能選擇模型
                val selectedModelId = if (attempt == 0) {
                    // 首次嘗試：使用智能路由
                    routingStrategy.selectOptimalModel(analysis, healthyModels, prioritizeSpeed, prioritizeCost)
                } else {
                    // 重試：選擇最佳性能模型
                    healthMonitor.getBestPerformingModel(healthyModels) ?: healthyModels.first()
                }

                println("🎯 選擇模型：${selectedModelId}")
                println("📋 ${routingStrategy.explainSelection(selectedModelId, analysis)}")

                val executor = executors[selectedModelId]
                    ?: throw IllegalStateException("執行器不存在：$selectedModelId")

                val startTime = TimeSource.Monotonic.markNow()

                // 執行查詢
                val result = executor.execute(prompt, createLLModel(selectedModelId), emptyList())

                val responseTime = startTime.elapsedNow()

                // 記錄成功
                healthMonitor.recordSuccess(selectedModelId, responseTime)

                println("✅ 執行成功，回應時間：${responseTime}")
                return result

            } catch (e: Exception) {
                lastException = e
                attempt++

                println("❌ 嘗試 $attempt 失敗：${e.message}")

                // 記錄失敗
                val failedModel = getLastUsedModel() // 需要實作追蹤機制
                if (failedModel != null) {
                    healthMonitor.recordFailure(failedModel, e)
                }

                // 指數退避
                if (attempt < maxRetries) {
                    val delayTime = (1000 * attempt).toLong()
                    println("⏳ 等待 ${delayTime}ms 後重試...")
                    delay(delayTime)
                }
            }
        }

        throw lastException ?: Exception("所有重試都失敗了")
    }

    private suspend fun executeWithFailover(
        prompt: Prompt,
        model: LLModel,
        tools: List<ToolDescriptor>
    ): List<Message.Response> {
        return executeWithIntelligence(prompt)
    }

    private fun createLLModel(modelId: String): LLModel {
        // 根據模型 ID 創建對應的 LLModel 實例
        // 這裡需要根據實際的 Koog API 來實作
        return when (modelId) {
            "gpt-4o" -> ai.koog.models.OpenAIModels.Chat.GPT4o
            "claude-3.5-sonnet" -> ai.koog.models.AnthropicModels.Chat.Claude3_5Sonnet
            "gemini-pro" -> ai.koog.models.GoogleModels.Chat.GeminiPro
            else -> ai.koog.models.OpenAIModels.Chat.GPT4o // 預設
        }
    }

    private fun getLastUsedModel(): String? {
        // 實作最後使用模型的追蹤
        // 這裡需要根據實際執行情況來記錄
        return null
    }
}

// 檔案：src/main/kotlin/customer/IntelligentCustomerService.kt
package customer

import ai.koog.agents.AIAgent
import ai.koog.agents.executors.simpleOpenAIExecutor
import ai.koog.agents.executors.simpleAnthropicExecutor
import ai.koog.agents.executors.simpleGoogleExecutor
import ai.koog.prompt.prompt
import intelligent.*

class IntelligentCustomerService {

    // Day 2: 引用 ApiKeyManager
    private val apiKeyManager = ApiKeyManager

    // Day 11: 快取系統（來自前面的實作）
    private val cache by lazy { createCacheStrategy() }

    // Day 12: 記憶體系統（來自前面的實作）
    private val memoryProvider by lazy { createMemoryProvider() }

    // Day 16: 新增智能路由系統
    private val healthMonitor = ModelHealthMonitor()
    private val routingStrategy = SmartRoutingStrategy()

    // 設定多個執行器
    private val executors = mapOf(
        "gpt-4o" to createCachedExecutor(simpleOpenAIExecutor(apiKeyManager.openAIKey)),
        "claude-3.5-sonnet" to createCachedExecutor(simpleAnthropicExecutor(apiKeyManager.anthropicKey)),
        "gemini-pro" to createCachedExecutor(simpleGoogleExecutor(apiKeyManager.googleKey))
    )

    // 智能容錯執行器
    private val intelligentExecutor = AutoFailoverExecutor(
        executors = executors,
        healthMonitor = healthMonitor,
        routingStrategy = routingStrategy
    )

    // 升級版客服 Agent
    private val agent by lazy {
        AIAgent(
            executor = intelligentExecutor,                     // Day 16: 智能執行器
            systemPrompt = createEnhancedSystemPrompt(),        // Day 3: 進階提示
            toolRegistry = toolRegistry,                        // Day 5+9: 工具系統
            temperature = 0.7,                                  // Day 6: 配置
            maxIterations = 15,                                 // Day 6: 進階配置
            strategy = selectBestStrategy()                     // Day 14: 策略選擇
        ) {
            install(AgentMemory) {                              // Day 12: 記憶體功能
                memoryProvider = this@IntelligentCustomerService.memoryProvider
                featureName = "intelligent-customer-service"
                organizationName = "tech-support"
            }
        }
    }

    suspend fun handleCustomerQuery(
        query: String,
        prioritizeSpeed: Boolean = false,
        prioritizeCost: Boolean = false
    ): CustomerServiceResponse {

        println("🎧 智能客服系統處理查詢：$query")

        return try {
            // 使用智能執行器處理查詢
            val prompt = prompt {
                system(createEnhancedSystemPrompt())
                user(query)
            }

            val result = intelligentExecutor.executeWithIntelligence(
                prompt = prompt,
                prioritizeSpeed = prioritizeSpeed,
                prioritizeCost = prioritizeCost
            )

            CustomerServiceResponse(
                response = result.first().content,
                successful = true,
                modelUsed = "智能選擇",
                responseTime = System.currentTimeMillis(), // 簡化
                fromCache = false // 可以從快取系統取得實際狀態
            )

        } catch (e: Exception) {
            println("⚠️ 客服系統處理失敗：${e.message}")

            CustomerServiceResponse(
                response = "非常抱歉，系統暫時無法處理您的請求。我們的技術團隊正在處理這個問題。",
                successful = false,
                modelUsed = "容錯回應",
                responseTime = System.currentTimeMillis(),
                fromCache = false,
                error = e.message
            )
        }
    }

    // 系統健康狀態檢查
    suspend fun getSystemStatus(): SystemStatus {
        val healthReport = healthMonitor.getHealthReport()

        return SystemStatus(
            totalModels = executors.size,
            healthyModels = healthReport.values.count { it.isHealthy },
            averageResponseTime = healthReport.values
                .filter { it.isHealthy }
                .map { it.averageResponseTime }
                .takeIf { it.isNotEmpty() }
                ?.reduce { acc, duration -> acc + duration }
                ?.div(healthReport.values.count { it.isHealthy }),
            healthDetails = healthReport
        )
    }

    // 效能測試
    suspend fun performanceTest(): PerformanceTestResult {
        val testQueries = listOf(
            "我的帳號無法登入",
            "請幫我查詢訂單狀態",
            "今天台北的天氣如何？",
            "如何重設密碼？"
        )

        val results = mutableListOf<TestResult>()

        testQueries.forEach { query ->
            val startTime = System.currentTimeMillis()

            try {
                val response = handleCustomerQuery(query)
                val endTime = System.currentTimeMillis()

                results.add(TestResult(
                    query = query,
                    successful = response.successful,
                    responseTime = endTime - startTime,
                    modelUsed = response.modelUsed
                ))

            } catch (e: Exception) {
                results.add(TestResult(
                    query = query,
                    successful = false,
                    responseTime = -1,
                    error = e.message
                ))
            }
        }

        return PerformanceTestResult(
            totalTests = testQueries.size,
            successfulTests = results.count { it.successful },
            averageResponseTime = results.filter { it.successful }
                .map { it.responseTime }
                .takeIf { it.isNotEmpty() }
                ?.average() ?: 0.0,
            testDetails = results
        )
    }

    private fun createCachedExecutor(baseExecutor: ai.koog.agents.executors.SingleLLMPromptExecutor): ai.koog.agents.executors.SingleLLMPromptExecutor {
        // Day 11: 整合快取執行器
        return baseExecutor // 簡化實作，實際應包裝快取功能
    }

    private fun createEnhancedSystemPrompt(): String {
        return """
            你是一個智能客服助手，具備以下特色：

            📞 專業客服技能：
            - 友善且有耐心地協助客戶
            - 準確理解客戶問題並提供解決方案
            - 主動詢問必要的細節以提供更好的服務

            🧠 智能系統支援：
            - 我具備記憶體功能，可以記住客戶偏好和歷史
            - 我可以使用多種工具來協助客戶（天氣查詢、訂單查詢等）
            - 我的回應經過快取優化，能提供快速且一致的服務

            💡 服務原則：
            - 使用繁體中文進行對話
            - 回答簡潔明瞭，避免冗長說明
            - 無法確定時會誠實說明並提供替代方案
            - 遇到複雜問題時會適當升級給人工客服

            現在我已準備好為您提供最佳的客服體驗！
        """.trimIndent()
    }

    private fun selectBestStrategy(): ai.koog.agents.strategies.AgentStrategy {
        // Day 14: 策略選擇邏輯
        return ai.koog.agents.strategies.chatAgentStrategy()
    }

    private fun createCacheStrategy(): Any {
        // Day 11: 快取策略實作
        return "SimpleCache" // 簡化實作
    }

    private fun createMemoryProvider(): Any {
        // Day 12: 記憶體提供者實作
        return "SimpleMemoryProvider" // 簡化實作
    }

    private val toolRegistry by lazy {
        // Day 5+9: 工具註冊（天氣查詢、訂單查詢等）
        "SimpleToolRegistry" // 簡化實作
    }
}

// 資料類別定義
data class CustomerServiceResponse(
    val response: String,
    val successful: Boolean,
    val modelUsed: String,
    val responseTime: Long,
    val fromCache: Boolean,
    val error: String? = null
)

data class SystemStatus(
    val totalModels: Int,
    val healthyModels: Int,
    val averageResponseTime: kotlin.time.Duration?,
    val healthDetails: Map<String, ModelHealthMonitor.ModelHealth>
)

data class PerformanceTestResult(
    val totalTests: Int,
    val successfulTests: Int,
    val averageResponseTime: Double,
    val testDetails: List<TestResult>
)

data class TestResult(
    val query: String,
    val successful: Boolean,
    val responseTime: Long,
    val modelUsed: String? = null,
    val error: String? = null
)

// API Key 管理器（引用 Day 2）
object ApiKeyManager {
    val openAIKey: String by lazy {
        System.getenv("OPENAI_API_KEY")
            ?: error("請設定 OPENAI_API_KEY 環境變數")
    }

    val anthropicKey: String by lazy {
        System.getenv("ANTHROPIC_API_KEY")
            ?: error("請設定 ANTHROPIC_API_KEY 環境變數")
    }

    val googleKey: String by lazy {
        System.getenv("GOOGLE_API_KEY")
            ?: error("請設定 GOOGLE_API_KEY 環境變數")
    }
}

// 檔案：src/main/kotlin/examples/IntelligentCustomerServiceDemo.kt
package examples

import customer.IntelligentCustomerService
import kotlinx.coroutines.runBlocking

suspend fun main() {
    val customerService = IntelligentCustomerService()

    println("🚀 智能客服系統啟動完成")

    // 1. 系統健康檢查
    val systemStatus = customerService.getSystemStatus()
    println("📊 系統狀態：${systemStatus.healthyModels}/${systemStatus.totalModels} 模型運行正常")

    // 2. 測試不同類型的查詢
    val testCases = listOf(
        "我無法登入我的帳戶" to "簡單技術問題",
        "請幫我分析最近三個月的銷售趨勢，並提供改進建議" to "複雜分析任務",
        "今天台北的天氣如何？" to "簡單查詢（成本優先）",
        "緊急！我的系統出現嚴重錯誤，請立即協助！" to "緊急關鍵任務"
    )

    println("\n🧪 開始測試不同查詢類型：")

    testCases.forEach { (query, description) ->
        println("\n" + "=".repeat(50))
        println("📝 測試案例：$description")
        println("❓ 查詢：$query")

        val startTime = System.currentTimeMillis()

        val response = when (description) {
            "簡單查詢（成本優先）" -> customerService.handleCustomerQuery(
                query = query,
                prioritizeCost = true
            )
            "緊急關鍵任務" -> customerService.handleCustomerQuery(
                query = query,
                prioritizeSpeed = true
            )
            else -> customerService.handleCustomerQuery(query)
        }

        val endTime = System.currentTimeMillis()
        val responseTime = endTime - startTime

        println("🤖 AI 回應：${response.response}")
        println("⚡ 回應時間：${responseTime}ms")
        println("🎯 使用模型：${response.modelUsed}")
        println("✅ 執行結果：${if (response.successful) "成功" else "失敗"}")

        if (response.error != null) {
            println("⚠️ 錯誤訊息：${response.error}")
        }
    }

    // 3. 效能測試
    println("\n" + "=".repeat(50))
    println("🏃‍♂️ 開始效能測試...")

    val performanceResult = customerService.performanceTest()

    println("📈 效能測試結果：")
    println("   總測試數：${performanceResult.totalTests}")
    println("   成功數：${performanceResult.successfulTests}")
    println("   成功率：${(performanceResult.successfulTests.toDouble() / performanceResult.totalTests * 100).toInt()}%")
    println("   平均回應時間：${performanceResult.averageResponseTime.toInt()}ms")

    // 4. 最終系統狀態
    val finalStatus = customerService.getSystemStatus()
    println("\n📊 最終系統狀態：")
    finalStatus.healthDetails.forEach { (modelId, health) ->
        println("   $modelId: " +
               "成功${health.successCount}次, " +
               "失敗${health.failureCount}次, " +
               "健康度${health.healthScore.toInt()}%, " +
               "平均回應時間${health.averageResponseTime}")
    }

    println("\n🎉 智能客服系統測試完成！")
}

Day 8  → Day 11 → Day 12 → Day 14 → Day 16
基礎    快取     記憶體    策略     智能路由
聊天    優化     學習      選擇     容錯機制