dependencies {
    // Complete SDK with all modules (recommended)
    implementation("com.agui:kotlin-client:0.2.1")
}

dependencies {
    // Core protocol types only (advanced)
    implementation("com.agui:kotlin-core:0.2.1")

    // Tools framework only (advanced)
    implementation("com.agui:kotlin-tools:0.2.1")
}

// Create a stateless agent
val agent = AgUiAgent("https://your-agent-api.com/agent") {
    bearerToken = "your-api-token"
    systemPrompt = "You are a helpful AI assistant"
}

// Send a message and receive streaming responses
agent.sendMessage("What's the weather like?").collect { state ->
    println("State updated: $state")
}

// Create a stateful agent for conversations
val chatAgent = StatefulAgUiAgent("https://your-agent-api.com/agent") {
    bearerToken = "your-api-token"
    systemPrompt = "You are a friendly conversational AI"
}

// Have a conversation with context
chatAgent.chat("Hello!").collect { /* ... */ }
chatAgent.chat("What's my name?").collect { state ->
    // Agent remembers previous context
}

// Create an agent with client-side tools
val agent = agentWithTools(
    url = "https://your-agent-api.com/agent",
    toolRegistry = toolRegistry {
        addTool(WeatherToolExecutor())    // Executes locally on client
        addTool(CalculatorToolExecutor()) // Executes locally on client
    }
) {
    bearerToken = "your-api-token"
}

// Agent can request client-side tool execution during conversation
agent.sendMessage("What's 15% tip on $85.50?").collect { state ->
    // Agent requests calculator tool, which runs locally on the client
}

// Bearer Token
AgUiAgent(url) {
    bearerToken = "your-token"
}

// API Key
AgUiAgent(url) {
    apiKey = "your-api-key"
}

// Basic Auth
AgUiAgent(url) {
    basicAuth("username", "password")
}

agent.sendMessage("Hello").collect { state ->
    state.errors.forEach { error ->
        println("Error: ${error.message}")
    }
}

// Access current state
val currentState = agent.currentState
println("Messages: ${currentState.messages.size}")

// Monitor state changes
agent.sendMessage("Hello").collect { state ->
    println("Updated state: ${state.messages.last()}")
}

// RAW and CUSTOM protocol events are surfaced for inspection
state.rawEvents?.forEach { raw ->
    println("Raw event from ${raw.source ?: "unknown"}: ${raw.event}")
}
state.customEvents?.forEach { custom ->
    println("Custom event ${custom.name}: ${custom.value}")
}

// Thinking telemetry stream
state.thinking?.let { thinking ->
    if (thinking.isThinking) {
        val latest = thinking.messages.lastOrNull().orEmpty()
        println("Agent is thinking: $latest")
    } else if (thinking.messages.isNotEmpty()) {
        println("Agent finished thinking: ${thinking.messages.joinToString()}")
    }
}