Summary Type

data class Summary(
    val summary: String
) : HasContent

import com.embabel.agent.domain.library.Summary

val summary = Summary(
    "This document discusses AI agent architectures, focusing on planning algorithms."
)

// Access via summary property
println(summary.summary)

// Access via HasContent interface
println(summary.content)  // Same value

interface HasContent {
    val content: String
}

import com.embabel.agent.domain.library.*

fun processContent(item: HasContent) {
    val text = item.content
    println("Processing ${text.length} characters")
}

val summary = Summary("Brief summary")
processContent(summary)

val blog = Blog("Title", "Author", "Blog content")
processContent(blog)  // Also works

fun summarizeDocument(document: String): Summary {
    // In real agent, use LLM
    val summaryText = "Summary: ${document.take(100)}..."
    return Summary(summaryText)
}

val doc = "Long document content..."
val summary = summarizeDocument(doc)

data class Message(val speaker: String, val text: String)

fun summarizeConversation(messages: List<Message>): Summary {
    val speakers = messages.map { it.speaker }.distinct()
    val topicHints = messages.joinToString(" ") { it.text }.take(200)

    return Summary(
        "Conversation between ${speakers.joinToString(", ")}: $topicHints..."
    )
}

data class OperationResult(
    val success: Boolean,
    val itemsProcessed: Int,
    val errors: List<String>
)

fun summarizeOperation(result: OperationResult): Summary {
    val status = if (result.success) "successful" else "failed"
    val text = "Operation $status: ${result.itemsProcessed} items processed" +
               if (result.errors.isNotEmpty()) ", ${result.errors.size} errors" else ""

    return Summary(text)
}

val summaries = listOf(
    Summary("Chapter 1: Introduction"),
    Summary("Chapter 2: Planning algorithms"),
    Summary("Chapter 3: Integration")
)

// Combine summaries
val combined = Summary(
    summaries.joinToString("\n") { it.summary }
)

// Filter
val aiSummaries = summaries.filter { "AI" in it.summary }

// Map
val lengths = summaries.map { it.summary.length }

val s1 = Summary("This is a summary")
val s2 = Summary("This is a summary")
val s3 = Summary("Different")

// Structural equality
println(s1 == s2)  // true
println(s1 == s3)  // false

// Copy with modifications
val extended = s1.copy(
    summary = s1.summary + " with details"
)

// Destructuring
val (text) = s1

import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper

val mapper = jacksonObjectMapper()

val summary = Summary("Document covers agent fundamentals")

// Serialize
val json = mapper.writeValueAsString(summary)
// {"summary":"Document covers agent fundamentals"}

// Deserialize
val deserialized = mapper.readValue(json, Summary::class.java)
println(deserialized.content)  // Via HasContent

{
  "summary": "Document covers agent fundamentals"
}

import com.embabel.agent.domain.library.*

fun summarizeBlog(blog: Blog): Summary {
    return Summary(
        "Blog '${blog.title}' by ${blog.author}: ${blog.content.take(100)}..."
    )
}

fun summarizeResearch(report: ResearchReport): Summary {
    return Summary(
        "Research on '${report.topic}': ${report.content.take(200)}... " +
        "References ${report.links.size} sources."
    )
}

fun summarizeNews(stories: RelevantNewsStories): Summary {
    if (stories.items.isEmpty()) {
        return Summary("No news stories available")
    }
    val topics = stories.items.joinToString(", ") { it.title }
    return Summary("News covering ${stories.items.size} stories: $topics")
}

class DocumentProcessor {
    fun processDocument(document: String): Summary {
        val keyPoints = extractKeyPoints(document)
        val sectionSummaries = generateSectionSummaries(keyPoints)

        return Summary(
            "Document summary: ${sectionSummaries.joinToString("; ")}"
        )
    }

    private fun extractKeyPoints(doc: String): List<String> = listOf()
    private fun generateSectionSummaries(points: List<String>): List<String> = listOf()
}

data class AgentState(
    val currentTask: String,
    val progressSummary: Summary,
    val completedSteps: List<String>
)

fun updateProgress(state: AgentState, newStep: String): AgentState {
    val updatedSteps = state.completedSteps + newStep
    val newSummary = Summary(
        "Completed ${updatedSteps.size} steps: ${updatedSteps.joinToString(", ")}"
    )

    return state.copy(
        completedSteps = updatedSteps,
        progressSummary = newSummary
    )
}

fun createHierarchicalSummary(
    sections: List<String>
): Pair<List<Summary>, Summary> {
    // Summarize each section
    val sectionSummaries = sections.map { section ->
        Summary("Section: ${section.take(50)}...")
    }

    // Overall summary from sections
    val overall = Summary(
        sectionSummaries.joinToString("\n") { it.summary }
    )

    return Pair(sectionSummaries, overall)
}

HasContent (interface)
├── Summary
├── ContentAsset (interface)
│   ├── Blog
│   └── ResearchReport
└── (other types)