Rename WebSocket handler types to CopilotWebSocketHandler + CopilotWebSocketForwarder

Unifies the WebSocket interception handler naming across all six SDKs so the
protocol/contract is always CopilotWebSocketHandler and the default
forwarding implementation is always CopilotWebSocketForwarder.

- OO SDKs (Node, .NET, Java, Python): abstract CopilotWebSocketHandlerBase
  -> CopilotWebSocketHandler (protocol); concrete CopilotWebSocketHandler
  -> CopilotWebSocketForwarder (forwarder). Java files renamed accordingly.
- Go/Rust: concrete ForwardingCopilotWebSocketHandler ->
  CopilotWebSocketForwarder (plus constructor/builder); the
  CopilotWebSocketHandler interface/trait is unchanged.

Also rename the Rust CopilotRequestTransport::Websocket enum variant to
WebSocket for proper-noun consistency.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: SteveSandersonMS

dotnet/src/CopilotRequestHandler.cs

@@ -113,11 +113,11 @@ public sealed class CopilotWebSocketCloseStatus
 /// to any upstream server on its own. Subclass it directly only to service a
 /// fully synthetic connection yourself. For the common case of mutating and
 /// forwarding traffic to the real upstream, subclass
-/// <see cref="CopilotWebSocketHandler"/> instead, which connects upstream and
+/// <see cref="CopilotWebSocketForwarder"/> instead, which connects upstream and
 /// forwards by default.
 /// </summary>
 [Experimental(Diagnostics.Experimental)]
-public abstract class CopilotWebSocketHandlerBase : IAsyncDisposable
+public abstract class CopilotWebSocketHandler : IAsyncDisposable
 {
     private readonly TaskCompletionSource<CopilotWebSocketCloseStatus> _completion =
         new(TaskCreationOptions.RunContinuationsAsynchronously);
@@ -132,7 +132,7 @@ public abstract class CopilotWebSocketHandlerBase : IAsyncDisposable
     /// <summary>
     /// Initializes a per-connection handler for the supplied request context.
     /// </summary>
-    protected CopilotWebSocketHandlerBase(CopilotRequestContext context)
+    protected CopilotWebSocketHandler(CopilotRequestContext context)
     {
         Context = context;
         _ = context.WebSocketResponse ?? throw new InvalidOperationException("WebSocket response bridge is not attached.");
@@ -195,11 +195,11 @@ public virtual async ValueTask DisposeAsync()
 /// <see cref="CopilotRequestHandler.OpenWebSocketAsync"/>. Override nothing to
 /// get full pass-through. To mutate traffic, subclass this type and override a
 /// send method, then call the base implementation to keep forwarding upstream.
-/// (Subclassing <see cref="CopilotWebSocketHandlerBase"/> instead would drop
+/// (Subclassing <see cref="CopilotWebSocketHandler"/> instead would drop
 /// forwarding entirely.)
 /// </summary>
 [Experimental(Diagnostics.Experimental)]
-public class CopilotWebSocketHandler : CopilotWebSocketHandlerBase
+public class CopilotWebSocketForwarder : CopilotWebSocketHandler
 {
     private readonly string _url;
     private readonly IReadOnlyDictionary<string, IReadOnlyList<string>> _headers;
@@ -212,7 +212,7 @@ public class CopilotWebSocketHandler : CopilotWebSocketHandlerBase
     /// demand using the supplied URL/headers (or the values from
     /// <paramref name="context"/> when omitted).
     /// </summary>
-    public CopilotWebSocketHandler(
+    public CopilotWebSocketForwarder(
         CopilotRequestContext context,
         string? url = null,
         IReadOnlyDictionary<string, IReadOnlyList<string>>? headers = null)
@@ -440,11 +440,11 @@ protected virtual Task<HttpResponseMessage> SendRequestAsync(HttpRequestMessage
 
     /// <summary>
     /// Open the upstream WebSocket connection. Override to return a custom
-    /// <see cref="CopilotWebSocketHandlerBase"/> or to construct a
-    /// <see cref="CopilotWebSocketHandler"/> against a rewritten URL.
+    /// <see cref="CopilotWebSocketHandler"/> or to construct a
+    /// <see cref="CopilotWebSocketForwarder"/> against a rewritten URL.
     /// </summary>
-    protected virtual Task<CopilotWebSocketHandlerBase> OpenWebSocketAsync(CopilotRequestContext ctx) =>
-        Task.FromResult<CopilotWebSocketHandlerBase>(new CopilotWebSocketHandler(ctx));
+    protected virtual Task<CopilotWebSocketHandler> OpenWebSocketAsync(CopilotRequestContext ctx) =>
+        Task.FromResult<CopilotWebSocketHandler>(new CopilotWebSocketForwarder(ctx));
 
     /// <summary>
     /// Entry point invoked by the adapter once per intercepted request. Routes to

dotnet/test/E2E/CopilotRequestWebSocketE2ETests.cs

@@ -22,7 +22,7 @@ namespace GitHub.Copilot.Test.E2E;
 /// transports against an in-process fake upstream: model-layer GETs and the
 /// single-shot HTTP <c>/responses</c> call are forwarded over HTTP, while the
 /// main turn flows over a real WebSocket opened by a
-/// <see cref="CopilotWebSocketHandler"/>.
+/// <see cref="CopilotWebSocketForwarder"/>.
 /// </summary>
 /// <remarks>
 /// This is the regression test for the WebSocket upgrade deadlock: the runtime
@@ -101,7 +101,7 @@ internal sealed class HandlerCounters
 /// A <see cref="CopilotRequestHandler"/> that points every intercepted request at
 /// the in-process <see cref="FakeCopilotUpstream"/>: HTTP requests are rewritten
 /// and forwarded by the base class, and WebSocket connections are opened against
-/// the rewritten URL via a counting <see cref="CopilotWebSocketHandler"/>.
+/// the rewritten URL via a counting <see cref="CopilotWebSocketForwarder"/>.
 /// </summary>
 internal sealed class ForwardingUpstreamHandler(string upstreamBaseUrl, HandlerCounters counters) : CopilotRequestHandler
 {
@@ -114,10 +114,10 @@ protected override Task<HttpResponseMessage> SendRequestAsync(HttpRequestMessage
         return base.SendRequestAsync(request, ctx);
     }
 
-    protected override Task<CopilotWebSocketHandlerBase> OpenWebSocketAsync(CopilotRequestContext ctx)
+    protected override Task<CopilotWebSocketHandler> OpenWebSocketAsync(CopilotRequestContext ctx)
     {
         var wsUrl = Rewrite(new Uri(ctx.Url)).ToString();
-        return Task.FromResult<CopilotWebSocketHandlerBase>(new CountingForwardingWebSocketHandler(ctx, wsUrl, counters));
+        return Task.FromResult<CopilotWebSocketHandler>(new CountingForwardingWebSocketHandler(ctx, wsUrl, counters));
     }
 
     private Uri Rewrite(Uri original) => new UriBuilder(original)
@@ -135,7 +135,7 @@ internal sealed class CountingForwardingWebSocketHandler(
     CopilotRequestContext context,
     string url,
     HandlerCounters counters)
-    : CopilotWebSocketHandler(context, url)
+    : CopilotWebSocketForwarder(context, url)
 {
     public override Task SendRequestMessageAsync(CopilotWebSocketMessage message)
     {

go/copilot_request_handler.go

@@ -108,7 +108,7 @@ type CopilotRequestHandler struct {
 	// used. RoundTrip is called directly, so redirects are not followed.
 	Transport http.RoundTripper
 	// OpenWebSocket returns a per-connection WebSocket handler. When nil a
-	// transparent [ForwardingCopilotWebSocketHandler] to the request URL is opened.
+	// transparent [CopilotWebSocketForwarder] to the request URL is opened.
 	OpenWebSocket func(ctx *CopilotRequestContext) (CopilotWebSocketHandler, error)
 }
 
@@ -124,7 +124,7 @@ type WebSocketResponseWriter interface {
 
 // CopilotWebSocketHandler is a per-connection WebSocket handler returned by
 // [CopilotRequestHandler.OpenWebSocket]. The default implementation is
-// [ForwardingCopilotWebSocketHandler]; a full transport replacement implements
+// [CopilotWebSocketForwarder]; a full transport replacement implements
 // this interface directly.
 type CopilotWebSocketHandler interface {
 	// Open establishes the connection and starts forwarding upstream→runtime
@@ -255,7 +255,7 @@ func (h *CopilotRequestHandler) handleWebSocket(rctx *CopilotRequestContext, sin
 	if h.OpenWebSocket != nil {
 		handler, err = h.OpenWebSocket(rctx)
 	} else {
-		handler = NewForwardingCopilotWebSocketHandler(rctx.URL, rctx.Headers)
+		handler = NewCopilotWebSocketForwarder(rctx.URL, rctx.Headers)
 	}
 	if err != nil {
 		return err
@@ -365,11 +365,11 @@ func (w *wsResponseWriter) fail(message string, code string) error {
 	return w.sink.sinkError(message, code)
 }
 
-// ForwardingCopilotWebSocketHandler is the default [CopilotWebSocketHandler]:
+// CopilotWebSocketForwarder is the default [CopilotWebSocketHandler]:
 // it dials the real upstream and runs a receive loop forwarding upstream→runtime
 // messages. Set OnSendRequestMessage / OnSendResponseMessage to observe,
 // transform, or drop messages in either direction.
-type ForwardingCopilotWebSocketHandler struct {
+type CopilotWebSocketForwarder struct {
 	URL     string
 	Headers http.Header
 	// OnSendRequestMessage observes or transforms each runtime→upstream frame.
@@ -390,13 +390,13 @@ type ForwardingCopilotWebSocketHandler struct {
 	closeOnce sync.Once
 }
 
-// NewForwardingCopilotWebSocketHandler creates a forwarding handler targeting
+// NewCopilotWebSocketForwarder creates a forwarding handler targeting
 // url with the given handshake headers.
-func NewForwardingCopilotWebSocketHandler(url string, headers http.Header) *ForwardingCopilotWebSocketHandler {
-	return &ForwardingCopilotWebSocketHandler{URL: url, Headers: headers, done: make(chan struct{})}
+func NewCopilotWebSocketForwarder(url string, headers http.Header) *CopilotWebSocketForwarder {
+	return &CopilotWebSocketForwarder{URL: url, Headers: headers, done: make(chan struct{})}
 }
 
-func (f *ForwardingCopilotWebSocketHandler) Open(ctx context.Context, resp WebSocketResponseWriter) error {
+func (f *CopilotWebSocketForwarder) Open(ctx context.Context, resp WebSocketResponseWriter) error {
 	f.resp = resp
 	if f.done == nil {
 		f.done = make(chan struct{})
@@ -412,7 +412,7 @@ func (f *ForwardingCopilotWebSocketHandler) Open(ctx context.Context, resp WebSo
 	return nil
 }
 
-func (f *ForwardingCopilotWebSocketHandler) dialHeaders() http.Header {
+func (f *CopilotWebSocketForwarder) dialHeaders() http.Header {
 	out := http.Header{}
 	for name, values := range f.Headers {
 		if isForbiddenRequestHeader(name) {
@@ -425,7 +425,7 @@ func (f *ForwardingCopilotWebSocketHandler) dialHeaders() http.Header {
 	return out
 }
 
-func (f *ForwardingCopilotWebSocketHandler) receiveLoop(ctx context.Context) {
+func (f *CopilotWebSocketForwarder) receiveLoop(ctx context.Context) {
 	defer close(f.done)
 	for {
 		typ, data, err := f.conn.Read(ctx)
@@ -455,7 +455,7 @@ func (f *ForwardingCopilotWebSocketHandler) receiveLoop(ctx context.Context) {
 	}
 }
 
-func (f *ForwardingCopilotWebSocketHandler) SendRequestMessage(ctx context.Context, msg CopilotWebSocketMessage) error {
+func (f *CopilotWebSocketForwarder) SendRequestMessage(ctx context.Context, msg CopilotWebSocketMessage) error {
 	out := msg
 	if f.OnSendRequestMessage != nil {
 		transformed := f.OnSendRequestMessage(msg)
@@ -474,10 +474,10 @@ func (f *ForwardingCopilotWebSocketHandler) SendRequestMessage(ctx context.Conte
 	return f.conn.Write(ctx, msgType, out.Data)
 }
 
-func (f *ForwardingCopilotWebSocketHandler) Done() <-chan struct{} { return f.done }
-func (f *ForwardingCopilotWebSocketHandler) Err() error            { return f.err }
+func (f *CopilotWebSocketForwarder) Done() <-chan struct{} { return f.done }
+func (f *CopilotWebSocketForwarder) Err() error            { return f.err }
 
-func (f *ForwardingCopilotWebSocketHandler) Close() error {
+func (f *CopilotWebSocketForwarder) Close() error {
 	f.closeOnce.Do(func() {
 		if f.conn != nil {
 			_ = f.conn.Close(websocket.StatusNormalClosure, "")

go/internal/e2e/copilot_request_handler_e2e_test.go

@@ -145,7 +145,7 @@ func TestCopilotRequestHandler(t *testing.T) {
 			}
 			parsed.Scheme = wsBase.Scheme
 			parsed.Host = wsBase.Host
-			fwd := copilot.NewForwardingCopilotWebSocketHandler(parsed.String(), rctx.Headers)
+			fwd := copilot.NewCopilotWebSocketForwarder(parsed.String(), rctx.Headers)
 			fwd.OnSendRequestMessage = func(msg copilot.CopilotWebSocketMessage) *copilot.CopilotWebSocketMessage {
 				counters.wsRequestMessages.Add(1)
 				return &msg

java/src/main/java/com/github/copilot/CopilotRequestHandler.java

@@ -26,7 +26,7 @@
  * model-layer HTTP and WebSocket traffic through this handler instead of
  * issuing the calls itself. Subclass and override {@link #sendRequest} to
  * mutate or replace HTTP calls, or {@link #openWebSocket} to mutate the
- * handshake or return a fully custom {@link CopilotWebSocketHandlerBase}.
+ * handshake or return a fully custom {@link CopilotWebSocketHandler}.
  *
  * @since 1.0.0
  */
@@ -89,8 +89,8 @@ protected HttpResponse<InputStream> sendRequest(HttpRequest request, CopilotRequ
      * @throws Exception
      *             if the handler could not be created
      */
-    protected CopilotWebSocketHandlerBase openWebSocket(CopilotRequestContext ctx) throws Exception {
-        return new CopilotWebSocketHandler(ctx);
+    protected CopilotWebSocketHandler openWebSocket(CopilotRequestContext ctx) throws Exception {
+        return new CopilotWebSocketForwarder(ctx);
     }
 
     /**
@@ -160,7 +160,7 @@ private void handleWebSocket(LlmInferenceExchange exchange) throws Exception {
         LlmWebSocketResponseBridge bridge = new LlmWebSocketResponseBridge(exchange);
         ctx.setWebSocketResponse(bridge);
 
-        CopilotWebSocketHandlerBase handler = openWebSocket(ctx);
+        CopilotWebSocketHandler handler = openWebSocket(ctx);
         try {
             handler.open();