Threads & Replies

var parentMessage = await channel.SendNewMessageAsync("Starting a thread");

var reply = await channel.SendNewMessageAsync(new StreamSendMessageRequest
{
  ParentId = parentMessage.Id,
  ShowInChannel = false,
  Text = "This is a reply in a thread",
});

// Get the latest 20 replies (oldest-first)
var replies = await parentMessage.LoadRepliesAsync(limit: 20);

// Get older replies (before message with id "42")
var olderReplies = await parentMessage.LoadRepliesAsync(limit: 20, idLessThan: "42");

var message = await channel.SendNewMessageAsync(new StreamSendMessageRequest
{
  QuotedMessage = originalMessage,
  Text = "I agree with this point",
});

{
  "id": "new-message-id",
  "text": "I agree with this point",
  "quoted_message_id": "original-message-id",
  "quoted_message": {
    "id": "original-message-id",
    "text": "The original message text"
  }
}

var response = await Client.QueryThreadsAsync(new StreamQueryThreadsRequest
{
  Watch = true,
  Limit = 10,
});

foreach (var thread in response.Threads)
{
  // Threads are cached, watched and kept in sync with realtime events
  Debug.Log(thread.ParentMessage.Text);
  Debug.Log(thread.LatestReplies);
  Debug.Log(thread.ThreadParticipants);
  Debug.Log(thread.Read);
}

var since = new DateTimeOffset(2024, 1, 1, 0, 0, 0, TimeSpan.Zero);

var request = new StreamQueryThreadsRequest
{
  Filter = new IFieldFilterRule[]
  {
    ThreadFilter.CreatedByUserId.EqualsTo("user-1"),
    ThreadFilter.UpdatedAt.GreaterThanOrEquals(since),
  },
  Sort = ThreadSort.OrderByDescending(ThreadSortFieldName.CreatedAt),
  Limit = 10,
};

var page1 = await Client.QueryThreadsAsync(request);

// Get next page using the cursor returned by the previous response
if (!string.IsNullOrEmpty(page1.Next))
{
  request.Next = page1.Next;
  var page2 = await Client.QueryThreadsAsync(request);
}

// The returned IStreamThread is auto-watched (watch defaults to true) and stays in
// sync with realtime events via Updated / ReplyReceived / ReadStateChanged.
var thread = await Client.GetThreadAsync("parent-message-id",
    replyLimit: 10, participantLimit: 25);

var thread = await Client.GetThreadAsync("parent-message-id");

// Set title and custom fields; unset a previously set field
await thread.UpdatePartialAsync(
    setFields: new Dictionary<string, object>
    {
        { "title", "Project Discussion" },
        { "priority", "high" },
    },
    unsetFields: new[] { "priority" });

// Available immediately after connect on IStreamLocalUserData
var unreadThreads = Client.LocalUserData.UnreadThreads;
Debug.Log(unreadThreads);

// The same total is also available on demand from the server
var unreadCounts = await Client.GetLatestUnreadCountsAsync();
Debug.Log(unreadCounts.TotalUnreadThreadsCount);

var thread = await Client.GetThreadAsync("parent-message-id");

// Mark this thread as read for the local user
await thread.MarkReadAsync();

// Mark this thread as unread starting from the parent message
await thread.MarkUnreadAsync();

// Equivalent helpers from the parent message of the thread
IStreamMessage parentMessage = thread.ParentMessage;
await parentMessage.MarkThreadAsReadAsync();
await parentMessage.MarkThreadAsUnreadAsync();

// Or by parent message id when you already have the channel
await thread.Channel.MarkThreadAsReadAsync(thread.ParentMessageId);
await thread.Channel.MarkThreadAsUnreadAsync(thread.ParentMessageId);

var unreadCounts = await Client.GetLatestUnreadCountsAsync();

Debug.Log(unreadCounts.TotalUnreadThreadsCount);

foreach (var thread in unreadCounts.UnreadThreads)
{
  Debug.Log(thread.ParentMessageId);
  Debug.Log(thread.UnreadCount);
  Debug.Log(thread.LastRead);
  Debug.Log(thread.LastReadMessageId);
}

// Get notified when a thread starts or stops being tracked locally
Client.ThreadTracked += thread => { /* a new IStreamThread is now tracked */ };
Client.ThreadUntracked += thread => { /* an IStreamThread is no longer tracked */ };

// Load threads. Watch defaults to true so realtime updates are delivered.
var response = await Client.QueryThreadsAsync(new StreamQueryThreadsRequest
{
  Watch = true,
  Limit = 10,
});

// Each returned IStreamThread is stateful: it is cached and kept in sync with
// realtime events automatically. Subscribe to per-thread events to react to
// changes (e.g. new replies, title / custom data updates, read state changes).
foreach (var thread in response.Threads)
{
  thread.Updated += changedThread => { /* title or custom data changed */ };
  thread.ReplyReceived += (changedThread, reply) => { /* new reply arrived */ };
  thread.ReadStateChanged += changedThread => { /* unread state changed */ };
}

const { threads } = await client.queryThreads({ watch: true, limit: 10 });
const [thread] = threads;

// Register event handlers for a single thread
thread.registerSubscriptions();

const unsubscribe = thread.state.subscribe((state) => {
  console.log(state.replies);
});

const threadManager = client.threads;
threadManager.registerSubscriptions();

await threadManager.loadNextPage();

// All threads are now listening to channel events
const { threads } = threadManager.state.getLatestValue();