Method handleWebSocket

go/copilot_request_handler.go:254–312

(rctx *CopilotRequestContext, sink *responseSink)

}

func (h *CopilotRequestHandler) handleWebSocket(rctx *CopilotRequestContext, sink *responseSink) error {
	var handler CopilotWebSocketHandler
	var err error
	if h.OpenWebSocket != nil {
		handler, err = h.OpenWebSocket(rctx)
	} else {
		handler = NewCopilotWebSocketForwarder(rctx.URL, rctx.Headers)
	}
	if err != nil {
		return err
	}

	writer := &wsResponseWriter{sink: sink}
	// Emit the 101 upgrade head eagerly — the runtime gates connect_via_callback
	// on receiving httpResponseStart/101 before sending request chunks; a lazy
	// first-write start deadlocks until timeout.
	if err := writer.start(); err != nil {
		return err
	}
	if err := handler.Open(rctx.Context, writer); err != nil {
		return writer.fail(err.Error(), "")
	}
	defer func() { _ = handler.Close() }()

	clientDone := make(chan struct{})
	go func() {
		defer close(clientDone)
		for {
			select {
			case frame, ok := <-rctx.body:
				if !ok {
					return
				}
				if err := handler.SendRequestMessage(rctx.Context, frame); err != nil {
					return
				}
			case <-rctx.Context.Done():
				return
			}
		}
	}()

	select {
	case <-handler.Done():
		if e := handler.Err(); e != nil {
			return writer.fail(e.Error(), "")
		}
		return writer.end()
	case <-clientDone:
		_ = handler.Close()
		<-handler.Done()
		if e := handler.Err(); e != nil {
			return writer.fail(e.Error(), "")
		}
		return writer.end()
	case <-rctx.Context.Done():
		return writer.fail("Request cancelled by runtime", "cancelled")
	}