Threads & Replies

var resp = await chat.SendMessageAsync("messaging", channelId,
    new SendMessageRequest
    {
        Message = new MessageRequest
        {
            Text = "This is a reply in a thread",
            UserID = userId,
            ParentID = parentMessageId
        }
    });

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 first 20 replies
var resp = await chat.GetRepliesAsync(parentMessageId, new { limit = 20 });

// Get older replies
var olderResp = await chat.GetRepliesAsync(parentMessageId, new { limit = 20, id_lte = "42" });

// 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 resp = await chat.SendMessageAsync("messaging", channelId,
    new SendMessageRequest
    {
        Message = new MessageRequest
        {
            Text = "I agree with this point",
            UserID = userId,
            QuotedMessageID = originalMessageId
        }
    });

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

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 resp = await chat.QueryThreadsAsync(new QueryThreadsRequest
{
    Filter = new Dictionary<string, object>
    {
        { "created_by_user_id", new Dictionary<string, object> { { "$eq", "user-1" } } },
        { "updated_at", new Dictionary<string, object> { { "$gte", "2024-01-01T00:00:00Z" } } },
    },
    Sort = new List<SortParamRequest>
    {
        new SortParamRequest { Field = "created_at", Direction = -1 }
    },
    Limit = 10,
    UserID = userId
});

// Get next page
if (resp.Data.Next != null)
{
    var nextPage = await chat.QueryThreadsAsync(new QueryThreadsRequest
    {
        Filter = new Dictionary<string, object>
        {
            { "created_by_user_id", new Dictionary<string, object> { { "$eq", "user-1" } } },
            { "updated_at", new Dictionary<string, object> { { "$gte", "2024-01-01T00:00:00Z" } } },
        },
        Sort = new List<SortParamRequest>
        {
            new SortParamRequest { Field = "created_at", Direction = -1 }
        },
        Limit = 10,
        UserID = userId,
        Next = resp.Data.Next
    });
}

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 */ };
}