Method handleInitializeAPISession

internal/lsp/server.go:1732–1798

(ctx context.Context, params *lsproto.InitializeAPISessionParams, _ *lsproto.RequestMessage)

}

func (s *Server) handleInitializeAPISession(ctx context.Context, params *lsproto.InitializeAPISessionParams, _ *lsproto.RequestMessage) (lsproto.CustomInitializeAPISessionResponse, error) {
	s.apiSessionsMu.Lock()
	defer s.apiSessionsMu.Unlock()

	if s.apiSessions == nil {
		s.apiSessions = make(map[string]*api.Session)
	}

	var apiSession *api.Session
	apiSession = api.NewSession(s.session, nil)

	// Use provided pipe path or generate a unique one
	var pipePath string
	if params.Pipe != nil && *params.Pipe != "" {
		pipePath = *params.Pipe
	} else {
		pipePath = s.generateAPIPipePath()
	}

	transport, err := api.NewPipeTransport(pipePath)
	if err != nil {
		return nil, fmt.Errorf("failed to create API transport: %w", err)
	}

	// Start accepting connections in the background
	go func() {
		defer func() {
			apiSession.Close()
			s.removeAPISession(apiSession.ID())
		}()

		rwc, acceptErr := transport.Accept()
		_ = transport.Close()
		if acceptErr != nil {
			s.logger.Errorf("API session %s: failed to accept connection: %v", apiSession.ID(), acceptErr)
			return
		}

		// Create a cancellable context for the API connection
		apiCtx, apiCancel := context.WithCancel(s.backgroundCtx)
		defer apiCancel()

		// Run the connection with panic recovery
		defer func() {
			if r := recover(); r != nil {
				stack := debug.Stack()
				s.logger.Errorf("API session %s: panic: %v\n%s", apiSession.ID(), r, string(stack))
				// Cancel the context to shut down the connection
				apiCancel()
				// Close the underlying connection
				rwc.Close()
			}
		}()

		conn := api.NewAsyncConn(rwc, apiSession)
		if apiErr := conn.Run(apiCtx); apiErr != nil {
			s.logger.Errorf("API session %s: %v", apiSession.ID(), apiErr)
		}