Update Client.connect(transport:) to automatically send initialize request (#100)

* Update Client to automatically call initialize in connect

* Make Client.connect(transport:) return value discardable

* Fix example usage in README

* Update example code in transports to remove initialize call

* Deprecate initialize method

* Update tests

* Update README

* Fix sampling tests

* Fix race condition tests

Author: mattt

README.md

@@ -54,17 +54,19 @@ let client = Client(name: "MyApp", version: "1.0.0")
 
 // Create a transport and connect
 let transport = StdioTransport()
-try await client.connect(transport: transport)
-
-// Initialize the connection
-let result = try await client.initialize()
+let result = try await client.connect(transport: transport)
 
 // Check server capabilities
 if result.capabilities.tools != nil {
     // Server supports tools (implicitly including tool calling if the 'tools' capability object is present)
 }
 ```
 
+> [!NOTE]
+> The `Client.connect(transport:)` method returns the initialization result.
+> This return value is discardable, 
+> so you can ignore it if you don't need to check server capabilities.
+
 ### Transport Options for Clients
 
 #### Stdio Transport
@@ -278,7 +280,7 @@ Handle common client errors:
 
 ```swift
 do {
-    let result = try await client.initialize()
+    try await client.connect(transport: transport)
     // Success
 } catch let error as MCPError {
     print("MCP Error: \(error.localizedDescription)")
@@ -402,7 +404,7 @@ The server component allows your application to host model capabilities and resp
 ```swift
 import MCP
 
-// Initialize the server with capabilities
+// Create a server with given capabilities
 let server = Server(
     name: "MyModelServer",
     version: "1.0.0",

Sources/MCP/Base/Transports/HTTPClientTransport.swift

@@ -41,9 +41,6 @@ import Logging
 /// let client = Client(name: "MyApp", version: "1.0.0")
 /// try await client.connect(transport: transport)
 ///
-/// // Initialize the connection
-/// let result = try await client.initialize()
-///
 /// // The transport will automatically handle SSE events
 /// // and deliver them through the client's notification handlers
 /// ```

Sources/MCP/Base/Transports/NetworkTransport.swift

@@ -51,9 +51,6 @@ import Logging
     /// // Use the transport with an MCP client
     /// let client = Client(name: "MyApp", version: "1.0.0")
     /// try await client.connect(transport: transport)
-    ///
-    /// // Initialize the connection
-    /// let result = try await client.initialize()
     /// ```
     public actor NetworkTransport: Transport {
         /// Represents a heartbeat message for connection health monitoring.

Sources/MCP/Base/Transports/StdioTransport.swift

@@ -44,9 +44,6 @@ import struct Foundation.Data
     /// // Create a transport and connect
     /// let transport = StdioTransport()
     /// try await client.connect(transport: transport)
-    ///
-    /// // Initialize the connection
-    /// let result = try await client.initialize()
     /// ```
     public actor StdioTransport: Transport {
         private let input: FileDescriptor

Sources/MCP/Client/Client.swift

@@ -168,7 +168,8 @@ public actor Client {
     }
 
     /// Connect to the server using the given transport
-    public func connect(transport: any Transport) async throws {
+    @discardableResult
+    public func connect(transport: any Transport) async throws -> Initialize.Result {
         self.connection = transport
         try await self.connection?.connect()
 
@@ -217,6 +218,9 @@ public actor Client {
             } while true
             await self.logger?.info("Client message handling loop task is terminating.")
         }
+
+        // Automatically initialize after connecting
+        return try await _initialize()
     }
 
     /// Disconnect the client and cancel all pending requests
@@ -480,7 +484,23 @@ public actor Client {
 
     // MARK: - Lifecycle
 
+    /// Initialize the connection with the server.
+    ///
+    /// - Important: This method is deprecated. Initialization now happens automatically
+    ///   when calling `connect(transport:)`. You should use that method instead.
+    ///
+    /// - Returns: The server's initialization response containing capabilities and server info
+    @available(
+        *, deprecated,
+        message:
+            "Initialization now happens automatically during connect. Use connect(transport:) instead."
+    )
     public func initialize() async throws -> Initialize.Result {
+        return try await _initialize()
+    }
+
+    /// Internal initialization implementation
+    private func _initialize() async throws -> Initialize.Result {
         let request = Initialize.request(
             .init(
                 protocolVersion: Version.latest,

Tests/MCPTests/ClientTests.swift

@@ -653,11 +653,8 @@ import Testing
                 }
             }
 
-            // Execute the complete flow
-            try await client.connect(transport: transport)
-
             // Step 1: Initialize client
-            let initResult = try await client.initialize()
+            let initResult = try await client.connect(transport: transport)
             #expect(initResult.protocolVersion == Version.latest)
             #expect(initResult.capabilities.tools != nil)
 

Tests/MCPTests/HTTPClientTransportTests.swift

@@ -99,10 +99,9 @@ struct RoundtripTests {
         let client = Client(name: "TestClient", version: "1.0")
 
         try await server.start(transport: serverTransport)
-        try await client.connect(transport: clientTransport)
 
         let initTask = Task {
-            let result = try await client.initialize()
+            let result = try await client.connect(transport: clientTransport)
 
             #expect(result.serverInfo.name == "TestServer")
             #expect(result.serverInfo.version == "1.0.0")

Tests/MCPTests/RoundtripTests.swift

@@ -587,30 +587,6 @@ struct SamplingIntegrationTests {
         try await server.start(transport: serverTransport)
         try await client.connect(transport: clientTransport)
 
-        // Test initialization and capability negotiation
-        let initTask = Task {
-            let result = try await client.initialize()
-
-            #expect(result.serverInfo.name == "SamplingTestServer")
-            #expect(result.serverInfo.version == "1.0.0")
-            #expect(
-                result.capabilities.sampling != nil, "Server should advertise sampling capability")
-            #expect(result.protocolVersion == Version.latest)
-        }
-
-        try await withThrowingTaskGroup(of: Void.self) { group in
-            group.addTask {
-                try await Task.sleep(for: .seconds(1))
-                initTask.cancel()
-                throw CancellationError()
-            }
-            group.addTask {
-                try await initTask.value
-            }
-            try await group.next()
-            group.cancelAll()
-        }
-
         await server.stop()
         await client.disconnect()
         try? clientToServerRead.close()