diff --git a/packages/http-client-csharp/generator/TestProjects/Spector.Tests/Http/Streaming/Sse/SseTests.cs b/packages/http-client-csharp/generator/TestProjects/Spector.Tests/Http/Streaming/Sse/SseTests.cs
index bb06e9d5aeb..ee76f6b65b4 100644
--- a/packages/http-client-csharp/generator/TestProjects/Spector.Tests/Http/Streaming/Sse/SseTests.cs
+++ b/packages/http-client-csharp/generator/TestProjects/Spector.Tests/Http/Streaming/Sse/SseTests.cs
@@ -1,8 +1,11 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+using System;
+using System.ClientModel.Primitives;
 using System.Collections.Generic;
 using System.Linq;
+using System.Net.ServerSentEvents;
 using System.Text.Json;
 using System.Threading.Tasks;
 using NUnit.Framework;
@@ -82,5 +85,111 @@ public Task Retrieve() => Test(async (host) =>
                 },
                 events);
         });
+
+        [SpectorTest]
+        public Task WithEnvelope() => Test(async (host) =>
+        {
+            var client = new SseClient(host, null).GetProtocolClient().GetProtocolDataClient();
+            await using var response = await client.WithEnvelopeAsync();
+            var item = await ReadSingleEventAsync(response);
+
+            Assert.AreEqual("withEnvelope", item.EventType);
+            Assert.AreEqual("hello", item.Data.ToString());
+        });
+
+        [SpectorTest]
+        public Task WithoutEnvelope() => Test(async (host) =>
+        {
+            var client = new SseClient(host, null).GetProtocolClient().GetProtocolDataClient();
+            await using var response = await client.WithoutEnvelopeAsync();
+            var item = await ReadSingleEventAsync(response);
+
+            Assert.AreEqual("withoutEnvelope", item.EventType);
+            using var document = JsonDocument.Parse(item.Data.ToMemory());
+            Assert.AreEqual("world", document.RootElement.GetProperty("contents").GetString());
+            Assert.AreEqual("test", document.RootElement.GetProperty("metadata").GetProperty("source").GetString());
+        });
+
+        [SpectorTest]
+        public Task Id() => Test(async (host) =>
+        {
+            var client = new SseClient(host, null).GetProtocolClient();
+            await using var response = await client.IdAsync();
+            var item = await ReadSingleEventAsync(response);
+
+            Assert.AreEqual("message", item.EventType);
+            Assert.AreEqual("event-1", item.EventId);
+            Assert.AreEqual("hello", item.Data.Message);
+        });
+
+        [SpectorTest]
+        public Task InvalidId() => Test(async (host) =>
+        {
+            var client = new SseClient(host, null).GetProtocolClient();
+            await using var response = await client.InvalidIdAsync();
+            var item = await ReadSingleEventAsync(response);
+
+            Assert.AreEqual("message", item.EventType);
+            Assert.IsNull(item.EventId);
+            Assert.AreEqual("hello", item.Data.Message);
+        });
+
+        [SpectorTest]
+        public Task Retry() => Test(async (host) =>
+        {
+            var client = new SseClient(host, null).GetProtocolClient();
+            await using var response = await client.RetryAsync();
+            var item = await ReadSingleEventAsync(response);
+
+            Assert.AreEqual("message", item.EventType);
+            Assert.AreEqual(TimeSpan.FromMilliseconds(1000), item.ReconnectionInterval);
+            Assert.AreEqual("hello", item.Data.Message);
+        });
+
+        [SpectorTest]
+        public Task InvalidRetry() => Test(async (host) =>
+        {
+            var client = new SseClient(host, null).GetProtocolClient();
+            await using var response = await client.InvalidRetryAsync();
+            var item = await ReadSingleEventAsync(response);
+
+            Assert.AreEqual("message", item.EventType);
+            Assert.IsNull(item.ReconnectionInterval);
+            Assert.AreEqual("hello", item.Data.Message);
+        });
+
+        [SpectorTest]
+        public Task Reconnect() => Test(async (host) =>
+        {
+            var client = new SseClient(host, null).GetProtocolClient();
+            string lastEventId;
+            await using (var response = await client.ReconnectAsync())
+            {
+                var item = await ReadSingleEventAsync(response);
+                Assert.AreEqual("message", item.EventType);
+                Assert.AreEqual("event-1", item.EventId);
+                Assert.AreEqual("hello", item.Data.Message);
+                lastEventId = item.EventId!;
+            }
+
+            var options = new RequestOptions();
+            options.SetHeader("Last-Event-ID", lastEventId);
+            await using var reconnectedResponse = await client.ReconnectAsync(options);
+            var reconnectedItem = await ReadSingleEventAsync(reconnectedResponse);
+
+            Assert.AreEqual("message", reconnectedItem.EventType);
+            Assert.AreEqual("event-2", reconnectedItem.EventId);
+            using var document = JsonDocument.Parse(reconnectedItem.Data.ToMemory());
+            Assert.AreEqual("world", document.RootElement.GetProperty("message").GetString());
+        });
+
+        private static async Task<SseItem<T>> ReadSingleEventAsync<T>(IAsyncEnumerable<SseItem<T>> response)
+        {
+            await using var enumerator = response.GetAsyncEnumerator();
+            Assert.IsTrue(await enumerator.MoveNextAsync(), "Expected one SSE event.");
+            var item = enumerator.Current;
+            Assert.IsFalse(await enumerator.MoveNextAsync(), "Expected the SSE stream to end after one event.");
+            return item;
+        }
     }
 }