google__adk-docs/examples/kotlin/snippets/artifacts/ArtifactExamples.kt

package com.google.adk.kt.examples.artifacts

import com.google.adk.kt.agents.Instruction
import com.google.adk.kt.agents.LlmAgent
import com.google.adk.kt.artifacts.GcsArtifactService
import com.google.adk.kt.artifacts.InMemoryArtifactService
import com.google.adk.kt.models.Gemini
import com.google.adk.kt.runners.InMemoryRunner
import com.google.adk.kt.sessions.InMemorySessionService
import com.google.adk.kt.tools.LoadArtifactsTool
import com.google.adk.kt.tools.ToolContext
import com.google.adk.kt.types.Blob
import com.google.adk.kt.types.Part
import kotlinx.coroutines.runBlocking

// --8<-- [start:full_example]
// --8<-- [start:representation]
fun artifactRepresentationExample() {
    // Assume 'imageBytes' contains the binary data of a PNG image
    val imageBytes = byteArrayOf(0x89.toByte(), 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A)

    val imageArtifact =
        Part(
            inlineData =
                Blob(
                    mimeType = "image/png",
                    data = imageBytes,
                ),
        )

    println("Artifact MIME Type: ${imageArtifact.inlineData?.mimeType}")
    println("Artifact Data (first 8 bytes): ${imageArtifact.inlineData?.data?.take(8)}")
}
// --8<-- [end:representation]

// --8<-- [start:configure_runner]
fun configureRunnerExample() {
    val myAgent =
        LlmAgent(name = "artifact_user_agent", model = Gemini(name = "gemini-flash-latest"))
    val artifactService = InMemoryArtifactService()
    val sessionService = InMemorySessionService()

    val runner =
        InMemoryRunner(
            agent = myAgent,
            appName = "my_artifact_app",
            sessionService = sessionService,
            artifactService = artifactService,
        )
}
// --8<-- [end:configure_runner]

// --8<-- [start:artifact_data]
fun artifactDataExample() {
    val pdfBytes = "%PDF-1.4...".toByteArray()
    val pdfMimeType = "application/pdf"

    val pdfArtifact =
        Part(
            inlineData =
                Blob(
                    data = pdfBytes,
                    mimeType = pdfMimeType,
                ),
        )

    println("Created Kotlin artifact with MIME type: ${pdfArtifact.inlineData?.mimeType}")
}
// --8<-- [end:artifact_data]

// --8<-- [start:namespacing]
fun namespacingExample() {
    // Session-specific artifact filename
    val sessionReportFilename = "summary.txt"

    // User-specific artifact filename
    val userConfigFilename = "user:settings.json"
}
// --8<-- [end:namespacing]

// --8<-- [start:interaction_save]
suspend fun saveGeneratedReport(
    context: ToolContext,
    reportBytes: ByteArray,
) {
    val reportArtifact =
        Part(
            inlineData =
                Blob(
                    data = reportBytes,
                    mimeType = "application/pdf",
                ),
        )
    val filename = "generated_report.pdf"

    val service = context.invocationContext.artifactService
    if (service != null) {
        val version =
            service.saveArtifact(
                context.invocationContext.session.key,
                filename,
                reportArtifact,
            )
        println("Successfully saved Kotlin artifact '$filename' as version $version.")
    } else {
        println("Artifact service not available.")
    }
}
// --8<-- [end:interaction_save]

// --8<-- [start:interaction_load]
suspend fun processLatestReport(context: ToolContext) {
    val filename = "generated_report.pdf"
    val reportArtifact = context.loadArtifact(filename)

    if (reportArtifact != null && reportArtifact.inlineData != null) {
        println("Successfully loaded latest Kotlin artifact '$filename'.")
        println("MIME Type: ${reportArtifact.inlineData?.mimeType}")
        val pdfBytes = reportArtifact.inlineData?.data
        println("Report size: ${pdfBytes?.size} bytes.")
    } else {
        println("Kotlin artifact '$filename' not found.")
    }
}
// --8<-- [end:interaction_load]

// --8<-- [start:load_artifacts_tool]
fun loadArtifactsToolExample() {
    val rootAgent =
        LlmAgent(
            name = "artifact_reader",
            model = Gemini(name = "gemini-flash-latest"),
            instruction =
                Instruction(
                    "Answer questions about available user files. " +
                        "Call load_artifacts before answering when you need file contents.",
                ),
            tools = listOf(LoadArtifactsTool()),
        )
}
// --8<-- [end:load_artifacts_tool]

// --8<-- [start:listing_artifacts]
suspend fun listUserFiles(context: ToolContext): String {
    val availableFiles = context.listArtifacts()
    if (availableFiles.isEmpty()) {
        return "You have no saved artifacts."
    } else {
        val fileListStr = availableFiles.joinToString("\n") { "- $it" }
        return "Here are your available Kotlin artifacts:\n$fileListStr"
    }
}
// --8<-- [end:listing_artifacts]

// --8<-- [start:in_memory_service]
fun inMemoryServiceExample() {
    val inMemoryService = InMemoryArtifactService()
}
// --8<-- [end:in_memory_service]

// --8<-- [start:gcs_service]
fun gcsServiceExample() {
    val gcsBucketName = "your-gcs-bucket-for-adk-artifacts"
    try {
        // Initialize the GCS Storage client (usually uses Application Default Credentials)
        val storage = com.google.cloud.storage.StorageOptions.getDefaultInstance().service
        val gcsService = GcsArtifactService(bucketName = gcsBucketName, storageClient = storage)
        println("Kotlin GcsArtifactService initialized for bucket: $gcsBucketName")
    } catch (e: Exception) {
        println("Error initializing Kotlin GcsArtifactService: ${e.message}")
    }
}
// --8<-- [end:gcs_service]

fun main() =
    runBlocking {
        artifactRepresentationExample()
        artifactDataExample()
        inMemoryServiceExample()
        gcsServiceExample()
    }
// --8<-- [end:full_example]