How to use the vscode-jsonrpc.StreamMessageReader function in vscode-jsonrpc

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

import { StreamMessageReader, StreamMessageWriter } from 'vscode-jsonrpc';

import { start } from './LUServer';

const reader = new StreamMessageReader(process.stdin);
const writer = new StreamMessageWriter(process.stdout);
start(reader, writer);

function createLSConnection(ballerinaHome: string) : LangServerProcessConnection {
    const childProcess = createServer(ballerinaHome);
    childProcess.on('error', (err) => {
        // log('Error while starting LS', err);
    });
    const reader = new StreamMessageReader(childProcess.stdout);
    const writer = new StreamMessageWriter(childProcess.stdin);
    const messageConntection = createMessageConnection(reader, writer);
    const errorHandler: ConnectionErrorHandler = (err, msg, count) => {
       // log('Error while starting LS', err);
    };
    const closeHandler: ConnectionCloseHandler = () => {
       // log('LS Connection closed');
    };
    const lsConnection = createConnection(messageConntection, errorHandler, closeHandler);
    return {
        childProcess,
        lsConnection
    }
}

this._process.on("close", (code: number, signal: string) => {
            Log.warn(`[LANGUAGE CLIENT]: Process closed with exit code ${code} and signal ${signal}`)
        })

        const logFunc = (msg: any) => {
            Log.debug(`[LANGUAGE CLIENT - DEBUG] ${msg}`)
        }
        const errFunc = (msg: any) => {
            Log.error(`[LANGUAGE CLIENT - ERROR]: ${msg}`)
            this._statusBar.setStatus(LanguageClientState.Error)
        }
        this._process.stderr.on("data", (this._startOptions.stderrAsLog) ? logFunc : errFunc)

        this._connection = rpc.createMessageConnection(
            (new rpc.StreamMessageReader(this._process.stdout)) as any,
            (new rpc.StreamMessageWriter(this._process.stdin)) as any,
            new LanguageClientLogger())

        this._currentOpenDocumentPath = null
        this._serverCapabilities = null

        this._connection.onNotification(Helpers.ProtocolConstants.Window.LogMessage, (args) => {
            Log.info(JSON.stringify(args))
        })

        this._connection.onNotification(Helpers.ProtocolConstants.Telemetry.Event, (args) => {
            Log.info(JSON.stringify(args))
        })

        this._connection.onNotification(Helpers.ProtocolConstants.Window.ShowMessage, (args) => {
            // TODO: Need alternate paradigm for showing a message

this.testCases.push(...discoveryTestCases);
            })

            findDuplicatesTestCases(discoveryTestCases);

            return {
                testCases: discoveryTestCases
            }
        });

    }
}


const mochaLanguageServer = new MochaTestLanguageServer();
mochaLanguageServer.listen(new StreamMessageReader(process.stdin),
    new StreamMessageWriter(process.stdout));

/**
 * Override default console.log to redirect output from user test cases to the appropriate channel
 */
console.log = function (data: string) {
    mochaLanguageServer.getConnection().dataOutput({ data });
};

/**
 * Find all duplicate test cases and log the information
 * @param testCases
 */
function findDuplicatesTestCases(testCases : Array) {
    const fullTitles = testCases.map((testCase) => {return testCase.fullTitle});

process.exit(1)
}

const kak = Kak.Init(Splice, {
  session,
  debug,
})

console.log('spawning')
const child = cp.spawn(server, args, {
  detached: true,
  stdio: 'pipe',
})

const connection = rpc.createMessageConnection(
  new rpc.StreamMessageReader(child.stdout),
  new rpc.StreamMessageWriter(child.stdin)
)

console.log('running')

function OnNotification(
  type: lsp.NotificationType,
  handler: lsp.NotificationHandler<p>
): void {
  return connection.onNotification(type, handler)
}

OnNotification(lsp.ShowMessageNotification.type, params =&gt; {
  if (debug_connection) {
    console.group('notification', params.type)
    console.log(params.message)</p>

.createServer(client => {
            client.setEncoding('utf8');
            reader = new SocketMessageReader(client);
            writer = new SocketMessageWriter(client);
            client.on('end', () => {
              socket.close();
              process.exit(0);
            });
            const connection = createMessageConnection(reader, writer, logger);
            addHandlers(connection, logger, options.configDir);
            connection.listen();
          })
          .listen(port);
        return;
      case 'stream':
        reader = new StreamMessageReader(process.stdin);
        writer = new StreamMessageWriter(process.stdout);
        break;
      case 'node':
      default:
        reader = new IPCMessageReader(process);
        writer = new IPCMessageWriter(process);
        break;
    }
    const connection = createMessageConnection(reader, writer, logger);
    addHandlers(connection, logger, options.configDir);
    connection.listen();
  }
});

export function createConnection(childProcess: ChildProcess): Connection {
    const reader = new StreamMessageReader(childProcess.stdout);
    const writer = new StreamMessageWriter(childProcess.stdin);
    return {
        reader, writer,
        forward(to: Connection, map: (message: Message) => Message = message => message): void {
            reader.listen(input => {
                const output = map(input);
                to.writer.write(output);
            });
        },
        dispose: () => {
            childProcess.kill();
            reader.dispose();
            writer.dispose();
        }
    };
}

protected initialize() {
        try {
            //find binaries path
            let langServerPath : string = this._context.asAbsolutePath("bin/AZALDevToolsServer.exe");
            //start child process
            this._childProcess = cp.spawn(langServerPath, [this._alExtensionPath]);
            if (this._childProcess) {
                this._connection = rpc.createMessageConnection(
                    new rpc.StreamMessageReader(this._childProcess.stdout),
                    new rpc.StreamMessageWriter(this._childProcess.stdin));
                this._connection.listen();
            }
        }
        catch (e) {
        }
    }