Announcing ADK for Kotlin 1.0: Building Production-Ready AI Agents in Kotlin, Android, and Beyond

data class ServiceMetrics(
    val serviceName: String,
    val cpuUsagePercent: Double,
    val connectionPoolUsagePercent: Double,
    val activeConnections: Int,
    val maxConnections: Int,
    val p99LatencyMs: Int,
    val errorRatePercent: Double,
)

data class DeploymentInfo(
    val deploymentId: String,
    val serviceName: String,
    val gitCommit: String,
    val author: String,
    val deployedMinutesAgo: Int,
    val description: String,
)

class InfrastructureDiagnosticsService {

    @Tool
    suspend fun getServiceMetrics(
        @Param("Target service or database cluster") serviceName: String,
        @Param("Time window in minutes") windowMinutes: Int? = 15,
    ): ServiceMetrics {
        // Query monitoring backends (Datadog, Prometheus, Cloud Monitoring)
        return ServiceMetrics(
            serviceName = serviceName,
            cpuUsagePercent = 91.4,
            connectionPoolUsagePercent = 98.5,
            activeConnections = 492,
            maxConnections = 500,
            p99LatencyMs = 2450,
            errorRatePercent = 4.2,
        )
    }

    @Tool
    fun fetchRecentDeployments(
        @Param("Target service identifier") serviceName: String
    ): List<DeploymentInfo> {
        return listOf(
            DeploymentInfo(
                deploymentId = "deploy-9842",
                serviceName = serviceName,
                gitCommit = "a1b2c3d",
                author = "[email protected]",
                deployedMinutesAgo = 25,
                description = "Add unindexed batch query to user profile sync job",
            )
        )
    }

    @Tool
    fun notifyOnCall(
        @Param("Channel to notify, e.g. '#production-alerts'") channel: String,
        @Param("Diagnostic summary message") message: String,
        @Param("Severity: INFO, WARNING, CRITICAL") severity: String? = "WARNING",
    ): String {
        println(">>> [CHAT-OPS] Broadcasting [$severity] to $channel: $message")
        return "Notification posted successfully."
    }
}

---
name: database-incident-triage
description: Standard operating procedure for diagnosing database latency spikes and connection pool saturation.
allowed-tools: [getServiceMetrics, fetchRecentDeployments, notifyOnCall]
---

# Database Incident Triage SOP

1. **Telemetry**: Call `getServiceMetrics` to inspect CPU, latency, and pool saturation.
2. **Correlation**: Call `fetchRecentDeployments` to check for recent code/schema changes.
3. **Safety Rules**: Inspect `assets/mitigation_rules.txt` with `load_skill_resource` before taking action. Never restart primary nodes during peak hours.
4. **Notify**: Broadcast root-cause diagnosis to `#production-alerts` with `notifyOnCall`.

object IncidentTriageDemoAgent {

    val rootAgent = LlmAgent(
        name = "incident_triage_agent",
        model = Gemini(name = "gemini-3.8-flash"),
        instruction = Instruction(
            """
            你是一个SRE值班诊断助手。
            当收到警报时:
            1. 发现可用的故障排除方案并使用 `load_skill` 加载匹配的标准操作流程(SOP)。
            2. 严格遵循方案步骤，必要时加载技能资源。
            3. 使用诊断工具检查遥测数据并通知团队。
            """.trimIndent()
        ),
        // 1. 编译时生成的函数工具（零反射）
        tools = InfrastructureDiagnosticsService().generatedTools(),
        // 2. 动态技能工具集（提供 list_skills, load_skill, load_skill_resource）
        toolsets = listOf(SkillToolset(NewFileSystemSource(resolveSkillsDir()))),
    )
}

fun main() = runBlocking {
    val runner = InMemoryRunner(
        agent = IncidentTriageDemoAgent.rootAgent, 
        appName = "IncidentTriageApp"
    )

    val alert = "ALERT [P1]: 在 'users-postgres-cluster' 上检测到数据库延迟激增！ "
              + "活动连接激增且查询超时。"

    val events = runner.runAsync(
        userId = "oncall-sre",
        sessionId = UUID.randomUUID().toString(),
        newMessage = Content.fromText(Role.USER, alert)
    ).toList()

    for (event in events) {
        event.content?.parts?.firstOrNull()?.text?.let { println("Agent: $it") }
    }
}

// 1. 需要人工确认的敏感工具
class BankTransferTools {
    @Tool(
        name = "transferFunds",
        description = "向其他账户转账。需要用户明确授权",
        requireConfirmation = true
    )
    fun transferFunds(
        @Param("收款账户ID") recipientId: String,
        @Param("金额（美元）") amount: Double
    ): String {
        println(">>> [BANKING CORE] 正在执行向 $recipientId 转账 \$${amount}...")
        return "已成功安排向 $recipientId 转账 \$${amount}。参考号：TX-${System.currentTimeMillis()}"
    }
}

// 2. 使用 Firebase AI（Gemini 3.8 Flash）定义代理
fun createFinancialAgent(): LlmAgent {
    val firebaseAi = FirebaseAI.getInstance(FirebaseApp.getInstance())
    return LlmAgent(
        name = "FinancialAgent",
        description = "处理银行查询和资金转账安排",
        model = Firebase.create("gemini-3.8-flash", firebaseAi),
        instruction = Instruction(
            "你是一个安全的银行助手。帮助用户管理账户并进行资金转账"
        ),
        tools = BankTransferTools().generatedTools()
    )
}

// 3. 使用持久化安卓存储服务配置 Runner
fun createAndroidRunner(applicationContext: Context, agent: LlmAgent): InMemoryRunner {
    return InMemoryRunner(
        agent = agent,
        appName = "AndroidFinancialApp",
        // 使用 SQLite 持久化存储跨重启/进程终止的聊天记录
        sessionService = RoomSessionService.fromContext(applicationContext),
        // 使用 AndroidX AppSearch 进行设备端全文索引的内存服务
        memoryService = AppSearchMemoryService.fromContext(applicationContext),
        // 用于生成的声明/收据的私有文件存储
        artifactService = FileArtifactService.fromExternalFilesDir(applicationContext)
    )
}

// 4. 多轮人机协作执行
suspend fun runFinancialDemo(runner: InMemoryRunner) {
    val userId = "user-123"
    val sessionId = "session-${UUID.randomUUID()}"
    suspend fun sendTurn(message: Content): List<Event> {
        val events = runner.runAsync(userId = userId, sessionId = sessionId, newMessage = message).toList()
        for (event in events) {
            event.content?.parts?.firstOrNull()?.text?.let { println("Agent: $it") }
        }
        return events
    }

    // --- 第1轮：用户请求转账（智能体暂停执行）
    println("User: 请将50美元转入账户ACCT-9876。\n")
    val turn1Events = sendTurn(
            Content.fromText(Role.USER, "Please transfer $50 to account ACCT-9876."))

    // 拦截ADK发出的合成确认请求
    val confirmationRequestId = turn1Events
        .flatMap { it.functionCalls() }
        .firstOrNull { it.name == FunctionCall.REQUEST_CONFIRMATION_FUNCTION_CALL_NAME }
        ?.id ?: return
    println("\n[UI]: 检测到敏感操作。用户点击了[确认转账]。\n")

    // --- 第2轮：用户在安卓UI中确认（恢复并执行转账）
    val approvalMessage = Content(
        role = Role.USER,
        parts = listOf(
            Part(
                functionResponse = FunctionResponse(
                    name = FunctionCall.REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
                    id = confirmationRequestId,
                    response = mapOf(ToolConfirmation.CONFIRMED_KEY to true)
                )
            )
        )
    )
    sendTurn(approvalMessage)
}

dependencies {
    // ADK Kotlin核心引擎 + KSP处理器
    implementation("com.google.adk:google-adk-kotlin-core:1.0.0")
    ksp("com.google.adk:google-adk-kotlin-processor:1.0.0")

    // 可选安卓优先扩展：
    implementation("com.google.adk:google-adk-kotlin-mlkit-android:1.0.0-beta")
    implementation("com.google.adk:google-adk-kotlin-litertlm:1.0.0")     
    implementation("com.google.adk:google-adk-kotlin-firebase-android:1.0.0")
}