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

// Start a conversation - system prompt is automatically included
agent.chat("My name is Alice").collect { event ->
    // Handle streaming events
}

// Continue conversation - previous context is automatically included
agent.chat("What's my name?").collect { event ->
    // Agent has full context from previous messages
}

// Different conversation threads maintain separate histories
agent.chat("Let's talk about cooking", threadId = "cooking").collect { }
agent.chat("What about baking?", threadId = "cooking").collect { }

agent.chat("I need tech support", threadId = "support").collect { }
agent.chat("My issue is urgent", threadId = "support").collect { }

// Each thread maintains its own complete history

// Chat agent with system prompt
val agent = chatAgent(
    url = "https://api.example.com/agent",
    systemPrompt = "You are a helpful customer service agent"
) {
    bearerToken = "your-token"
}

// Stateful agent with initial state
val agent = statefulAgent(
    url = "https://api.example.com/agent",
    initialState = buildJsonObject {
        put("userType", "premium")
        put("language", "en")
    }
) {
    bearerToken = "your-token"
    systemPrompt = "You are a premium support agent"
}

val agent = StatefulAgUiAgent("https://api.example.com/agent") {
    // Authentication (choose one)
    bearerToken = "your-bearer-token"
    // OR
    apiKey = "your-api-key"
    // OR
    basicAuth("username", "password")

    // System prompt (automatically included in conversations)
    systemPrompt = "You are a customer service assistant"

    // Optional user ID
    userId = "user-123"
}

val agent = StatefulAgUiAgent("https://api.example.com/agent") {
    bearerToken = "your-token"
    systemPrompt = "You are a helpful assistant"

    // History management - automatic trimming when exceeded
    maxHistoryLength = 50  // Limit to 50 messages per thread (0 = unlimited)

    // Initial state (sent with first message)
    initialState = buildJsonObject {
        put("userPreferences", buildJsonObject {
            put("language", "en")
            put("timezone", "UTC")
        })
    }

    // Networking options
    requestTimeout = 30.seconds
    debug = true
}

fun chat(
    message: String,
    threadId: String = "default"
): Flow<BaseEvent>

agent.chat("Hello, I need help").collect { event ->
    when (event) {
        is TextMessageStartEvent -> {
            println("Agent started responding (ID: ${event.messageId})")
        }
        is TextMessageContentEvent -> {
            print(event.delta) // Print each chunk as it arrives
        }
        is TextMessageEndEvent -> {
            println("\nAgent finished responding")
        }
        is ToolCallStartEvent -> {
            println("Agent is calling tool: ${event.toolCallName}")
        }
        // Handle other events as needed
    }
}

fun getHistory(threadId: String = "default"): List<Message>

// Check conversation history
val history = agent.getHistory("support")
history.forEach { message ->
    println("${message.role}: ${message.content}")
}

fun clearHistory(threadId: String? = null)

// Clear specific thread
agent.clearHistory("support")

// Clear all conversation history
agent.clearHistory()

val agent = StatefulAgUiAgent(url) {
    systemPrompt = "You are a helpful assistant"
}

// First message - sends: [SystemMessage, UserMessage]
agent.chat("Hello").collect { }

// Second message - sends: [SystemMessage, UserMessage("Hello"), AssistantMessage("Hi there!"), UserMessage("How are you?")]
agent.chat("How are you?").collect { }

val agent = StatefulAgUiAgent(url) {
    bearerToken = token

    // Automatically trim when exceeded
    maxHistoryLength = 20
}

// When limit is reached, oldest messages are automatically removed
// (system message is always preserved)
repeat(30) { i ->
    agent.chat("Message $i").collect { }
}
// Only the most recent 20 messages are kept automatically

// Customer service thread
agent.chat("I have a billing question", threadId = "billing").collect { }
agent.chat("What's my current balance?", threadId = "billing").collect { }

// Technical support thread (completely separate history)
agent.chat("My app is crashing", threadId = "tech-support").collect { }
agent.chat("It happens on startup", threadId = "tech-support").collect { }

// Start new conversation thread
val threadId = "session-${UUID.randomUUID()}"

agent.chat("Start new session", threadId = threadId).collect { }
// ... more conversation ...

// Clean up when conversation session ends
agent.clearHistory(threadId)

agent.chat("Hello").collect { event ->
    when (event) {
        is ErrorEvent -> {
            println("Error: ${event.error}")
            // History is preserved in memory even if request fails
        }
        // Handle success events
    }
}

// Set reasonable history limits - automatic trimming handles the rest
val agent = StatefulAgUiAgent(url) {
    bearerToken = token
    maxHistoryLength = 100  // Automatically managed
}

// Only clear manually when ending conversation sessions
agent.clearHistory("completed-session")

// Use meaningful thread IDs for different conversation contexts
val userId = getCurrentUserId()
val sessionId = "user-${userId}-${System.currentTimeMillis()}"

agent.chat("Start session", threadId = sessionId).collect { }