Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.
Rust agentai-agentapplecomputer-usecomputer-use-agentcontainerizationcuadesktop-automationhacktoberfestlumemacosmanusoperatorswiftvirtualizationvirtualization-frameworkwindowswindows-sandbox
fix(lume): replace custom HTTP server with NIOHTTP1 to fix 'Invalid request body' (#1236)
ddupontfe205d5960a4
diff --git a/libs/lume/Package.resolved b/libs/lume/Package.resolvedindex 1c581ba0f5..eda811830b 100644--- a/libs/lume/Package.resolved+++ b/libs/lume/Package.resolved@@ -1,5 +1,5 @@{- "originHash" : "b0869df3ba5ae43764c89b3ecf9d8da7c06c91709d49fd9999c35e57cc5e45df",+ "originHash" : "e211eb961ff71ceccb522c1477d4f18226110d69b566538f7da616eec2b3774b","pins" : [{"identity" : "dynamic",@@ -123,8 +123,8 @@"kind" : "remoteSourceControl","location" : "https://github.com/modelcontextprotocol/swift-sdk.git","state" : {- "revision" : "c0407a0b52677cb395d824cac2879b963075ba8c",- "version" : "0.10.2"+ "revision" : "6132fd4b5b4217ce4717c4775e4607f5c3120129",+ "version" : "0.12.0"}},{diff --git a/libs/lume/Package.swift b/libs/lume/Package.swiftindex 849677cd6a..64d38f8d2c 100644--- a/libs/lume/Package.swift+++ b/libs/lume/Package.swift@@ -14,7 +14,7 @@ let package = Package(.package(url: "https://github.com/apple/swift-atomics.git", .upToNextMajor(from: "1.2.0")),.package(url: "https://github.com/mhdhejazi/Dynamic", branch: "master"),.package(url: "https://github.com/jpsim/Yams.git", from: "5.0.0"),- .package(url: "https://github.com/modelcontextprotocol/swift-sdk.git", from: "0.10.0"),+ .package(url: "https://github.com/modelcontextprotocol/swift-sdk.git", from: "0.12.0"),.package(url: "https://github.com/apple/swift-nio.git", from: "2.81.0"),.package(url: "https://github.com/apple/swift-nio-ssh.git", from: "0.12.0")],@@ -34,6 +34,7 @@ let package = Package(.product(name: "MCP", package: "swift-sdk"),.product(name: "NIOCore", package: "swift-nio"),.product(name: "NIOPosix", package: "swift-nio"),+ .product(name: "NIOHTTP1", package: "swift-nio"),.product(name: "NIOConcurrencyHelpers", package: "swift-nio"),.product(name: "NIOSSH", package: "swift-nio-ssh")],diff --git a/libs/lume/src/Server/HTTP.swift b/libs/lume/src/Server/HTTP.swiftindex d2dd86a0da..7efe0f2824 100644--- a/libs/lume/src/Server/HTTP.swift+++ b/libs/lume/src/Server/HTTP.swift@@ -10,7 +10,15 @@ struct HTTPRequest {let path: Stringlet headers: [String: String]let body: Data?-++ /// Memberwise init used by the NIO handler (components already parsed).+ init(method: String, path: String, headers: [String: String], body: Data?) {+ self.method = method+ self.path = path+ self.headers = headers+ self.body = body+ }+init?(data: Data) {guard let requestString = String(data: data, encoding: .utf8) else { return nil }let components = requestString.components(separatedBy: "\r\n\r\n")diff --git a/libs/lume/src/Server/Server.swift b/libs/lume/src/Server/Server.swiftindex 9be86b90d9..9cf8f791fc 100644--- a/libs/lume/src/Server/Server.swift+++ b/libs/lume/src/Server/Server.swift@@ -1,8 +1,10 @@-import Darwinimport Foundation-import Network+import NIOCore+import NIOPosix+import NIOHTTP1// MARK: - Error Types+enum PortError: Error, LocalizedError {case alreadyInUse(port: UInt16)@@ -14,11 +16,117 @@ enum PortError: Error, LocalizedError {}}+// MARK: - NIO Channel Handler++/// Accumulates HTTP/1.1 request parts delivered by NIOHTTP1's decoder (which+/// already handles Content-Length / chunked-encoding reassembly), then+/// dispatches the complete request to the Server's route handlers.+private final class HTTPChannelHandler: ChannelInboundHandler, @unchecked Sendable {+ typealias InboundIn = HTTPServerRequestPart+ typealias OutboundOut = HTTPServerResponsePart++ private var requestHead: HTTPRequestHead?+ private var bodyBuffer: ByteBuffer = ByteBuffer()+ private let server: Server++ init(server: Server) {+ self.server = server+ }++ func channelRead(context: ChannelHandlerContext, data: NIOAny) {+ switch unwrapInboundIn(data) {+ case .head(let head):+ requestHead = head+ bodyBuffer.clear()+ case .body(var buf):+ bodyBuffer.writeBuffer(&buf)+ case .end:+ guard let head = requestHead else { return }+ let bodyData: Data? =+ bodyBuffer.readableBytes > 0 ? Data(bodyBuffer.readableBytesView) : nil+ var headers: [String: String] = [:]+ for (name, value) in head.headers {+ headers[name.description] = value+ }+ let request = HTTPRequest(+ method: head.method.rawValue,+ path: head.uri,+ headers: headers,+ body: bodyData+ )+ Logger.info(+ "Received request",+ metadata: [+ "method": request.method,+ "path": request.path,+ "body": String(data: bodyData ?? Data(), encoding: .utf8) ?? "",+ ])++ // Bridge to Swift concurrency via an EventLoopPromise so that+ // ChannelHandlerContext (non-Sendable) is only ever accessed on+ // the event loop — never sent across actor boundaries.+ let promise = context.eventLoop.makePromise(of: HTTPResponse.self)+ let srv = server+ Task {+ do {+ let response = try await srv.handleRequest(request)+ promise.succeed(response)+ } catch {+ promise.succeed(srv.errorResponse(error))+ }+ }+ promise.futureResult.whenComplete { result in+ let response: HTTPResponse+ switch result {+ case .success(let r): response = r+ case .failure(let e): response = srv.errorResponse(e)+ }+ HTTPChannelHandler.writeResponse(response, to: context)+ }+ }+ }++ private static func writeResponse(_ response: HTTPResponse, to context: ChannelHandlerContext) {+ var nioHeaders = HTTPHeaders()+ for (k, v) in response.headers {+ nioHeaders.add(name: k, value: v)+ }+ if let body = response.body {+ nioHeaders.replaceOrAdd(name: "Content-Length", value: "\(body.count)")+ }+ let status = HTTPResponseStatus(statusCode: response.statusCode.rawValue)+ let head = HTTPResponseHead(version: .http1_1, status: status, headers: nioHeaders)++ Logger.info(+ "Sending response",+ metadata: [+ "statusCode": "\(response.statusCode.rawValue)",+ "body": String(data: response.body ?? Data(), encoding: .utf8) ?? "",+ ])++ context.eventLoop.execute {+ context.write(NIOAny(HTTPServerResponsePart.head(head)), promise: nil)+ if let body = response.body {+ var buf = context.channel.allocator.buffer(capacity: body.count)+ buf.writeBytes(body)+ context.write(NIOAny(HTTPServerResponsePart.body(.byteBuffer(buf))), promise: nil)+ }+ context.writeAndFlush(NIOAny(HTTPServerResponsePart.end(nil)), promise: nil)+ }+ }++ func errorCaught(context: ChannelHandlerContext, error: Error) {+ Logger.error("Channel error", metadata: ["error": error.localizedDescription])+ context.close(promise: nil)+ }+}+// MARK: - Server Class-@MainActor-final class Server {++final class Server: @unchecked Sendable {// MARK: - Route Type+private struct Route {let method: Stringlet path: String@@ -27,64 +135,46 @@ final class Server {func matches(_ request: HTTPRequest) -> Bool {if method != request.method { return false }- // Handle path parameterslet routeParts = path.split(separator: "/")let requestParts = request.path.split(separator: "/")if routeParts.count != requestParts.count { return false }for (routePart, requestPart) in zip(routeParts, requestParts) {- if routePart.hasPrefix(":") { continue } // Path parameter+ if routePart.hasPrefix(":") { continue }if routePart != requestPart { return false }}return true}- func extractParams(_ request: HTTPRequest) -> [String: String] {- var params: [String: String] = [:]- let routeParts = path.split(separator: "/")-- // Split request path to remove query parameters- let requestPathOnly = request.path.split(separator: "?", maxSplits: 1)[0]- let requestParts = requestPathOnly.split(separator: "/")-- for (routePart, requestPart) in zip(routeParts, requestParts) {- if routePart.hasPrefix(":") {- let paramName = String(routePart.dropFirst())- params[paramName] = String(requestPart)- }- }-- return params- }}// MARK: - Properties- private let port: NWEndpoint.Port++ private let portNumber: UInt16private let controller: LumeController- private var isRunning = false- private var listener: NWListener?private var routes: [Route]+ private var serverChannel: (any Channel)?+ private var eventLoopGroup: (any EventLoopGroup)?// MARK: - Initialization+init(port: UInt16 = 7777) {- self.port = NWEndpoint.Port(rawValue: port)!+ self.portNumber = portself.controller = LumeController()self.routes = []-- // Define API routes after self is fully initializedself.setupRoutes()}// MARK: - Route Setup+private func setupRoutes() {routes = [Route(method: "GET", path: "/lume/vms",handler: { [weak self] request inguard let self else { throw HTTPError.internalError }- // Extract storage from query params if presentlet storage = self.extractQueryParam(request: request, name: "storage")return try await self.handleListVMs(storage: storage)}),@@ -92,38 +182,22 @@ final class Server {method: "GET", path: "/lume/vms/:name",handler: { [weak self] request inguard let self else { throw HTTPError.internalError }- let params = Route(- method: "GET", path: "/lume/vms/:name",- handler: { _ in- HTTPResponse(statusCode: .ok, body: "")- }- ).extractParams(request)+ let params = self.extractPathParams(pattern: "/lume/vms/:name", from: request)guard let name = params["name"] else {return HTTPResponse(statusCode: .badRequest, body: "Missing VM name")}-- // Extract storage from query params if presentlet storage = self.extractQueryParam(request: request, name: "storage")-return try await self.handleGetVM(name: name, storage: storage)}),Route(method: "DELETE", path: "/lume/vms/:name",handler: { [weak self] request inguard let self else { throw HTTPError.internalError }- let params = Route(- method: "DELETE", path: "/lume/vms/:name",- handler: { _ in- HTTPResponse(statusCode: .ok, body: "")- }- ).extractParams(request)+ let params = self.extractPathParams(pattern: "/lume/vms/:name", from: request)guard let name = params["name"] else {return HTTPResponse(statusCode: .badRequest, body: "Missing VM name")}-- // Extract storage from query params if presentlet storage = self.extractQueryParam(request: request, name: "storage")-return try await self.handleDeleteVM(name: name, storage: storage)}),Route(@@ -142,12 +216,7 @@ final class Server {method: "PATCH", path: "/lume/vms/:name",handler: { [weak self] request inguard let self else { throw HTTPError.internalError }- let params = Route(- method: "PATCH", path: "/lume/vms/:name",- handler: { _ in- HTTPResponse(statusCode: .ok, body: "")- }- ).extractParams(request)+ let params = self.extractPathParams(pattern: "/lume/vms/:name", from: request)guard let name = params["name"] else {return HTTPResponse(statusCode: .badRequest, body: "Missing VM name")}@@ -157,12 +226,7 @@ final class Server {method: "POST", path: "/lume/vms/:name/run",handler: { [weak self] request inguard let self else { throw HTTPError.internalError }- let params = Route(- method: "POST", path: "/lume/vms/:name/run",- handler: { _ in- HTTPResponse(statusCode: .ok, body: "")- }- ).extractParams(request)+ let params = self.extractPathParams(pattern: "/lume/vms/:name/run", from: request)guard let name = params["name"] else {return HTTPResponse(statusCode: .badRequest, body: "Missing VM name")}@@ -172,44 +236,33 @@ final class Server {method: "POST", path: "/lume/vms/:name/stop",handler: { [weak self] request inguard let self else { throw HTTPError.internalError }- let params = Route(- method: "POST", path: "/lume/vms/:name/stop",- handler: { _ in- HTTPResponse(statusCode: .ok, body: "")- }- ).extractParams(request)+ let params = self.extractPathParams(+ pattern: "/lume/vms/:name/stop", from: request)guard let name = params["name"] else {return HTTPResponse(statusCode: .badRequest, body: "Missing VM name")}-- Logger.info("Processing stop VM request", metadata: ["method": request.method, "path": request.path])-- // Extract storage from the request body+ Logger.info(+ "Processing stop VM request",+ metadata: ["method": request.method, "path": request.path])var storage: String? = nilif let bodyData = request.body, !bodyData.isEmpty {do {- if let json = try JSONSerialization.jsonObject(with: bodyData) as? [String: Any],- let bodyStorage = json["storage"] as? String {+ if let json = try JSONSerialization.jsonObject(with: bodyData)+ as? [String: Any],+ let bodyStorage = json["storage"] as? String+ {storage = bodyStorage- Logger.info("Extracted storage from request body", metadata: ["storage": bodyStorage])}- } catch {- Logger.error("Failed to parse request body JSON", metadata: ["error": error.localizedDescription])- }+ } catch {}}-return try await self.handleStopVM(name: name, storage: storage)}),Route(method: "POST", path: "/lume/vms/:name/setup",handler: { [weak self] request inguard let self else { throw HTTPError.internalError }- let params = Route(- method: "POST", path: "/lume/vms/:name/setup",- handler: { _ in- HTTPResponse(statusCode: .ok, body: "")- }- ).extractParams(request)+ let params = self.extractPathParams(+ pattern: "/lume/vms/:name/setup", from: request)guard let name = params["name"] else {return HTTPResponse(statusCode: .badRequest, body: "Missing VM name")}@@ -245,7 +298,6 @@ final class Server {guard let self else { throw HTTPError.internalError }return try await self.handleGetImages(request)}),- // New config endpointRoute(method: "GET", path: "/lume/config",handler: { [weak self] _ in@@ -274,41 +326,28 @@ final class Server {method: "DELETE", path: "/lume/config/locations/:name",handler: { [weak self] request inguard let self else { throw HTTPError.internalError }- let params = Route(- method: "DELETE", path: "/lume/config/locations/:name",- handler: { _ in- HTTPResponse(statusCode: .ok, body: "")- }- ).extractParams(request)+ let params = self.extractPathParams(+ pattern: "/lume/config/locations/:name", from: request)guard let name = params["name"] else {return HTTPResponse(statusCode: .badRequest, body: "Missing location name")}return try await self.handleRemoveLocation(name)}),-- // Logs retrieval routeRoute(method: "GET", path: "/lume/logs",handler: { [weak self] request inguard let self else { throw HTTPError.internalError }-- // Extract query parameters- let type = self.extractQueryParam(request: request, name: "type") // "info", "error", or "all"+ let type = self.extractQueryParam(request: request, name: "type")let linesParam = self.extractQueryParam(request: request, name: "lines")- let lines = linesParam.flatMap { Int($0) } // Convert to Int if present-+ let lines = linesParam.flatMap { Int($0) }return try await self.handleGetLogs(type: type, lines: lines)}),Route(method: "POST", path: "/lume/config/locations/default/:name",handler: { [weak self] request inguard let self else { throw HTTPError.internalError }- let params = Route(- method: "POST", path: "/lume/config/locations/default/:name",- handler: { _ in- HTTPResponse(statusCode: .ok, body: "")- }- ).extractParams(request)+ let params = self.extractPathParams(+ pattern: "/lume/config/locations/default/:name", from: request)guard let name = params["name"] else {return HTTPResponse(statusCode: .badRequest, body: "Missing location name")}@@ -320,7 +359,6 @@ final class Server {guard let self else { throw HTTPError.internalError }return try await self.handlePush(request.body)}),- // Host status endpoint for orchestrator health checksRoute(method: "GET", path: "/lume/host/status",handler: { [weak self] _ in@@ -330,302 +368,99 @@ final class Server {]}- // Helper to extract query parameters from the URL+ // MARK: - Helpers+private func extractQueryParam(request: HTTPRequest, name: String) -> String? {- // Extract only the query part by splitting on '?'let parts = request.path.split(separator: "?", maxSplits: 1)- guard parts.count > 1 else { return nil } // No query parameters-+ guard parts.count > 1 else { return nil }let queryString = String(parts[1])- // Create a placeholder URL with the query string- if let urlComponents = URLComponents(string: "http://placeholder.com?"+queryString),- let queryItems = urlComponents.queryItems+ if let urlComponents = URLComponents(string: "http://placeholder.com?" + queryString),+ let queryItems = urlComponents.queryItems{return queryItems.first(where: { $0.name == name })?.value?.removingPercentEncoding}return nil}- // MARK: - Port Utilities- private func isPortAvailable(port: Int) async -> Bool {- // Create a socket- let socketFD = socket(AF_INET, SOCK_STREAM, 0)- if socketFD == -1 {- return false- }-- // Set socket options to allow reuse- var value: Int32 = 1- if setsockopt(- socketFD, SOL_SOCKET, SO_REUSEADDR, &value, socklen_t(MemoryLayout<Int32>.size)) == -1- {- close(socketFD)- return false- }-- // Set up the address structure- var addr = sockaddr_in()- addr.sin_family = sa_family_t(AF_INET)- addr.sin_port = UInt16(port).bigEndian- addr.sin_addr.s_addr = INADDR_ANY.bigEndian-- // Bind to the port- let bindResult = withUnsafePointer(to: &addr) { addrPtr in- addrPtr.withMemoryRebound(to: sockaddr.self, capacity: 1) { addrPtr in- Darwin.bind(socketFD, addrPtr, socklen_t(MemoryLayout<sockaddr_in>.size))+ private func extractPathParams(pattern: String, from request: HTTPRequest) -> [String: String] {+ var params: [String: String] = [:]+ let routeParts = pattern.split(separator: "/")+ let requestPathOnly = request.path.split(separator: "?", maxSplits: 1)[0]+ let requestParts = requestPathOnly.split(separator: "/")+ for (routePart, requestPart) in zip(routeParts, requestParts) {+ if routePart.hasPrefix(":") {+ params[String(routePart.dropFirst())] = String(requestPart)}}-- // Clean up- close(socketFD)-- // If bind failed, the port is in use- return bindResult == 0+ return params}// MARK: - Server Lifecycle- func start() async throws {- // First check if the port is already in use- if !(await isPortAvailable(port: Int(port.rawValue))) {- // Don't log anything here, just throw the error- throw PortError.alreadyInUse(port: port.rawValue)- }-- let parameters = NWParameters.tcp- listener = try NWListener(using: parameters, on: port)-- // Create an actor to safely manage state transitions- actor StartupState {- var error: Error?- var isComplete = false-- func setError(_ error: Error) {- self.error = error- self.isComplete = true- }-- func setComplete() {- self.isComplete = true- }- func checkStatus() -> (isComplete: Bool, error: Error?) {- return (isComplete, error)- }- }-- let startupState = StartupState()-- // Set up a state update handler to detect port binding errors- listener?.stateUpdateHandler = { state in- Task {- switch state {- case .setup:- // Initial state, no action needed- Logger.info("Listener setup", metadata: ["port": "\(self.port.rawValue)"])- break- case .waiting(let error):- // Log the full error details to see what we're getting- Logger.error(- "Listener waiting",- metadata: [- "error": error.localizedDescription,- "debugDescription": error.debugDescription,- "localizedDescription": error.localizedDescription,- "port": "\(self.port.rawValue)",- ])-- // Check for different port in use error messages- if error.debugDescription.contains("Address already in use")- || error.localizedDescription.contains("in use")- || error.localizedDescription.contains("address already in use")- {- Logger.error(- "Port conflict detected", metadata: ["port": "\(self.port.rawValue)"])- await startupState.setError(- PortError.alreadyInUse(port: self.port.rawValue))- } else {- // Wait for a short period to see if the listener recovers- // Some network errors are transient- try? await Task.sleep(nanoseconds: 1_000_000_000) // 1 second-- // If we're still waiting after delay, consider it an error- if case .waiting = await self.listener?.state {- await startupState.setError(error)- }- }- case .failed(let error):- // Log the full error details- Logger.error(- "Listener failed",- metadata: [- "error": error.localizedDescription,- "debugDescription": error.debugDescription,- "port": "\(self.port.rawValue)",- ])- await startupState.setError(error)- case .ready:- // Listener successfully bound to port- Logger.info("Listener ready", metadata: ["port": "\(self.port.rawValue)"])- await startupState.setComplete()- case .cancelled:- // Listener was cancelled- Logger.info("Listener cancelled", metadata: ["port": "\(self.port.rawValue)"])- break- @unknown default:- Logger.info(- "Unknown listener state",- metadata: ["state": "\(state)", "port": "\(self.port.rawValue)"])- break+ func start() async throws {+ let group = MultiThreadedEventLoopGroup(numberOfThreads: System.coreCount)+ eventLoopGroup = group+ let srv = self++ let bootstrap = ServerBootstrap(group: group)+ .serverChannelOption(ChannelOptions.backlog, value: 256)+ .serverChannelOption(ChannelOptions.socketOption(.so_reuseaddr), value: 1)+ .childChannelInitializer { channel in+ channel.pipeline.configureHTTPServerPipeline().flatMap {+ channel.pipeline.addHandler(HTTPChannelHandler(server: srv))}}- }-- listener?.newConnectionHandler = { [weak self] connection in- Task { @MainActor [weak self] in- guard let self else { return }- self.handleConnection(connection)- }- }-- listener?.start(queue: .main)-- // Wait for either successful startup or an error- var status: (isComplete: Bool, error: Error?) = (false, nil)- repeat {- try await Task.sleep(nanoseconds: 100_000_000) // 100ms- status = await startupState.checkStatus()- } while !status.isComplete- // If there was a startup error, throw it- if let error = status.error {- self.stop()+ do {+ let channel = try await bootstrap.bind(host: "127.0.0.1", port: Int(portNumber)).get()+ serverChannel = channel+ Logger.info("Server started", metadata: ["port": "\(portNumber)"])+ try await channel.closeFuture.get()+ } catch let ioError as IOError where ioError.errnoCode == EADDRINUSE {+ try? await group.shutdownGracefully()+ throw PortError.alreadyInUse(port: portNumber)+ } catch {+ try? await group.shutdownGracefully()throw error}-- isRunning = true-- Logger.info("Server started", metadata: ["port": "\(port.rawValue)"])-- // Keep the server running- while isRunning {- try await Task.sleep(nanoseconds: 1_000_000_000)- }+ try? await group.shutdownGracefully()}func stop() {- isRunning = false- listener?.cancel()- }-- // MARK: - Connection Handling- private func handleConnection(_ connection: NWConnection) {- connection.stateUpdateHandler = { [weak self] state in- switch state {- case .ready:- Task { @MainActor [weak self] in- guard let self else { return }- self.receiveData(connection)- }- case .failed(let error):- Logger.error("Connection failed", metadata: ["error": error.localizedDescription])- connection.cancel()- case .cancelled:- // Connection is already cancelled, no need to cancel again- break- default:- break- }- }- connection.start(queue: .main)- }-- private func receiveData(_ connection: NWConnection) {- connection.receive(minimumIncompleteLength: 1, maximumLength: 65536) {- [weak self] content, _, isComplete, error in- if let error = error {- Logger.error("Receive error", metadata: ["error": error.localizedDescription])- connection.cancel()- return- }-- guard let data = content, !data.isEmpty else {- if isComplete {- connection.cancel()- }- return- }-- Task { @MainActor [weak self] in- guard let self else { return }- do {- let response = try await self.handleRequest(data)- self.send(response, on: connection)- } catch {- let errorResponse = self.errorResponse(error)- self.send(errorResponse, on: connection)- }- }+ serverChannel?.close(promise: nil)+ if let group = eventLoopGroup {+ Task { try? await group.shutdownGracefully() }}}- private func send(_ response: HTTPResponse, on connection: NWConnection) {- let data = response.serialize()- Logger.info(- "Serialized response", metadata: ["data": String(data: data, encoding: .utf8) ?? ""])- connection.send(- content: data,- completion: .contentProcessed { [weak connection] error in- if let error = error {- Logger.error(- "Failed to send response", metadata: ["error": error.localizedDescription])- } else {- Logger.info("Response sent successfully")- }- if connection?.state != .cancelled {- connection?.cancel()- }- })- }-// MARK: - Request Handling- private func handleRequest(_ data: Data) async throws -> HTTPResponse {- Logger.info(- "Received request data", metadata: ["data": String(data: data, encoding: .utf8) ?? ""])-- guard let request = HTTPRequest(data: data) else {- Logger.error("Failed to parse request")- return HTTPResponse(statusCode: .badRequest, body: "Invalid request")- }+ func handleRequest(_ request: HTTPRequest) async throws -> HTTPResponse {Logger.info("Parsed request",metadata: ["method": request.method,"path": request.path,- "headers": "\(request.headers)","body": String(data: request.body ?? Data(), encoding: .utf8) ?? "",])- // Find matching routeguard let route = routes.first(where: { $0.matches(request) }) else {return HTTPResponse(statusCode: .notFound, body: "Not found")}- // Handle the requestlet response = try await route.handler(request)Logger.info("Sending response",metadata: ["statusCode": "\(response.statusCode.rawValue)",- "headers": "\(response.headers)","body": String(data: response.body ?? Data(), encoding: .utf8) ?? "",])return response}- private func errorResponse(_ error: Error) -> HTTPResponse {+ func errorResponse(_ error: Error) -> HTTPResponse {HTTPResponse(statusCode: .internalServerError,headers: ["Content-Type": "application/json"],