fix: ReadBuffer skips malformed lines instead of stalling on them

Previously, readMessage() returned null after consuming an unparseable line even when more complete lines existed in the buffer. This caused valid messages following a bad line in the same chunk to be silently dropped until the next chunk arrived (or forever, in tests).

Fix the loop so null means only "no complete line available", not "encountered a parse failure". Blank/whitespace-only lines are now silently skipped via isBlank() rather than forwarded to the deserializer and logged as errors.

Refactor the method into three focused helpers:
 - readMessage() — outer loop over lines
 - readLine()    — consume the next newline-delimited line from the buffer
 - tryRecover()  — attempt deserialization from the first '{' onward

Author: kpavlov

kotlin-sdk-core/src/commonMain/kotlin/io/modelcontextprotocol/kotlin/sdk/shared/ReadBuffer.kt

@@ -20,45 +20,56 @@ public class ReadBuffer {
         buffer.write(chunk)
     }
 
+    @Suppress("TooGenericExceptionCaught")
     public fun readMessage(): JSONRPCMessage? {
-        if (buffer.exhausted()) return null
-        var lfIndex = buffer.indexOf('\n'.code.toByte())
-        val line = when (lfIndex) {
-            -1L -> return null
+        var message: JSONRPCMessage? = null
+        while (message == null) {
+            val line = readNextLine() ?: return null
+            if (line.isBlank()) continue
 
-            0L -> {
-                buffer.skip(1)
-                return null
-            }
-
-            else -> {
-                var skipBytes = 1
-                if (buffer[lfIndex - 1] == '\r'.code.toByte()) {
-                    lfIndex -= 1
-                    skipBytes += 1
-                }
-                val string = buffer.readString(lfIndex)
-                buffer.skip(skipBytes.toLong())
-                string
+            try {
+                message = deserializeMessage(line)
+            } catch (e: Exception) {
+                logger.error(e) { "Failed to deserialize message from line: $line\nAttempting to recover..." }
+                message = tryRecover(line)
             }
         }
-        try {
-            return deserializeMessage(line)
-        } catch (e: Exception) {
-            logger.error(e) { "Failed to deserialize message from line: $line\nAttempting to recover..." }
-            // if there is a non-JSON object prefix, try to parse from the first '{' onward.
-            val braceIndex = line.indexOf('{')
-            if (braceIndex != -1) {
-                val trimmed = line.substring(braceIndex)
-                try {
-                    return deserializeMessage(trimmed)
-                } catch (ignored: Exception) {
-                    logger.error(ignored) { "Deserialization failed for line: $line\nSkipping..." }
-                }
+        return message
+    }
+
+    private fun readNextLine(): String? {
+        val lfIndex = if (buffer.exhausted()) -1L else buffer.indexOf('\n'.code.toByte())
+        if (lfIndex == -1L) return null
+
+        return if (lfIndex == 0L) {
+            buffer.skip(1)
+            ""
+        } else {
+            var skipBytes = 1
+            var messageLength = lfIndex
+            if (buffer[lfIndex - 1] == '\r'.code.toByte()) {
+                messageLength -= 1
+                skipBytes += 1
             }
+            val string = buffer.readString(messageLength)
+            buffer.skip(skipBytes.toLong())
+            string
         }
+    }
 
-        return null
+    @Suppress("TooGenericExceptionCaught")
+    private fun tryRecover(line: String): JSONRPCMessage? {
+        // if there is a non-JSON object prefix, try to parse from the first '{' onward.
+        val braceIndex = line.indexOf('{')
+        if (braceIndex == -1) return null
+
+        val trimmed = line.substring(braceIndex)
+        return try {
+            deserializeMessage(trimmed)
+        } catch (ignored: Exception) {
+            logger.error(ignored) { "Deserialization failed for line: $line\nSkipping..." }
+            null
+        }
     }
 
     public fun clear() {

kotlin-sdk-core/src/commonTest/kotlin/io/modelcontextprotocol/kotlin/sdk/shared/ReadBufferTest.kt

@@ -31,6 +31,8 @@ class ReadBufferTest {
         val messageBytes = json.encodeToString(testMessage).encodeToByteArray()
         readBuffer.append(messageBytes)
         assertNull(readBuffer.readMessage())
+        readBuffer.append("\r".encodeToByteArray())
+        assertNull(readBuffer.readMessage())
 
         // Append a newline and verify message is now available
         readBuffer.append("\n".encodeToByteArray())
@@ -45,6 +47,20 @@ class ReadBufferTest {
         assertNull(readBuffer.readMessage())
     }
 
+    @Test
+    fun `skip blank line`() {
+        val readBuffer = ReadBuffer()
+        readBuffer.append(" \n".toByteArray())
+        assertNull(readBuffer.readMessage())
+    }
+
+    @Test
+    fun `skip invalid json line`() {
+        val readBuffer = ReadBuffer()
+        readBuffer.append(" {ah=oh\n".toByteArray())
+        assertNull(readBuffer.readMessage())
+    }
+
     @Test
     fun `should be reusable after clearing`() {
         val readBuffer = ReadBuffer()

kotlin-sdk-server/src/jvmTest/kotlin/io/modelcontextprotocol/kotlin/sdk/server/StdioServerTransportTest.kt

@@ -260,6 +260,7 @@ class StdioServerTransportTest {
 
             val validMessage = PingRequest().toJSON()
             inputWriter.write("not-valid-json\n".toByteArray())
+            inputWriter.write(" \t \r \n".toByteArray()) // blank line
             inputWriter.write(serializeMessage(validMessage).toByteArray())
             inputWriter.flush()