Deprecation cycle (#498)

- increase the deprecation level
- remove tests that use deprecated objects with deprecation level =
error

## Motivation and Context
deprecation lifecycle

## How Has This Been Tested?
-

## Breaking Changes
-

## Types of changes
- [ ] Bug fix (non-breaking change which fixes an issue)
- [ ] New feature (non-breaking change which adds functionality)
- [ ] Breaking change (fix or feature that would cause existing
functionality to change)
- [ ] Documentation update

## Checklist
- [x] I have read the [MCP
Documentation](https://modelcontextprotocol.io)
- [x] My code follows the repository's style guidelines
- [x] New and existing tests pass locally
- [ ] I have added appropriate error handling
- [ ] I have added or updated documentation as needed

kotlin-sdk-server/src/commonMain/kotlin/io/modelcontextprotocol/kotlin/sdk/server/SSEServerTransport.kt

@@ -22,9 +22,6 @@ import kotlin.uuid.Uuid
 
 internal const val SESSION_ID_PARAM = "sessionId"
 
-@Deprecated("Use SseServerTransport instead", ReplaceWith("SseServerTransport"), DeprecationLevel.ERROR)
-public typealias SSEServerTransport = SseServerTransport
-
 /**
  * Server transport for SSE: this will send messages over an SSE connection and receive messages from HTTP POST requests.
  *

kotlin-sdk-server/src/commonMain/kotlin/io/modelcontextprotocol/kotlin/sdk/server/Server.kt

@@ -173,7 +173,7 @@ public open class Server(
     @Deprecated(
         "Use createSession(transport) instead.",
         ReplaceWith("createSession(transport)"),
-        DeprecationLevel.WARNING,
+        DeprecationLevel.ERROR,
     )
     public suspend fun connect(transport: Transport): ServerSession = createSession(transport)
 
@@ -266,7 +266,7 @@ public open class Server(
     @Deprecated(
         "Initialization moved to ServerSession, use ServerSession.onInitialized instead.",
         ReplaceWith("ServerSession.onInitialized"),
-        DeprecationLevel.WARNING,
+        DeprecationLevel.ERROR,
     )
     public fun onInitialized(block: () -> Unit) {
         val old = _onInitialized

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

@@ -1,140 +0,0 @@
-package io.modelcontextprotocol.kotlin.sdk.server
-
-import io.modelcontextprotocol.kotlin.sdk.InitializedNotification
-import io.modelcontextprotocol.kotlin.sdk.JSONRPCMessage
-import io.modelcontextprotocol.kotlin.sdk.PingRequest
-import io.modelcontextprotocol.kotlin.sdk.shared.ReadBuffer
-import io.modelcontextprotocol.kotlin.sdk.shared.serializeMessage
-import io.modelcontextprotocol.kotlin.sdk.toJSON
-import kotlinx.coroutines.CompletableDeferred
-import kotlinx.coroutines.runBlocking
-import kotlinx.coroutines.test.runTest
-import kotlinx.io.Sink
-import kotlinx.io.Source
-import kotlinx.io.asSink
-import kotlinx.io.asSource
-import kotlinx.io.buffered
-import java.io.ByteArrayOutputStream
-import java.io.PipedInputStream
-import java.io.PipedOutputStream
-import kotlin.test.BeforeTest
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertFalse
-import kotlin.test.assertTrue
-
-class OldSchemaStdioServerTransportTest {
-    private lateinit var input: PipedInputStream
-    private lateinit var inputWriter: PipedOutputStream
-    private lateinit var outputBuffer: ReadBuffer
-    private lateinit var output: ByteArrayOutputStream
-
-    // We'll store the wrapped streams that meet the constructor requirements
-    private lateinit var bufferedInput: Source
-    private lateinit var printOutput: Sink
-
-    @BeforeTest
-    fun setUp() {
-        // Simulate an input stream that we can push data into using inputWriter.
-        input = PipedInputStream()
-        inputWriter = PipedOutputStream(input)
-
-        outputBuffer = ReadBuffer()
-
-        // A custom ByteArrayOutputStream that appends all written data into outputBuffer
-        output = object : ByteArrayOutputStream() {
-            override fun write(b: ByteArray, off: Int, len: Int) {
-                super.write(b, off, len)
-                outputBuffer.append(b.copyOfRange(off, off + len))
-            }
-        }
-
-        bufferedInput = input.asSource().buffered()
-
-        printOutput = output.asSink().buffered()
-    }
-
-    @Test
-    fun `should start then close cleanly`() {
-        runBlocking {
-            val server = StdioServerTransport(bufferedInput, printOutput)
-            server.onError { error ->
-                throw error
-            }
-
-            var didClose = false
-            server.onClose {
-                didClose = true
-            }
-
-            server.start()
-            assertFalse(didClose, "Should not have closed yet")
-
-            server.close()
-            assertTrue(didClose, "Should have closed after calling close()")
-        }
-    }
-
-    @Test
-    fun `should not read until started`() = runTest {
-        val server = StdioServerTransport(bufferedInput, printOutput)
-        server.onError { error ->
-            throw error
-        }
-
-        var didRead = false
-        val readMessage = CompletableDeferred<JSONRPCMessage>()
-
-        server.onMessage { message ->
-            didRead = true
-            readMessage.complete(message)
-        }
-
-        val message = PingRequest().toJSON()
-
-        // Push a message before the server started
-        val serialized = serializeMessage(message)
-        inputWriter.write(serialized)
-        inputWriter.flush()
-
-        assertFalse(didRead, "Should not have read message before start")
-
-        server.start()
-        val received = readMessage.await()
-        assertEquals(message, received)
-    }
-
-    @Test
-    fun `should read multiple messages`() = runTest {
-        val server = StdioServerTransport(bufferedInput, printOutput)
-        server.onError { error ->
-            throw error
-        }
-
-        val messages = listOf(
-            PingRequest().toJSON(),
-            InitializedNotification().toJSON(),
-        )
-
-        val readMessages = mutableListOf<JSONRPCMessage>()
-        val finished = CompletableDeferred<Unit>()
-
-        server.onMessage { message ->
-            readMessages.add(message)
-            if (message == messages[1]) {
-                finished.complete(Unit)
-            }
-        }
-
-        // Push both messages before starting the server
-        for (m in messages) {
-            inputWriter.write(serializeMessage(m))
-        }
-        inputWriter.flush()
-
-        server.start()
-        finished.await()
-
-        assertEquals(messages, readMessages)
-    }
-}