diff --git a/SlackNet.Tests/AgentSessionStoppedTests.cs b/SlackNet.Tests/AgentSessionStoppedTests.cs
new file mode 100644
index 00000000..ece16696
--- /dev/null
+++ b/SlackNet.Tests/AgentSessionStoppedTests.cs
@@ -0,0 +1,49 @@
+using EasyAssertions;
+using Newtonsoft.Json;
+using NUnit.Framework;
+using SlackNet.Events;
+
+namespace SlackNet.Tests;
+
+public class AgentSessionStoppedTests
+{
+    private JsonSerializerSettings _sut;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _sut = Default.JsonSettings(Default.SlackTypeResolver(Default.AssembliesContainingSlackTypes)).SerializerSettings;
+    }
+
+    [Test]
+    public void AgentSessionStopped_DeserializedFromSlackPayload()
+    {
+        var result = Deserialize<Event>(@"{ ""channel"": ""C0123ABC456"", ""event_ts"": ""1783536983.783769"", ""streaming_message_ts"": [""1782234987.693923""], ""thread_ts"": ""1782234671.392669"", ""type"": ""agent_session_stopped"", ""user"": ""U123ABC456"" }");
+
+        var stopped = result.ShouldBeA<AgentSessionStopped>().And;
+        stopped.Channel.ShouldBe("C0123ABC456");
+        stopped.ThreadTs.ShouldBe("1782234671.392669");
+        stopped.User.ShouldBe("U123ABC456");
+        stopped.StreamingMessageTs.ShouldMatch(["1782234987.693923"]);
+        stopped.EventTs.ShouldBe("1783536983.783769");
+        stopped.ExtraProperties.ShouldBeEmpty();
+    }
+
+    [Test]
+    public void AgentSessionStopped_NoActiveStream_HasEmptyStreamingMessageTs()
+    {
+        var result = Deserialize<Event>(@"{ ""type"": ""agent_session_stopped"", ""channel"": ""C1"", ""thread_ts"": ""1.2"", ""user"": ""U1"", ""streaming_message_ts"": [] }");
+
+        result.ShouldBeA<AgentSessionStopped>().And.StreamingMessageTs.ShouldBeEmpty();
+    }
+
+    [Test]
+    public void AgentSessionStopped_InSessionChannel_MayHaveNoThread()
+    {
+        var result = Deserialize<Event>(@"{ ""type"": ""agent_session_stopped"", ""channel"": ""C1"", ""user"": ""U1"", ""streaming_message_ts"": [] }");
+
+        result.ShouldBeA<AgentSessionStopped>().And.ThreadTs.ShouldBeNull();
+    }
+
+    private T Deserialize<T>(string json) => JsonConvert.DeserializeObject<T>(json, _sut);
+}
\ No newline at end of file
diff --git a/SlackNet.Tests/AgentsSessionsApiTests.cs b/SlackNet.Tests/AgentsSessionsApiTests.cs
new file mode 100644
index 00000000..34196377
--- /dev/null
+++ b/SlackNet.Tests/AgentsSessionsApiTests.cs
@@ -0,0 +1,62 @@
+using System.Threading.Tasks;
+using EasyAssertions;
+using Newtonsoft.Json.Linq;
+using NUnit.Framework;
+using SlackNet.WebApi;
+
+namespace SlackNet.Tests;
+
+public class AgentsSessionsApiTests
+{
+    private TestHttp _http;
+    private ISlackApiClient _sut;
+
+    [SetUp]
+    public void SetUp()
+    {
+        var jsonSettings = Default.JsonSettings(Default.SlackTypeResolver(Default.AssembliesContainingSlackTypes));
+        _http = new TestHttp();
+        _sut = new SlackApiClient(_http, Default.UrlBuilder(jsonSettings), jsonSettings, "token");
+    }
+
+    [Test]
+    public async Task SetStatus_SendsSessionArguments()
+    {
+        await _sut.AgentsSessions.SetStatus("C123", "1717171717.123456", AgentSessionStatus.Processing,
+            title: "Scuba diving research", initiatorUserId: "U123", iconEmoji: ":robot_face:", username: "Custom Agent Name");
+
+        _http.Method.ShouldBe("agents.sessions.setStatus");
+        _http.Body.ShouldMatchJson(@"{ ""channel_id"": ""C123"", ""thread_ts"": ""1717171717.123456"", ""status"": ""processing"", ""title"": ""Scuba diving research"", ""initiator_user_id"": ""U123"", ""icon_emoji"": "":robot_face:"", ""username"": ""Custom Agent Name"" }");
+    }
+
+    [TestCase(AgentSessionStatus.Active, "active")]
+    [TestCase(AgentSessionStatus.Processing, "processing")]
+    [TestCase(AgentSessionStatus.Suspended, "suspended")]
+    [TestCase(AgentSessionStatus.Closed, "closed")]
+    public async Task SetStatus_SendsStatusInSlackCase(AgentSessionStatus status, string expected)
+    {
+        await _sut.AgentsSessions.SetStatus("C123", "1717171717.123456", status);
+
+        _http.Body.ShouldMatchJson(@"{ ""channel_id"": ""C123"", ""thread_ts"": ""1717171717.123456"", ""status"": """ + expected + @""" }");
+    }
+
+    [Test]
+    public async Task SetStatus_InSessionChannel_OmitsThreadTs()
+    {
+        await _sut.AgentsSessions.SetStatus("C123", null, AgentSessionStatus.Active);
+
+        _http.Body.ShouldMatchJson(@"{ ""channel_id"": ""C123"", ""status"": ""active"" }");
+    }
+
+    [Test]
+    public async Task SetStatus_ReadsSessionStatusAndAgentStatus()
+    {
+        _http.Response = JObject.Parse(@"{ ""ok"": true, ""status"": ""processing"", ""agent_status"": ""active"", ""title"": ""Scuba diving research"" }");
+
+        var result = await _sut.AgentsSessions.SetStatus("C123", "1717171717.123456", AgentSessionStatus.Active);
+
+        result.Status.ShouldBe(AgentSessionStatus.Processing);
+        result.AgentStatus.ShouldBe(AgentSessionStatus.Active);
+        result.Title.ShouldBe("Scuba diving research");
+    }
+}
\ No newline at end of file
diff --git a/SlackNet.Tests/ApiLintTests.cs b/SlackNet.Tests/ApiLintTests.cs
index fd4584af..708a6d44 100644
--- a/SlackNet.Tests/ApiLintTests.cs
+++ b/SlackNet.Tests/ApiLintTests.cs
@@ -231,6 +231,10 @@ private static object DummyValue(ParameterInfo param) => ArgumentFactories.TryGe
             { typeof(UnfurlMetadata), _ => null },
             { typeof(WorkObjectEntity), _ => null },
             { typeof(EntityError), _ => null },
+            { typeof(IEnumerable<StreamChunk>), _ => Enumerable.Empty<StreamChunk>() },
+            { typeof(AgentSessionStatus), _ => AgentSessionStatus.Active },
+            { typeof(AgentSessionStatus?), _ => null },
+            { typeof(TaskDisplayMode?), _ => null },
             { typeof(CancellationToken), _ => null },
         };
 
@@ -293,6 +297,7 @@ public Task<T> Post<T>(string apiMethod, Args args, HttpContent content, Cancell
 
         public ISlackApiClient WithAccessToken(string accessToken) => this;
 
+        public IAgentsSessionsApi AgentsSessions { get; }
         public IApiApi Api { get; }
         public IAppsConnectionsApi AppsConnectionsApi { get; }
         public IAppsEventAuthorizationsApi AppsEventAuthorizations { get; }
diff --git a/SlackNet.Tests/BlockLintTests.cs b/SlackNet.Tests/BlockLintTests.cs
index 9e66326f..cab373fd 100644
--- a/SlackNet.Tests/BlockLintTests.cs
+++ b/SlackNet.Tests/BlockLintTests.cs
@@ -25,7 +25,8 @@ public void AllBlockElementsHaveACorrespondingElementValue()
     static readonly HashSet<string> ExcludedBlockElements =
         [
             "button",
-            "image"
+            "image",
+            "url"
         ];
 
     [Test]
diff --git a/SlackNet.Tests/Configuration/FactorySlackHandlerConfigurationTests.cs b/SlackNet.Tests/Configuration/FactorySlackHandlerConfigurationTests.cs
index 89ef746b..94327e94 100644
--- a/SlackNet.Tests/Configuration/FactorySlackHandlerConfigurationTests.cs
+++ b/SlackNet.Tests/Configuration/FactorySlackHandlerConfigurationTests.cs
@@ -878,6 +878,7 @@ protected class TestHandlerFactory : ISlackHandlerFactory
 
     protected class TestApiClient : ISlackApiClient
     {
+        public IAgentsSessionsApi AgentsSessions { get; }
         public IApiApi Api { get; }
         public IAppsConnectionsApi AppsConnectionsApi { get; }
         public IAppsEventAuthorizationsApi AppsEventAuthorizations { get; }
diff --git a/SlackNet.Tests/StreamingApiTests.cs b/SlackNet.Tests/StreamingApiTests.cs
new file mode 100644
index 00000000..19a5b2e8
--- /dev/null
+++ b/SlackNet.Tests/StreamingApiTests.cs
@@ -0,0 +1,157 @@
+using System.Threading.Tasks;
+using EasyAssertions;
+using Newtonsoft.Json.Linq;
+using NUnit.Framework;
+using SlackNet.Blocks;
+using SlackNet.WebApi;
+
+namespace SlackNet.Tests;
+
+public class StreamingApiTests
+{
+    private TestHttp _http;
+    private ISlackApiClient _sut;
+
+    [SetUp]
+    public void SetUp()
+    {
+        var jsonSettings = Default.JsonSettings(Default.SlackTypeResolver(Default.AssembliesContainingSlackTypes));
+        _http = new TestHttp();
+        _sut = new SlackApiClient(_http, Default.UrlBuilder(jsonSettings), jsonSettings, "token");
+    }
+
+    [Test]
+    public async Task StartStream_WithMarkdownText_SendsOnlyTheMarkdownArguments()
+    {
+        await _sut.Chat.StartStream("C123", "1717171717.123456", "Hello", recipientUserId: "U123", recipientTeamId: "T123");
+
+        _http.Method.ShouldBe("chat.startStream");
+        _http.Body.ShouldMatchJson(@"{ ""channel"": ""C123"", ""thread_ts"": ""1717171717.123456"", ""markdown_text"": ""Hello"", ""recipient_user_id"": ""U123"", ""recipient_team_id"": ""T123"" }");
+    }
+
+    [Test]
+    public async Task StartStream_WithChunks_SendsChunksAndTaskDisplayMode()
+    {
+        await _sut.Chat.StartStream("C123", "1717171717.123456",
+            chunks:
+            [
+                new MarkdownTextChunk { Text = "Let me help you with that!" },
+                new TaskUpdateChunk { Id = "t1", Title = "Searching", Status = TaskCardStatus.InProgress }
+            ],
+            taskDisplayMode: TaskDisplayMode.Plan,
+            iconEmoji: ":robot_face:",
+            iconUrl: "https://example.com/icon.png",
+            username: "Agent");
+
+        _http.Body.ShouldMatchJson(@"{
+            ""channel"": ""C123"",
+            ""thread_ts"": ""1717171717.123456"",
+            ""chunks"": [
+                { ""type"": ""markdown_text"", ""text"": ""Let me help you with that!"" },
+                { ""type"": ""task_update"", ""id"": ""t1"", ""title"": ""Searching"", ""status"": ""in_progress"" }
+            ],
+            ""task_display_mode"": ""plan"",
+            ""icon_emoji"": "":robot_face:"",
+            ""icon_url"": ""https://example.com/icon.png"",
+            ""username"": ""Agent""
+        }");
+    }
+
+    [Test]
+    public async Task AppendStream_WithMarkdownText_SendsOnlyTheMarkdownArguments()
+    {
+        await _sut.Chat.AppendStream("C123", "1503435956.000247", "more");
+
+        _http.Method.ShouldBe("chat.appendStream");
+        _http.Body.ShouldMatchJson(@"{ ""channel"": ""C123"", ""ts"": ""1503435956.000247"", ""markdown_text"": ""more"" }");
+    }
+
+    [Test]
+    public async Task AppendStream_WithChunks_SendsEveryKindOfChunk()
+    {
+        await _sut.Chat.AppendStream("C123", "1503435956.000247", chunks:
+        [
+            new MarkdownTextChunk { Text = "Here's what I found..." },
+            new TaskUpdateChunk
+                {
+                    Id = "t1",
+                    Title = "Remind Sandra how amazing she is",
+                    HideTitle = false,
+                    Status = TaskCardStatus.Complete,
+                    Details = "wow such good details",
+                    Output = "amazing output here",
+                    Sources = [new UrlSourceElement { Text = "Example.com", Url = "https://example.com" }]
+                },
+            new PlanUpdateChunk { Title = "Sandra's new and improved plan" },
+            new BlocksChunk { Blocks = [new MarkdownBlock { Text = "**Sandra's plan outline**" }] }
+        ]);
+
+        _http.Body.ShouldMatchJson(@"{
+            ""channel"": ""C123"",
+            ""ts"": ""1503435956.000247"",
+            ""chunks"": [
+                { ""type"": ""markdown_text"", ""text"": ""Here's what I found..."" },
+                {
+                    ""type"": ""task_update"",
+                    ""id"": ""t1"",
+                    ""title"": ""Remind Sandra how amazing she is"",
+                    ""hide_title"": false,
+                    ""status"": ""complete"",
+                    ""details"": ""wow such good details"",
+                    ""output"": ""amazing output here"",
+                    ""sources"": [ { ""type"": ""url"", ""url"": ""https://example.com"", ""text"": ""Example.com"" } ]
+                },
+                { ""type"": ""plan_update"", ""title"": ""Sandra's new and improved plan"" },
+                { ""type"": ""blocks"", ""blocks"": [ { ""type"": ""markdown"", ""text"": ""**Sandra's plan outline**"" } ] }
+            ]
+        }");
+    }
+
+    [Test]
+    public async Task TaskUpdateChunk_WithIcon_SendsIcon()
+    {
+        await _sut.Chat.AppendStream("C123", "1503435956.000247", chunks: [new TaskUpdateChunk { Id = "t1", Title = "Task", Status = TaskCardStatus.InProgress, Icon = new TaskCardIcon { Name = "bug" } }]);
+
+        _http.Body.ShouldMatchJson(@"{ ""channel"": ""C123"", ""ts"": ""1503435956.000247"", ""chunks"": [ { ""type"": ""task_update"", ""id"": ""t1"", ""title"": ""Task"", ""status"": ""in_progress"", ""icon"": { ""type"": ""icon"", ""name"": ""bug"" } } ] }");
+    }
+
+    [TestCase(TaskCardStatus.Pending, "pending")]
+    [TestCase(TaskCardStatus.InProgress, "in_progress")]
+    [TestCase(TaskCardStatus.Complete, "complete")]
+    [TestCase(TaskCardStatus.Error, "error")]
+    public async Task TaskUpdateChunk_SendsStatusInSlackCase(TaskCardStatus status, string expected)
+    {
+        await _sut.Chat.AppendStream("C123", "1503435956.000247", chunks: [new TaskUpdateChunk { Id = "t1", Title = "Task", Status = status }]);
+
+        ((string)_http.Body["chunks"][0]["status"]).ShouldBe(expected);
+    }
+
+    [Test]
+    public async Task StopStream_WithoutChunksOrSessionStatus_SendsOnlyTheMarkdownAndBlocks()
+    {
+        await _sut.Chat.StopStream("C123", "1503435956.000247", "done", blocks: [new MarkdownBlock { Text = "footer" }]);
+
+        _http.Method.ShouldBe("chat.stopStream");
+        _http.Body.ShouldMatchJson(@"{ ""channel"": ""C123"", ""ts"": ""1503435956.000247"", ""markdown_text"": ""done"", ""blocks"": [ { ""type"": ""markdown"", ""text"": ""footer"" } ] }");
+    }
+
+    [Test]
+    public async Task StopStream_WithChunksAndSessionStatus_SendsThem()
+    {
+        await _sut.Chat.StopStream("C123", "1503435956.000247",
+            chunks: [new MarkdownTextChunk { Text = "Hope this helps!" }],
+            sessionStatus: AgentSessionStatus.Suspended);
+
+        _http.Body.ShouldMatchJson(@"{ ""channel"": ""C123"", ""ts"": ""1503435956.000247"", ""chunks"": [ { ""type"": ""markdown_text"", ""text"": ""Hope this helps!"" } ], ""session_status"": ""suspended"" }");
+    }
+
+    [Test]
+    public void AppendStream_StoppedByUser_ThrowsSlackExceptionWithErrorCode()
+    {
+        _http.Response = JObject.Parse(@"{ ""ok"": false, ""error"": ""stopped_by_user"" }");
+
+        var exception = Assert.ThrowsAsync<SlackException>(() => _sut.Chat.AppendStream("C123", "1503435956.000247", "more"));
+
+        exception.ErrorCode.ShouldBe("stopped_by_user");
+    }
+}
\ No newline at end of file
diff --git a/SlackNet.Tests/TaskBlockTests.cs b/SlackNet.Tests/TaskBlockTests.cs
new file mode 100644
index 00000000..96625048
--- /dev/null
+++ b/SlackNet.Tests/TaskBlockTests.cs
@@ -0,0 +1,119 @@
+using EasyAssertions;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using NUnit.Framework;
+using SlackNet.Blocks;
+
+namespace SlackNet.Tests;
+
+public class TaskBlockTests
+{
+    private JsonSerializerSettings _sut;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _sut = Default.JsonSettings(Default.SlackTypeResolver(Default.AssembliesContainingSlackTypes)).SerializerSettings;
+    }
+
+    [Test]
+    public void PlanBlock_DeserializedFromSlackPayload_WithTasksThatHaveNoType()
+    {
+        var result = Deserialize<Block>(@"{
+            ""type"": ""plan"",
+            ""title"": ""Thinking completed"",
+            ""tasks"": [
+                {
+                    ""task_id"": ""call_001"",
+                    ""title"": ""Fetched user profile information"",
+                    ""status"": ""in_progress"",
+                    ""details"": { ""type"": ""rich_text"", ""block_id"": ""viMWO"", ""elements"": [ { ""type"": ""rich_text_section"", ""elements"": [ { ""type"": ""text"", ""text"": ""Searched database..."" } ] } ] }
+                },
+                { ""task_id"": ""call_002"", ""title"": ""Checked user permissions"", ""status"": ""pending"" },
+                { ""task_id"": ""call_003"", ""title"": ""Generated report"", ""status"": ""complete"", ""sources"": [ { ""type"": ""url"", ""url"": ""https://example.com"", ""text"": ""Example.com"" } ] }
+            ]
+        }");
+
+        var plan = result.ShouldBeA<PlanBlock>().And;
+        plan.Title.ShouldBe("Thinking completed");
+        plan.Tasks.Count.ShouldBe(3);
+        plan.Tasks[0].TaskId.ShouldBe("call_001");
+        plan.Tasks[0].Status.ShouldBe(TaskCardStatus.InProgress);
+        plan.Tasks[0].Details.Elements.Count.ShouldBe(1);
+        plan.Tasks[1].Status.ShouldBe(TaskCardStatus.Pending);
+        plan.Tasks[2].Status.ShouldBe(TaskCardStatus.Complete);
+        plan.Tasks[2].Sources[0].Url.ShouldBe("https://example.com");
+        plan.Tasks[2].Sources[0].Text.ShouldBe("Example.com");
+    }
+
+    [Test]
+    public void TaskCardBlock_DeserializedFromSlackPayload()
+    {
+        var result = Deserialize<Block>(@"{
+            ""type"": ""task_card"",
+            ""block_id"": ""b1"",
+            ""task_id"": ""call_001"",
+            ""title"": ""Fetched user profile information"",
+            ""status"": ""error"",
+            ""hide_title"": true,
+            ""output"": { ""type"": ""rich_text"", ""elements"": [ { ""type"": ""rich_text_section"", ""elements"": [ { ""type"": ""text"", ""text"": ""Failed"" } ] } ] }
+        }");
+
+        var card = result.ShouldBeA<TaskCardBlock>().And;
+        card.BlockId.ShouldBe("b1");
+        card.TaskId.ShouldBe("call_001");
+        card.Status.ShouldBe(TaskCardStatus.Error);
+        card.HideTitle.ShouldBe(true);
+        card.Output.Elements.Count.ShouldBe(1);
+        card.Details.ShouldBeNull();
+    }
+
+    [Test]
+    public void TaskCardBlock_SerializedToSlackPayload()
+    {
+        var result = Serialize(new TaskCardBlock
+            {
+                TaskId = "call_001",
+                Title = "Fetched user profile information",
+                Status = TaskCardStatus.InProgress,
+                Sources = [new UrlSourceElement { Text = "Example.com", Url = "https://example.com" }]
+            });
+
+        JToken.DeepEquals(JObject.Parse(@"{ ""type"": ""task_card"", ""task_id"": ""call_001"", ""title"": ""Fetched user profile information"", ""status"": ""in_progress"", ""sources"": [ { ""type"": ""url"", ""url"": ""https://example.com"", ""text"": ""Example.com"" } ] }"), JObject.Parse(result))
+            .ShouldBe(true, result);
+    }
+
+    [Test]
+    public void TaskCardBlock_WithIcon_SerializedToSlackPayload()
+    {
+        var result = Serialize(new TaskCardBlock { TaskId = "call_001", Title = "Fetched user profile information", Status = TaskCardStatus.Complete, Icon = new TaskCardIcon { Name = "rocket" } });
+
+        JToken.DeepEquals(JObject.Parse(@"{ ""type"": ""task_card"", ""task_id"": ""call_001"", ""title"": ""Fetched user profile information"", ""status"": ""complete"", ""icon"": { ""type"": ""icon"", ""name"": ""rocket"" } }"), JObject.Parse(result))
+            .ShouldBe(true, result);
+    }
+
+    [Test]
+    public void TaskCardBlock_WithIcon_DeserializedFromSlackPayload()
+    {
+        var result = Deserialize<Block>(@"{ ""type"": ""task_card"", ""task_id"": ""call_001"", ""title"": ""t"", ""status"": ""complete"", ""icon"": { ""type"": ""icon"", ""name"": ""rocket"" } }");
+
+        result.ShouldBeA<TaskCardBlock>().And.Icon.Name.ShouldBe("rocket");
+    }
+
+    [Test]
+    public void PlanBlock_SerializedToSlackPayload()
+    {
+        var result = Serialize(new PlanBlock
+            {
+                Title = "Thinking completed",
+                Tasks = [new TaskCardBlock { TaskId = "call_002", Title = "Checked user permissions", Status = TaskCardStatus.Pending }]
+            });
+
+        JToken.DeepEquals(JObject.Parse(@"{ ""type"": ""plan"", ""title"": ""Thinking completed"", ""tasks"": [ { ""type"": ""task_card"", ""task_id"": ""call_002"", ""title"": ""Checked user permissions"", ""status"": ""pending"" } ] }"), JObject.Parse(result))
+            .ShouldBe(true, result);
+    }
+
+    private string Serialize(object obj) => JsonConvert.SerializeObject(obj, _sut);
+
+    private T Deserialize<T>(string json) => JsonConvert.DeserializeObject<T>(json, _sut);
+}
\ No newline at end of file
diff --git a/SlackNet.Tests/TestHttp.cs b/SlackNet.Tests/TestHttp.cs
new file mode 100644
index 00000000..91879def
--- /dev/null
+++ b/SlackNet.Tests/TestHttp.cs
@@ -0,0 +1,30 @@
+#nullable enable
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using EasyAssertions;
+using Newtonsoft.Json.Linq;
+using SlackNet.WebApi;
+
+namespace SlackNet.Tests;
+
+class TestHttp : IHttp
+{
+    public string Method { get; private set; } = "";
+    public JObject Body { get; private set; } = new();
+    public JObject Response { get; set; } = new() { ["ok"] = true };
+
+    public async Task<T> Execute<T>(HttpRequestMessage requestMessage, CancellationToken cancellationToken = default)
+    {
+        Method = requestMessage.RequestUri!.Segments[^1];
+        Body = JObject.Parse(await requestMessage.Content!.ReadAsStringAsync().ConfigureAwait(false));
+        return (T)(object)new WebApiResponse { Ok = (bool)Response["ok"]!, Data = Response };
+    }
+}
+
+static class JsonAssertions
+{
+    public static void ShouldMatchJson(this JObject actual, string expectedJson) =>
+        JToken.DeepEquals(JObject.Parse(expectedJson), actual)
+            .ShouldBe(true, $"Expected JSON {JObject.Parse(expectedJson)} but was {actual}");
+}
\ No newline at end of file
diff --git a/SlackNet/Blocks/PlanBlock.cs b/SlackNet/Blocks/PlanBlock.cs
new file mode 100644
index 00000000..a611ad1d
--- /dev/null
+++ b/SlackNet/Blocks/PlanBlock.cs
@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+
+namespace SlackNet.Blocks;
+
+/// <summary>
+/// Groups related <see cref="TaskCardBlock"/>s under a single title, so users can follow a multi-step process as one list.
+/// Each task in a plan must have a unique <see cref="TaskCardBlock.TaskId"/>, and a plan can contain at most 50 tasks.
+/// Slack doesn't allow a message to contain both a plan block and <see cref="TaskCardBlock"/>s.
+/// When streaming, set <see cref="WebApi.TaskDisplayMode.Plan"/> on <see cref="WebApi.IChatApi.StartStream"/> to collect task updates into a plan,
+/// and send <see cref="WebApi.PlanUpdateChunk"/>s to change its title.
+/// </summary>
+/// <remarks>See the <a href="https://docs.slack.dev/reference/block-kit/blocks/plan-block/">Slack documentation</a> for more information.</remarks>
+[SlackType("plan")]
+public class PlanBlock() : Block("plan")
+{
+    /// <summary>
+    /// Title of the plan in plain text.
+    /// </summary>
+    public string Title { get; set; }
+
+    /// <summary>
+    /// The tasks of the plan, at most 50.
+    /// </summary>
+    public IList<TaskCardBlock> Tasks { get; set; } = [];
+}
\ No newline at end of file
diff --git a/SlackNet/Blocks/TaskCardBlock.cs b/SlackNet/Blocks/TaskCardBlock.cs
new file mode 100644
index 00000000..84c26e69
--- /dev/null
+++ b/SlackNet/Blocks/TaskCardBlock.cs
@@ -0,0 +1,80 @@
+using System.Collections.Generic;
+
+namespace SlackNet.Blocks;
+
+/// <summary>
+/// Displays a single task, which represents a single action: a title, a status indicator and optional details, output and sources.
+/// Use a <see cref="PlanBlock"/> to show several related tasks together.
+/// Slack doesn't allow a message to contain both a plan block and task cards.
+/// When streaming, the equivalent is a <see cref="WebApi.TaskUpdateChunk"/>.
+/// </summary>
+/// <remarks>See the <a href="https://docs.slack.dev/reference/block-kit/blocks/task-card-block/">Slack documentation</a> for more information.</remarks>
+[SlackType("task_card")]
+public class TaskCardBlock() : Block("task_card")
+{
+    /// <summary>
+    /// ID for the task. Within a <see cref="PlanBlock"/> each task ID must be unique.
+    /// </summary>
+    public string TaskId { get; set; }
+
+    /// <summary>
+    /// Title of the task in plain text.
+    /// </summary>
+    public string Title { get; set; }
+
+    public TaskCardStatus Status { get; set; }
+
+    /// <summary>
+    /// Details of the task.
+    /// </summary>
+    public RichTextBlock Details { get; set; }
+
+    /// <summary>
+    /// Output of the task.
+    /// </summary>
+    public RichTextBlock Output { get; set; }
+
+    /// <summary>
+    /// URLs that were used to generate a response.
+    /// </summary>
+    [IgnoreIfEmpty]
+    public IList<UrlSourceElement> Sources { get; set; } = [];
+
+    /// <summary>
+    /// When true, <see cref="Title"/> is not displayed and <see cref="Details"/> becomes the top element. <see cref="Title"/> is still required.
+    /// </summary>
+    public bool? HideTitle { get; set; }
+
+    /// <summary>
+    /// Icon associated with the task.
+    /// </summary>
+    public TaskCardIcon Icon { get; set; }
+}
+
+/// <summary>
+/// One of Slack's named task icons.
+/// </summary>
+public class TaskCardIcon
+{
+    public string Type { get; set; } = "icon";
+
+    /// <summary>
+    /// The name of the icon, e.g. <c>rocket</c>, <c>bug</c>, <c>globe</c> or <c>check</c>. Slack only accepts the names it defines, and rejects the message with <c>invalid_blocks</c> for any other.
+    /// </summary>
+    public string Name { get; set; }
+}
+
+/// <summary>
+/// The state of a task.
+/// </summary>
+public enum TaskCardStatus
+{
+    /// <summary>
+    /// The task hasn't started. Slack accepts this for the tasks of a <see cref="PlanBlock"/> and in streamed task updates,
+    /// but rejects it for a <see cref="TaskCardBlock"/> that isn't part of a plan.
+    /// </summary>
+    Pending,
+    InProgress,
+    Complete,
+    Error
+}
\ No newline at end of file
diff --git a/SlackNet/Blocks/UrlSourceElement.cs b/SlackNet/Blocks/UrlSourceElement.cs
new file mode 100644
index 00000000..3b66d514
--- /dev/null
+++ b/SlackNet/Blocks/UrlSourceElement.cs
@@ -0,0 +1,20 @@
+namespace SlackNet.Blocks;
+
+/// <summary>
+/// Displays a clickable URL reference. This element can only be used in a <see cref="TaskCardBlock"/> (or in the equivalent <see cref="WebApi.TaskUpdateChunk"/> when streaming).
+/// Slack doesn't validate that the URL resolves.
+/// </summary>
+/// <remarks>See the <a href="https://docs.slack.dev/reference/block-kit/block-elements/url-source-element/">Slack documentation</a> for more information.</remarks>
+[SlackType("url")]
+public class UrlSourceElement() : BlockElement("url")
+{
+    /// <summary>
+    /// The URL being referenced.
+    /// </summary>
+    public string Url { get; set; }
+
+    /// <summary>
+    /// Display text for the URL.
+    /// </summary>
+    public string Text { get; set; }
+}
\ No newline at end of file
diff --git a/SlackNet/Events/AgentSessionStopped.cs b/SlackNet/Events/AgentSessionStopped.cs
new file mode 100644
index 00000000..6c947a92
--- /dev/null
+++ b/SlackNet/Events/AgentSessionStopped.cs
@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+
+namespace SlackNet.Events;
+
+/// <summary>
+/// Sent when a user clicks the native stop button shown while an agent session is <see cref="WebApi.AgentSessionStatus.Processing"/>.
+/// The button is only shown if the app is subscribed to this event, which requires the <c>chat:write</c> scope.
+/// When you receive it, stop any in-progress work for the channel and thread, confirm to the user that work has stopped,
+/// and move the session out of <see cref="WebApi.AgentSessionStatus.Processing"/> with <see cref="WebApi.IAgentsSessionsApi.SetStatus"/> or the <c>sessionStatus</c> argument of <see cref="WebApi.IChatApi.StopStream"/>.
+/// The session status is not updated automatically.
+/// </summary>
+/// <remarks>See the <a href="https://docs.slack.dev/reference/events/agent_session_stopped/">Slack documentation</a> for more information.</remarks>
+public class AgentSessionStopped : Event
+{
+    /// <summary>
+    /// The channel containing the session.
+    /// </summary>
+    public string Channel { get; set; }
+
+    /// <summary>
+    /// The root of the thread the session is scoped to.
+    /// </summary>
+    public string ThreadTs { get; set; }
+
+    /// <summary>
+    /// The user who clicked the stop button.
+    /// </summary>
+    public string User { get; set; }
+
+    /// <summary>
+    /// Timestamps of the app's in-progress streaming messages that Slack stopped in response to the click.
+    /// Empty when no stream was active, so the event still tells you to stop work that isn't a stream.
+    /// </summary>
+    public IList<string> StreamingMessageTs { get; set; } = [];
+}
\ No newline at end of file
diff --git a/SlackNet/SlackApiClient.cs b/SlackNet/SlackApiClient.cs
index 005d7d3e..a5188efd 100644
--- a/SlackNet/SlackApiClient.cs
+++ b/SlackNet/SlackApiClient.cs
@@ -14,6 +14,7 @@ namespace SlackNet;
 
 public interface ISlackApiClient
 {
+    IAgentsSessionsApi AgentsSessions { get; }
     IApiApi Api { get; }
     IAppsConnectionsApi AppsConnectionsApi { get; }
     IAppsEventAuthorizationsApi AppsEventAuthorizations { get; }
@@ -170,6 +171,7 @@ public ISlackApiClient WithAccessToken(string accessToken) =>
                 WarningsAsErrors = WarningsAsErrors
             };
 
+    public IAgentsSessionsApi AgentsSessions => new AgentsSessionsApi(this);
     public IApiApi Api => new ApiApi(this);
     public IAppsConnectionsApi AppsConnectionsApi => new AppsConnectionsApi(this);
     public IAppsEventAuthorizationsApi AppsEventAuthorizations => new AppsEventAuthorizationsApi(this);
diff --git a/SlackNet/WebApi/AgentSessionStatus.cs b/SlackNet/WebApi/AgentSessionStatus.cs
new file mode 100644
index 00000000..d5ac2dae
--- /dev/null
+++ b/SlackNet/WebApi/AgentSessionStatus.cs
@@ -0,0 +1,29 @@
+namespace SlackNet.WebApi;
+
+/// <summary>
+/// The lifecycle status of an agent in an agent session.
+/// </summary>
+/// <remarks>See the <a href="https://docs.slack.dev/reference/methods/agents.sessions.setStatus/">Slack documentation</a> for more information.</remarks>
+public enum AgentSessionStatus
+{
+    /// <summary>
+    /// The agent is ready for the next prompt or task.
+    /// </summary>
+    Active,
+
+    /// <summary>
+    /// The agent is working on a task. Slack shows a loading indicator, and a stop button if the app is subscribed to <see cref="Events.AgentSessionStopped"/>.
+    /// </summary>
+    Processing,
+
+    /// <summary>
+    /// The agent cannot make progress until the user intervenes, for example when it needs clarification, a decision, or a tool approval.
+    /// An agent that has posted a question and is waiting on the answer is suspended, not active.
+    /// </summary>
+    Suspended,
+
+    /// <summary>
+    /// The agent has closed the session and will no longer respond on it.
+    /// </summary>
+    Closed
+}
\ No newline at end of file
diff --git a/SlackNet/WebApi/AgentsSessionsApi.cs b/SlackNet/WebApi/AgentsSessionsApi.cs
new file mode 100644
index 00000000..b193be28
--- /dev/null
+++ b/SlackNet/WebApi/AgentsSessionsApi.cs
@@ -0,0 +1,68 @@
+using System.Threading;
+using System.Threading.Tasks;
+using JetBrains.Annotations;
+using Args = System.Collections.Generic.Dictionary<string, object>;
+
+namespace SlackNet.WebApi;
+
+public interface IAgentsSessionsApi
+{
+    /// <summary>
+    /// Sets the lifecycle status of an agent session, creating the session if it doesn't exist yet.
+    /// Only apps declared as agents in the app settings can create sessions.
+    /// While a session is <see cref="AgentSessionStatus.Processing"/>, Slack shows a loading indicator,
+    /// along with a stop button if the app subscribes to <see cref="Events.AgentSessionStopped"/>.
+    /// </summary>
+    /// <remarks>See the <a href="https://docs.slack.dev/reference/methods/agents.sessions.setStatus/">Slack documentation</a> for more information.</remarks>
+    /// <param name="channelId">ID of the channel containing the agent session. The app must be a member of it. Slack requires this for public channels.</param>
+    /// <param name="threadTs">
+    /// Timestamp of the thread root message the session is scoped to.
+    /// Required for thread-based sessions in regular channels and DMs; must be <c>null</c> for session channels (where the whole channel is one session).
+    /// </param>
+    /// <param name="status">The lifecycle status to set.</param>
+    /// <param name="title">Title for the agent session (max 200 characters). Only used when the session is created; use <c>agents.sessions.rename</c> to rename an existing session.</param>
+    /// <param name="initiatorUserId">The user who initiated the session. Only used when the session is created. Must be a member of the channel.</param>
+    /// <param name="iconEmoji">
+    /// Emoji to use as the agent's icon. Takes priority over <paramref name="iconUrl"/>. Requires the <c>chat:write.customize</c> scope.
+    /// Icon and username overrides persist until replaced: a call that sets none of <paramref name="iconEmoji"/>, <paramref name="iconUrl"/> and <paramref name="username"/> leaves them in place,
+    /// while a call that sets any of them replaces all three, so those it leaves out are cleared.
+    /// </param>
+    /// <param name="iconUrl">URL to an image to use as the agent's icon. Requires the <c>chat:write.customize</c> scope.</param>
+    /// <param name="username">Display name override for the agent (max 200 characters). Requires the <c>chat:write.customize</c> scope.</param>
+    /// <param name="cancellationToken"></param>
+    Task<AgentSessionStatusResponse> SetStatus(
+        string channelId,
+        [CanBeNull] string threadTs,
+        AgentSessionStatus status,
+        [CanBeNull] string title = null,
+        [CanBeNull] string initiatorUserId = null,
+        [CanBeNull] string iconEmoji = null,
+        [CanBeNull] string iconUrl = null,
+        [CanBeNull] string username = null,
+        CancellationToken cancellationToken = default);
+}
+
+public class AgentsSessionsApi(ISlackApiClient client) : IAgentsSessionsApi
+{
+    public Task<AgentSessionStatusResponse> SetStatus(
+        string channelId,
+        string threadTs,
+        AgentSessionStatus status,
+        string title = null,
+        string initiatorUserId = null,
+        string iconEmoji = null,
+        string iconUrl = null,
+        string username = null,
+        CancellationToken cancellationToken = default) =>
+        client.Post<AgentSessionStatusResponse>("agents.sessions.setStatus", new Args
+            {
+                { "channel_id", channelId },
+                { "thread_ts", threadTs },
+                { "status", status },
+                { "title", title },
+                { "initiator_user_id", initiatorUserId },
+                { "icon_emoji", iconEmoji },
+                { "icon_url", iconUrl },
+                { "username", username }
+            }, cancellationToken);
+}
\ No newline at end of file
diff --git a/SlackNet/WebApi/ChatApi.cs b/SlackNet/WebApi/ChatApi.cs
index b6d8cbb1..853ef206 100644
--- a/SlackNet/WebApi/ChatApi.cs
+++ b/SlackNet/WebApi/ChatApi.cs
@@ -151,25 +151,62 @@ Task Unfurl(
 
     /// <summary>
     /// Starts a new streaming conversation.
+    /// Starting a stream creates an agent session if there isn't one yet, and sets it to <see cref="AgentSessionStatus.Processing"/>.
     /// </summary>
     /// <remarks>See the <a href="https://docs.slack.dev/reference/methods/chat.startStream/">Slack documentation</a> for more information.</remarks>
     /// <param name="channel">An encoded ID that represents a channel, private group, or DM.</param>
-    /// <param name="threadTs">Provide another message's timestamp value to reply to. Streamed messages should always be replies to a user request.</param>
-    /// <param name="markdownText">Accepts message text formatted in markdown. This text is what will be appended to the message received so far.</param>
+    /// <param name="threadTs">
+    /// Provide another message's timestamp value to reply to. Streamed messages should always be replies to a user request.
+    /// Can be <c>null</c> only in channels where the whole channel is one session, such as Slack Code.
+    /// </param>
+    /// <param name="markdownText">
+    /// Accepts message text formatted in markdown. Limit this field to 12,000 characters.
+    /// Can't be combined with <paramref name="chunks"/>, and a stream started with markdown text can only be appended to with markdown text.
+    /// </param>
     /// <param name="recipientUserId">The encoded ID of the user to receive the streaming text. Required when streaming to channels.</param>
     /// <param name="recipientTeamId">The encoded ID of the team the user receiving the streaming text belongs to. Required when streaming to channels.</param>
+    /// <param name="chunks">
+    /// Chunks to stream: markdown text, task updates, plan updates and blocks.
+    /// Can't be combined with <paramref name="markdownText"/>, and a stream started with chunks can only be appended to with chunks.
+    /// </param>
+    /// <param name="taskDisplayMode">How task updates are displayed. Slack's default is <see cref="TaskDisplayMode.Timeline"/>.</param>
+    /// <param name="iconEmoji">Emoji to use as the icon for this message. Overrides <paramref name="iconUrl"/>.</param>
+    /// <param name="iconUrl">Image URL to use as the icon for this message.</param>
+    /// <param name="username">The bot's username to display.</param>
     /// <param name="cancellationToken"></param>
-    Task<MessageTsResponse> StartStream(string channel, string threadTs, string markdownText = null, string recipientUserId = null, string recipientTeamId = null, CancellationToken cancellationToken = default);
+    Task<MessageTsResponse> StartStream(
+        string channel,
+        string threadTs,
+        string markdownText = null,
+        string recipientUserId = null,
+        string recipientTeamId = null,
+        IEnumerable<StreamChunk> chunks = null,
+        TaskDisplayMode? taskDisplayMode = null,
+        string iconEmoji = null,
+        string iconUrl = null,
+        string username = null,
+        CancellationToken cancellationToken = default);
 
     /// <summary>
-    /// Appends text to an existing streaming conversation.
+    /// Appends text or chunks to an existing streaming conversation.
+    /// Fails with <c>stopped_by_user</c> if the user stopped the stream.
     /// </summary>
     /// <remarks>See the <a href="https://docs.slack.dev/reference/methods/chat.appendStream/">Slack documentation</a> for more information.</remarks>
     /// <param name="channel">An encoded ID that represents a channel, private group, or DM.</param>
     /// <param name="ts">The timestamp of the streaming message.</param>
-    /// <param name="markdownText">Accepts message text formatted in markdown. This text is what will be appended to the message received so far.</param>
+    /// <param name="markdownText">
+    /// Accepts message text formatted in markdown. Limit this field to 12,000 characters.
+    /// This text is what will be appended to the message received so far.
+    /// Use this if the stream was started with markdown text, and <paramref name="chunks"/> if it was started with chunks.
+    /// </param>
+    /// <param name="chunks">Chunks to append to the stream: markdown text, task updates, plan updates and blocks.</param>
     /// <param name="cancellationToken"></param>
-    Task<MessageTsResponse> AppendStream(string channel, string ts, string markdownText, CancellationToken cancellationToken = default);
+    Task<MessageTsResponse> AppendStream(
+        string channel,
+        string ts,
+        string markdownText = null,
+        IEnumerable<StreamChunk> chunks = null,
+        CancellationToken cancellationToken = default);
 
     /// <summary>
     /// Stops a streaming conversation.
@@ -177,7 +214,7 @@ Task Unfurl(
     /// <remarks>See the <a href="https://docs.slack.dev/reference/methods/chat.stopStream/">Slack documentation</a> for more information.</remarks>
     /// <param name="channel">An encoded ID that represents a channel, private group, or DM.</param>
     /// <param name="ts">A message's timestamp, uniquely identifying it within a channel.</param>
-    /// <param name="markdownText">Accepts message text formatted in markdown. This text is what will be appended to the message received so far.</param>
+    /// <param name="markdownText">Accepts message text formatted in markdown. Limit this field to 12,000 characters. This text is what will be appended to the message received so far.</param>
     /// <param name="blocks">A list of blocks that will be rendered at the bottom of the finalized message.</param>
     /// <param name="metadataObject">
     /// A custom event attached to the message.
@@ -187,10 +224,21 @@ Task Unfurl(
     /// <param name="metadataJson">
     /// A custom event attached to the message.
     /// Metadata you post to Slack is accessible to any app or user who is a member of that workspace.
-    /// Will take precedence over <see cref="metadataObject"/>.
+    /// Will take precedence over <paramref name="metadataObject"/>.
     /// </param>
+    /// <param name="chunks">Chunks to append before the stream is stopped: markdown text, task updates, plan updates and blocks.</param>
+    /// <param name="sessionStatus">The status to set the agent session to after the stream has stopped. Slack's default is <see cref="AgentSessionStatus.Active"/>.</param>
     /// <param name="cancellationToken"></param>
-    Task<PostMessageResponse> StopStream(string channel, string ts, string markdownText = null, IEnumerable<Block> blocks = null, object metadataObject = null, MessageMetadata metadataJson = null, CancellationToken cancellationToken = default);
+    Task<PostMessageResponse> StopStream(
+        string channel,
+        string ts,
+        string markdownText = null,
+        IEnumerable<Block> blocks = null,
+        object metadataObject = null,
+        MessageMetadata metadataJson = null,
+        IEnumerable<StreamChunk> chunks = null,
+        AgentSessionStatus? sessionStatus = null,
+        CancellationToken cancellationToken = default);
 }
 
 public class ChatApi(ISlackApiClient client, SlackJsonSettings jsonSettings) : IChatApi
@@ -333,22 +381,46 @@ public Task<MessageUpdateResponse> Update(MessageUpdate messageUpdate, Cancellat
                 },
             cancellationToken);
 
-    public Task<MessageTsResponse> StartStream(string channel, string threadTs, string markdownText = null, string recipientUserId = null, string recipientTeamId = null, CancellationToken cancellationToken = default) =>
+    public Task<MessageTsResponse> StartStream(
+        string channel,
+        string threadTs,
+        string markdownText = null,
+        string recipientUserId = null,
+        string recipientTeamId = null,
+        IEnumerable<StreamChunk> chunks = null,
+        TaskDisplayMode? taskDisplayMode = null,
+        string iconEmoji = null,
+        string iconUrl = null,
+        string username = null,
+        CancellationToken cancellationToken = default
+    ) =>
         client.Post<MessageTsResponse>("chat.startStream", new Args
             {
                 { "channel", channel },
                 { "thread_ts", threadTs },
                 { "markdown_text", markdownText },
                 { "recipient_user_id", recipientUserId },
-                { "recipient_team_id", recipientTeamId }
+                { "recipient_team_id", recipientTeamId },
+                { "chunks", chunks },
+                { "task_display_mode", taskDisplayMode },
+                { "icon_emoji", iconEmoji },
+                { "icon_url", iconUrl },
+                { "username", username }
             }, cancellationToken);
 
-    public Task<MessageTsResponse> AppendStream(string channel, string ts, string markdownText, CancellationToken cancellationToken = default) =>
+    public Task<MessageTsResponse> AppendStream(
+        string channel,
+        string ts,
+        string markdownText = null,
+        IEnumerable<StreamChunk> chunks = null,
+        CancellationToken cancellationToken = default
+    ) =>
         client.Post<MessageTsResponse>("chat.appendStream", new Args
             {
                 { "channel", channel },
                 { "ts", ts },
-                { "markdown_text", markdownText }
+                { "markdown_text", markdownText },
+                { "chunks", chunks }
             }, cancellationToken);
 
     public Task<PostMessageResponse> StopStream(
@@ -358,6 +430,8 @@ public Task<PostMessageResponse> StopStream(
         IEnumerable<Block> blocks = null,
         object metadataObject = null,
         MessageMetadata metadataJson = null,
+        IEnumerable<StreamChunk> chunks = null,
+        AgentSessionStatus? sessionStatus = null,
         CancellationToken cancellationToken = default
     ) =>
         client.Post<PostMessageResponse>("chat.stopStream", new Args
@@ -365,7 +439,9 @@ public Task<PostMessageResponse> StopStream(
                 { "channel", channel },
                 { "ts", ts },
                 { "markdown_text", markdownText },
+                { "chunks", chunks },
                 { "blocks", blocks },
-                { "metadata", metadataJson ?? MessageMetadata.FromObject(metadataObject, jsonSettings) }
+                { "metadata", metadataJson ?? MessageMetadata.FromObject(metadataObject, jsonSettings) },
+                { "session_status", sessionStatus }
             }, cancellationToken);
 }
diff --git a/SlackNet/WebApi/Responses/AgentSessionStatusResponse.cs b/SlackNet/WebApi/Responses/AgentSessionStatusResponse.cs
new file mode 100644
index 00000000..e0c30413
--- /dev/null
+++ b/SlackNet/WebApi/Responses/AgentSessionStatusResponse.cs
@@ -0,0 +1,21 @@
+namespace SlackNet.WebApi;
+
+public class AgentSessionStatusResponse
+{
+    /// <summary>
+    /// The status of the session as a whole, derived from the statuses of all the agents in it
+    /// (<see cref="AgentSessionStatus.Suspended"/> over <see cref="AgentSessionStatus.Processing"/> over <see cref="AgentSessionStatus.Active"/> over <see cref="AgentSessionStatus.Closed"/>).
+    /// </summary>
+    public AgentSessionStatus Status { get; set; }
+
+    /// <summary>
+    /// The calling agent's own status, i.e. the value that was just written.
+    /// In a session with more than one agent this can differ from <see cref="Status"/>.
+    /// </summary>
+    public AgentSessionStatus AgentStatus { get; set; }
+
+    /// <summary>
+    /// The title of the session, if it has one.
+    /// </summary>
+    public string Title { get; set; }
+}
\ No newline at end of file
diff --git a/SlackNet/WebApi/StreamChunk.cs b/SlackNet/WebApi/StreamChunk.cs
new file mode 100644
index 00000000..da04b437
--- /dev/null
+++ b/SlackNet/WebApi/StreamChunk.cs
@@ -0,0 +1,108 @@
+using System.Collections.Generic;
+using SlackNet.Blocks;
+
+namespace SlackNet.WebApi;
+
+/// <summary>
+/// A piece of a streaming message, sent in the <c>chunks</c> argument of <see cref="IChatApi.StartStream"/>, <see cref="IChatApi.AppendStream"/> and <see cref="IChatApi.StopStream"/>.
+/// A stream that was started with chunks must be appended to with chunks, and a stream that was started with markdown text must be appended to with markdown text.
+/// </summary>
+/// <remarks>See the <a href="https://docs.slack.dev/reference/methods/chat.appendStream/#chunks">Slack documentation</a> for more information.</remarks>
+public abstract class StreamChunk(string type)
+{
+    public string Type { get; set; } = type;
+}
+
+/// <summary>
+/// Streams text, formatted as standard markdown (not Slack's mrkdwn).
+/// </summary>
+public class MarkdownTextChunk() : StreamChunk("markdown_text")
+{
+    /// <summary>
+    /// The markdown text to append to the message received so far.
+    /// </summary>
+    public string Text { get; set; }
+}
+
+/// <summary>
+/// Creates or updates a task, to display the progress of a unit of work.
+/// Tasks are displayed according to the <see cref="TaskDisplayMode"/> of the stream.
+/// This is the streaming counterpart of the <see cref="TaskCardBlock"/>.
+/// Slack limits the size of <c>task_update</c> and <c>plan_update</c> chunks to 256 characters.
+/// </summary>
+public class TaskUpdateChunk() : StreamChunk("task_update")
+{
+    /// <summary>
+    /// A unique ID for the task. Sending another update with the same ID updates the task.
+    /// </summary>
+    public string Id { get; set; }
+
+    /// <summary>
+    /// Title of the task in plain text.
+    /// </summary>
+    public string Title { get; set; }
+
+    /// <summary>
+    /// When true, <see cref="Title"/> is not displayed and <see cref="Details"/> becomes the top element.
+    /// </summary>
+    public bool? HideTitle { get; set; }
+
+    /// <summary>
+    /// The state of the task. Slack marks tasks that are still <see cref="TaskCardStatus.Pending"/> or <see cref="TaskCardStatus.InProgress"/> when the stream stops as <see cref="TaskCardStatus.Error"/>.
+    /// </summary>
+    public TaskCardStatus Status { get; set; }
+
+    /// <summary>
+    /// Icon associated with the task.
+    /// </summary>
+    public TaskCardIcon Icon { get; set; }
+
+    /// <summary>
+    /// Details of the task.
+    /// </summary>
+    public string Details { get; set; }
+
+    /// <summary>
+    /// Output of the task.
+    /// </summary>
+    public string Output { get; set; }
+
+    /// <summary>
+    /// URLs that were used in the task.
+    /// </summary>
+    [IgnoreIfEmpty]
+    public IList<UrlSourceElement> Sources { get; set; } = [];
+}
+
+/// <summary>
+/// Updates the title of the plan that tasks are collected into when the stream's <see cref="TaskDisplayMode"/> is <see cref="TaskDisplayMode.Plan"/>.
+/// Slack limits the size of <c>task_update</c> and <c>plan_update</c> chunks to 256 characters.
+/// </summary>
+public class PlanUpdateChunk() : StreamChunk("plan_update")
+{
+    public string Title { get; set; }
+}
+
+/// <summary>
+/// Streams blocks as part of the message. At most 50 blocks can be sent in one chunk; Slack drops any extra blocks and returns a warning.
+/// </summary>
+public class BlocksChunk() : StreamChunk("blocks")
+{
+    public IList<Block> Blocks { get; set; } = [];
+}
+
+/// <summary>
+/// How task updates are displayed in a streaming message.
+/// </summary>
+public enum TaskDisplayMode
+{
+    /// <summary>
+    /// Task updates render as individual task cards, interleaved with the streamed text. This is Slack's default.
+    /// </summary>
+    Timeline,
+
+    /// <summary>
+    /// Task updates render together, in a single plan block.
+    /// </summary>
+    Plan
+}
\ No newline at end of file