@@ -6,6 +6,20 @@ namespace BotSharp.Abstraction.Realtime;
 
 public interface IRealtimeHook : IHookBase
 {
+    /// <summary>
+    /// Establishes the ambient identity for a stream connection, before anything runs on it.
+    ///
+    /// Synchronous on purpose. Ambient identity is AsyncLocal-backed, and a write made inside an
+    /// `async` method does not flow back out to its caller - so an awaited hook cannot establish
+    /// identity for the connection that follows it, only for itself.
+    /// </summary>
+    /// <param name="userId">
+    /// Who the client says it is. A browser cannot set headers on a WebSocket handshake, so this
+    /// arrives as a query parameter and is UNVERIFIED: treat it as a claim to be checked, not as
+    /// proof. Null when the client sent none.
+    /// </param>
+    void OnAuthenticate(string agentId, string conversationId, string? userId) { }
+
     Task OnModelReady(Agent agent, IRealTimeCompletion completer)
         => Task.CompletedTask;
 
 
@@ -1,5 +1,7 @@
+using BotSharp.Abstraction.Realtime;
 using BotSharp.Abstraction.Realtime.Options;
 using BotSharp.Abstraction.Realtime.Sessions;
+using BotSharp.Core.Infrastructures;
 using BotSharp.Core.Session;
 using Microsoft.AspNetCore.Http;
 using System.Net.WebSockets;
@@ -34,6 +36,23 @@ public async Task Invoke(HttpContext httpContext)
                     var agentId = segments[segments.Length - 2];
                     var conversationId = segments[segments.Length - 1];
 
+                    /*
+                     * Identity, before anything else touches the connection.
+                     *
+                     * The handshake carries no Authorization header - a browser cannot set one on
+                     * a WebSocket - so the signed-in user arrives as a query parameter. It stays
+                     * a query parameter rather than a path segment because agentId and
+                     * conversationId are read from the END of the path above, so an extra segment
+                     * would silently shift both.
+                     *
+                     * Emitted through the SYNCHRONOUS Emit overload: ambient identity is
+                     * AsyncLocal-backed and a write inside an async method does not escape it, so
+                     * an awaited hook would establish nothing for the work awaited below.
+                     */
+                    var userId = httpContext.Request.Query["user-id"].FirstOrDefault();
+                    HookEmitter.Emit<IRealtimeHook>(services,
+                        hook => hook.OnAuthenticate(agentId, conversationId, userId), agentId);
+
                     using var webSocket = await httpContext.WebSockets.AcceptWebSocketAsync();
                     await HandleWebSocket(services, agentId, conversationId, webSocket);
                 }