Quickstart

import { AIClientIdentity } from "stream-chat-react/ai-components";

const chat = new AgentChat<LocalMessage>({
  sessionId,
  open: (id) =>
    id ? sessions.resume(id, { tools }) : sessions.create({ tools }),
});
const conversation = new AIConversationController({
  transport: agentChatTransport(chat, {
    adapt: (message, reasoningText) =>
      fromStreamMessage(message, { reasoningText }),
  }),
  actions: { edit: false, regenerate: false },
  approver: {
    userId: "jlahey",
    clientId: AIClientIdentity.installId(),
    decide: async (call, allowed) =>
      (await chat.session()).decide(call.id, { allowed }),
  },
});

28 importsimport androidx.activity.compose.setContent
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.lifecycle.lifecycleScope
import io.getstream.chat.android.ai.compose.conversation.AIAgentActivity
import io.getstream.chat.android.ai.compose.conversation.AIConversationFeed
import io.getstream.chat.android.ai.compose.conversation.AIConversationRequest
import io.getstream.chat.android.ai.compose.conversation.AIConversationState
import io.getstream.chat.android.ai.compose.conversation.AIConversationTransport
import io.getstream.chat.android.ai.compose.conversation.AIMessage
import io.getstream.chat.android.ai.compose.conversation.AIMessageRole
import io.getstream.chat.android.ai.compose.parts.AIClientIdentity
import io.getstream.chat.android.ai.compose.parts.AIMessagePart
import io.getstream.chat.android.ai.compose.ui.component.AIConversation
import io.getstream.chat.android.ai.compose.ui.component.AIToolApprover
import io.getstream.chat.android.ai.compose.ui.component.ChatComposer
import io.getstream.chat.android.client.channel.state.ChannelState
import io.getstream.chat.android.models.Message
import io.getstream.agents.android.core.AgentEvent
import io.getstream.agents.android.core.AgentSession
import io.getstream.agents.android.core.Conversation
import io.getstream.agents.android.core.channelState
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.launch

// In your activity, once the user is signed in as in step 3.
lifecycleScope.launch {
    val session = startSession()
    // Connects to Stream Chat as the user set above and watches the session's channel.
    val channel = session.channelState(this@MainActivity, lifecycleScope)
    // The user set above, who answers the calls the agent addresses to them.
    val approver = AIToolApprover("jlahey", AIClientIdentity.installId(this@MainActivity), lifecycleScope) { call, allowed ->
        session.decide(call.id, allowed)
    }
    val conversation = AIConversationState(AgentTransport(session, channel, lifecycleScope), lifecycleScope, approver)
    setContent { AgentConversation(conversation, Modifier.fillMaxSize()) }
}

@Composable
fun AgentConversation(conversation: AIConversationState<AgentMessage>, modifier: Modifier = Modifier) {
    Column(modifier) {
        // Each question moves to the top, and its reply streams in below it with its
        // reasoning and tool calls. While the agent answers, the composer shows a Stop button.
        AIConversation(state = conversation, modifier = Modifier.weight(1f))
        ChatComposer(state = conversation)
    }
}

/** Connects the AI components to the session: they show its channel, and ask the session. */
class AgentTransport(
    val session: AgentSession,
    private val channel: StateFlow<ChannelState?>,
    private val scope: CoroutineScope,
) : AIConversationTransport<AgentMessage> {

    override fun connect(feed: AIConversationFeed<AgentMessage>) {
        // The channel's messages, oldest first, as Stream Chat keeps them up to date.
        scope.launch {
            channel.collectLatest { state ->
                state?.messages?.collect { messages ->
                    feed.update(messages.filter { it.deletedAt == null }.map(::AgentMessage))
                }
            }
        }
        // What the agent is doing while its reply shows nothing yet.
        scope.launch {
            session.conversation.collect { conversation ->
                feed.update(
                    activity = when (val state = conversation.state) {
                        Conversation.State.Responding -> AIAgentActivity(AIAgentActivity.State.Thinking)
                        is Conversation.State.Working -> AIAgentActivity(
                            AIAgentActivity.State.CheckingExternalSources,
                            "Working on " + state.skills.joinToString(" and "),
                        )
                        else -> null
                    },
                )
            }
        }
        // A reply the model couldn't write leaves nothing in the channel: only the session says so.
        scope.launch {
            session.events().collect { event ->
                if (event.kind == AgentEvent.Kind.Error && event.string("context") in setOf("llm", "sts")) {
                    feed.update(activity = AIAgentActivity(AIAgentActivity.State.Error))
                }
            }
        }
    }

    // The agent does not answer a message sent to the channel: ask the session.
    override suspend fun send(request: AIConversationRequest<AgentMessage>) {
        session.responses.create(request.text)
    }

    override suspend fun stop() {
        session.interrupt()
    }
}

/** A message of the channel, as the AI components show it. */
data class AgentMessage(val message: Message) : AIMessage {
    override val id: String = message.id
    // The agent's replies carry `ai_generated: true`.
    override val role: AIMessageRole =
        if (message.extraData["ai_generated"] == true) AIMessageRole.Assistant else AIMessageRole.User
    override val text: String = message.text
    override val isGenerating: Boolean = message.extraData["generating"] == true
    // The reply's reasoning and tool calls, which the router writes as its attachments. Stream Chat
    // lifts `name` out of an attachment's fields, and a tool call's step needs it back.
    override val parts: List<AIMessagePart> = AIMessagePart.parts(
        message.attachments.map { it.type.orEmpty() to it.extraData + ("name" to it.name) },
    )
}

import Combine
import StreamChat
import StreamChatAI
import SwiftUI
import StreamAgents

/// Opens a session with the agent, and shows it once its channel is open.
struct AgentScreen: View {
    @State private var transport: AgentTransport?
    @State private var failure: Error?

    var body: some View {
        if let transport {
            AgentConversation(transport: transport)
        } else if let failure {
            // Such as a CLI token that expired after its 2 hours: mint a new one.
            VStack(spacing: 16) {
                Text(failure.localizedDescription)
                Button("Try again") { self.failure = nil }
            }
            .padding()
        } else {
            ProgressView()
                .task {
                    do {
                        transport = try await AgentTransport(startSession())
                    } catch {
                        failure = error
                    }
                }
        }
    }
}

struct AgentConversation: View {
    @StateObject private var conversation: AIConversation<AgentMessage>

    init(transport: AgentTransport) {
        // Rating only: regenerating or editing would ask the agent again, and show the question twice.
        _conversation = StateObject(
            wrappedValue: AIConversation(transport: transport, approver: transport.approver, actions: [.rate])
        )
    }

    var body: some View {
        // Each question moves to the top, and its reply streams in below it with its
        // reasoning and tool calls. While the agent writes, the composer shows a Stop button.
        AIConversationView(conversation: conversation)
            .safeAreaInset(edge: .bottom) {
                AIComposerView(conversation: conversation)
            }
    }
}

/// Connects the AI components to the session: they show its channel, and ask the session.
@MainActor
final class AgentTransport: AIConversationTransport {
    let session: AgentSession
    private let channel: ChatChannelController
    private var subscription: AnyCancellable?

    init(_ session: AgentSession) async throws {
        self.session = session
        // `session.chat()` connects to Stream Chat as the user set above and opens the session's channel.
        channel = try await session.chat()
        // The session's socket, which stops a reply and runs the tools this phone offers.
        await session.start()
    }

    func connect(_ feed: AIConversationFeed<AgentMessage>) {
        // The channel lists its messages newest first, the conversation oldest first.
        let publish = { [channel] in
            feed.update(messages: channel.messages.reversed().map(AgentMessage.init))
        }
        subscription = channel.messagesChangesPublisher.sink { _ in publish() }
        channel.synchronize { _ in publish() }
    }

    // The agent does not answer a message sent to the channel: ask the session.
    func send(_ request: AIConversationRequest<AgentMessage>) async throws {
        _ = try await session.responses.create(request.text)
    }

    func stop() async throws {
        try await session.interrupt()
    }

    /// Answers the tools that ask before they run.
    var approver: AIToolApprover {
        AIToolApprover(userID: agents.backend.user?.id ?? "", clientID: AIClientIdentity.installID) { call, allowed in
            try await self.session.decide(call.id, allowed: allowed)
        }
    }
}

/// A message of the channel, as the AI components show it.
struct AgentMessage: AIMessage {
    let message: ChatMessage

    var id: MessageId { message.id }
    // The agent's replies carry `ai_generated: true`.
    var role: AIMessageRole {
        message.extraData["ai_generated"]?.boolValue == true ? .assistant : .user
    }
    var text: String { message.text }
    var isGenerating: Bool { message.extraData["generating"]?.boolValue == true }
    // The reply's reasoning and tool calls, which the router writes as its attachments.
    var parts: [AIMessagePart] {
        AIMessagePart.parts(from: message.allAttachments.map { ($0.type.rawValue, $0.payload) })
    }
}