catalyst-core 1.0.0 → 1.0.1-canary.2

package/dist/native/iosnativeWebView/CoreLogic/Sources/CatalystCoreLogic/Utils/FrameworkServerUtils+Requests.swift

@@ -0,0 +1,215 @@
+//
+//  FrameworkServerUtils+Requests.swift
+//  iosnativeWebView
+//
+//  HTTP request assembly (headers + Content-Length body across reads) and routing for the framework server,
+//  split out of FrameworkServerUtils.swift to keep that type within the lint limits.
+//
+
+import Foundation
+import Network
+import os
+
+private let logger = Logger(subsystem: Bundle.main.bundleIdentifier ?? "com.app", category: "FrameworkServer")
+
+extension FrameworkServerUtils {
+    /// Completion body of receiveHTTPRequest. Internal so tests can drive the
+    /// error branch directly; a real receive error is timing-dependent.
+    ///
+    /// A POST's headers and body can arrive in separate reads, so bytes are
+    /// buffered per connection until the headers end (CRLFCRLF) and Content-Length
+    /// bytes of body are present. A GET has no body and dispatches immediately.
+    func handleReceivedData(_ data: Data?, isComplete: Bool, error: NWError?, on connection: NWConnection) {
+        if let error = error {
+            discardPendingRequest(for: connection)
+            handleReceiveError(error, on: connection)
+            return
+        }
+
+        guard let data = data else {
+            discardPendingRequest(for: connection)
+            sendHTTPResponse(on: connection, statusCode: CatalystConstants.ErrorCodes.badRequest, body: "Bad Request")
+            return
+        }
+
+        let key = ObjectIdentifier(connection)
+        // Append to the connection's own buffer in place: `old + new` would copy every byte received so far on
+        // each 8 KB read.
+        requestStateLock.lock()
+        var buffer = pendingRequests.removeValue(forKey: key) ?? Data()
+        buffer.append(data)
+        requestStateLock.unlock()
+
+        let terminator = Data("\r\n\r\n".utf8)
+        guard let headerEnd = buffer.range(of: terminator) else {
+            if buffer.count > Self.maxHeaderBytes {
+                discardPendingRequest(for: connection)
+                sendHTTPResponse(on: connection, statusCode: CatalystConstants.ErrorCodes.badRequest, body: "Bad Request")
+            } else if isComplete {
+                // Client closed mid-headers: fall through to the legacy single-read behaviour.
+                discardPendingRequest(for: connection)
+                dispatchRequest(headerData: buffer, body: Data(), isComplete: isComplete, on: connection)
+            } else {
+                requestStateLock.lock(); pendingRequests[key] = buffer; requestStateLock.unlock()
+                receiveHTTPRequest(on: connection)
+            }
+            return
+        }
+
+        let headerData = buffer[buffer.startIndex..<headerEnd.lowerBound]
+        let body = buffer[headerEnd.upperBound...]
+        guard let expected = Self.contentLength(inHeaders: headerData) else {
+            discardPendingRequest(for: connection)
+            sendHTTPResponse(on: connection, statusCode: CatalystConstants.ErrorCodes.badRequest, body: "Bad Request")
+            return
+        }
+
+        if expected > Self.maxBodyBytes {
+            discardPendingRequest(for: connection)
+            sendHTTPResponse(on: connection, statusCode: 413, body: "Payload Too Large")
+            return
+        }
+        if body.count < expected {
+            if isComplete {
+                // The client closed the connection before sending the declared body: reject rather than
+                // handle a truncated request.
+                discardPendingRequest(for: connection)
+                sendHTTPResponse(on: connection, statusCode: CatalystConstants.ErrorCodes.badRequest, body: "Bad Request")
+                return
+            }
+            requestStateLock.lock(); pendingRequests[key] = buffer; requestStateLock.unlock()
+            receiveHTTPRequest(on: connection)
+            return
+        }
+
+        discardPendingRequest(for: connection)
+        dispatchRequest(headerData: Data(headerData), body: Data(body.prefix(max(expected, 0))), isComplete: isComplete, on: connection)
+    }
+
+    func discardPendingRequest(for connection: NWConnection) {
+        requestStateLock.lock()
+        pendingRequests.removeValue(forKey: ObjectIdentifier(connection))
+        requestStateLock.unlock()
+    }
+
+    /// The declared body length: 0 when there is no Content-Length header, nil when it is malformed or negative
+    /// (the request is then rejected instead of being read as an empty body).
+    static func contentLength(inHeaders headerData: Data) -> Int? {
+        guard let text = String(data: headerData, encoding: .utf8) else { return nil }
+        for line in text.components(separatedBy: "\r\n") {
+            let parts = line.split(separator: ":", maxSplits: 1)
+            if parts.count == 2, parts[0].trimmingCharacters(in: .whitespaces).lowercased() == "content-length" {
+                guard let length = Int(parts[1].trimmingCharacters(in: .whitespaces)), length >= 0 else { return nil }
+                return length
+            }
+        }
+        return 0
+    }
+
+    /// True when the peer is on this device. The listener is not bound to loopback only (that predates the AI
+    /// routes and also serves files), so the AI routes — which run the on-device model — check the peer themselves.
+    static func isLoopbackPeer(_ endpoint: NWEndpoint) -> Bool {
+        guard case let .hostPort(host, _) = endpoint else { return false }
+        switch host {
+        case .ipv4(let address):
+            return address.isLoopback
+        case .ipv6(let address):
+            return address.isLoopback || address.asIPv4?.isLoopback == true
+        case .name(let name, _):
+            return name == "localhost"
+        @unknown default:
+            return false
+        }
+    }
+
+    func dispatchRequest(headerData: Data, body: Data, isComplete: Bool, on connection: NWConnection) {
+        guard let requestString = String(data: headerData, encoding: .utf8) else {
+            sendHTTPResponse(on: connection, statusCode: CatalystConstants.ErrorCodes.badRequest, body: "Bad Request")
+            return
+        }
+
+        let keepOpen = processHTTPRequest(requestString, body: body, on: connection)
+
+        // A client half-closing after sending its request must not kill an SSE stream we are still writing.
+        if isComplete && !keepOpen {
+            connection.cancel()
+        }
+    }
+
+    /// Returns true when the connection is now owned by a long-lived AI stream and must stay open.
+    @discardableResult
+    func processHTTPRequest(_ requestString: String, body: Data = Data(), on connection: NWConnection) -> Bool {
+        let lines = requestString.components(separatedBy: "\r\n")
+        guard let requestLine = lines.first else {
+            sendHTTPResponse(on: connection, statusCode: CatalystConstants.ErrorCodes.badRequest, body: "Bad Request")
+            return false
+        }
+
+        let components = requestLine.components(separatedBy: " ")
+        guard components.count >= 2 else {
+            sendHTTPResponse(on: connection, statusCode: 405, body: "Method Not Allowed")
+            return false
+        }
+
+        let method = components[0]
+        let aiPrefix = "/framework-\(self.sessionId)/ai/"
+        let isAIRoute = components[1] == aiPrefix + "stream" || components[1] == aiPrefix + "generate"
+
+        if isAIRoute {
+            guard Self.isLoopbackPeer(connection.endpoint) else {
+                logger.warning("Rejected AI request from a non-loopback peer")
+                sendHTTPResponse(on: connection, statusCode: 403, body: "Forbidden")
+                return false
+            }
+            switch method {
+            case "OPTIONS":
+                sendAIPreflight(on: connection)
+                return false
+            case "POST":
+                if components[1] == aiPrefix + "stream" {
+                    startAIStream(NativeAIRequest(body: body), on: connection)
+                    return true
+                }
+                runAIGenerate(NativeAIRequest(body: body), on: connection)
+                return true
+            default:
+                sendHTTPResponse(on: connection, statusCode: 405, body: "Method Not Allowed")
+                return false
+            }
+        }
+
+        guard method == "GET" else {
+            sendHTTPResponse(on: connection, statusCode: 405, body: "Method Not Allowed")
+            return false
+        }
+
+        let path = components[1]
+
+        // Handle status endpoint
+        if path == "/framework-\(self.sessionId)/status" {
+            fileQueue.sync {
+                let statusResponse = """
+                {
+                    "status": "running",
+                    "sessionId": "\(self.sessionId)",
+                    "port": \(self.serverPort),
+                    "servedFiles": \(self.servedFiles.count)
+                }
+                """
+                sendHTTPResponse(on: connection, statusCode: 200, body: statusResponse, contentType: "application/json")
+            }
+            return false
+        }
+
+        // Handle file requests
+        if path.hasPrefix("/framework-\(self.sessionId)/file-") {
+            let fileId = String(path.dropFirst("/framework-\(self.sessionId)/file-".count))
+            serveFile(fileId: fileId, on: connection)
+            return false
+        }
+
+        // Invalid route
+        sendHTTPResponse(on: connection, statusCode: CatalystConstants.ErrorCodes.fileNotFound, body: "Not Found")
+        return false
+    }
+}

package/dist/native/iosnativeWebView/CoreLogic/Sources/CatalystCoreLogic/Utils/FrameworkServerUtils.swift

@@ -102,10 +102,10 @@ public class FrameworkServerUtils {
 
     // Server state
     private var listener: NWListener?
-    private var serverPort: UInt16 = 0
-    private var sessionId: String = ""
-    private var isServerRunning: Bool = false
-    private var isHTTPS: Bool = false
+    var serverPort: UInt16 = 0
+    var sessionId: String = ""
+    var isServerRunning: Bool = false
+    var isHTTPS: Bool = false
 
     // Connection management
     private var activeConnections: Set<ConnectionWrapper> = []
@@ -114,11 +114,11 @@ public class FrameworkServerUtils {
     private let connectionTimeoutSeconds: TimeInterval = CatalystConstants.NetworkServer.connectionTimeout
 
     // CORS configuration - store the base URL from WebView
-    private var allowedOrigin: String = "*"
+    var allowedOrigin: String = "*"
 
     // File management
-    private var servedFiles: [String: ServedFile] = [:]
-    private let fileQueue = DispatchQueue(label: "framework.server.files", attributes: .concurrent)
+    var servedFiles: [String: ServedFile] = [:]
+    let fileQueue = DispatchQueue(label: "framework.server.files", attributes: .concurrent)
 
     // Cache directory
     private var cacheDirectory: URL?
@@ -126,6 +126,21 @@ public class FrameworkServerUtils {
     // Cleanup timer
     private var cleanupTimer: Timer?
 
+    // Native AI — supplier is set by the AI engine (catalyst-ai) before POST /ai/stream is called.
+    // Kotlin equivalent: nativeAiSupplier / nativeSystemPrompt in FrameworkServerUtils.kt.
+    var nativeAiSupplier: NativeAISupplier?
+    var nativeSystemPrompt: String = ""
+    let aiLock = NSLock()
+
+    // Requests whose headers/body arrive across several reads, keyed by connection.
+    var pendingRequests: [ObjectIdentifier: Data] = [:]
+    // In-flight AI stream tasks, cancelled when the client goes away.
+    var aiStreamTasks: [ObjectIdentifier: Task<Void, Never>] = [:]
+    let requestStateLock = NSLock()
+
+    static let maxHeaderBytes = 16 * 1024
+    static let maxBodyBytes = 1024 * 1024
+
     private init() {}
 
     // MARK: - Public API
@@ -332,20 +347,35 @@ public class FrameworkServerUtils {
         return isServerRunning
     }
 
+    /**
+     * Number of client connections currently tracked by the server.
+     * Internal so tests can wait on connection lifecycle events instead of sleeping.
+     */
+    func activeConnectionCount() -> Int {
+        return connectionQueue.sync { activeConnections.count }
+    }
+
     /**
      * Get server port
      */
-    func getServerPort() -> UInt16 {
+    public func getServerPort() -> UInt16 {
         return serverPort
     }
 
     /**
      * Get current session ID
      */
-    func getSessionId() -> String {
+    public func getSessionId() -> String {
         return sessionId
     }
 
+    /// Stream and generate connections outlive the default per-connection timeout (slow on-device decoding).
+    func cancelConnectionTimeout(for connection: NWConnection) {
+        connectionQueue.sync {
+            activeConnections.first { $0.connection === connection }?.cancelTimeout()
+        }
+    }
+
     // MARK: - Private Implementation
 
     /**
@@ -529,28 +559,35 @@ public class FrameworkServerUtils {
         let port = NWEndpoint.Port(integerLiteral: serverPort)
         // parameters.requiredLocalEndpoint = .hostPort(host: host, port: port)
 
-        listener = try NWListener(using: parameters, on: port)
+        let newListener = try NWListener(using: parameters, on: port)
+        listener = newListener
 
-        listener?.newConnectionHandler = { [weak self] connection in
+        newListener.newConnectionHandler = { [weak self] connection in
             self?.handleNewConnection(connection)
         }
 
-        listener?.stateUpdateHandler = { [weak self] state in
+        newListener.stateUpdateHandler = { [weak self, weak newListener] state in
+            // NWListener delivers state changes asynchronously, so a cancelled
+            // or failed listener can report after stopServer() -> startServer()
+            // has already installed a replacement. Only the current listener
+            // may flip isServerRunning; a stale callback would otherwise mark a
+            // healthy new server as stopped.
+            let isCurrent = { self?.listener === newListener }
             switch state {
             case .ready:
                 logger.debug("NW server ready on port \(self?.serverPort ?? 0)")
             case .failed(let error):
                 logger.error("NW server failed: \(error.localizedDescription)")
-                self?.isServerRunning = false
+                if isCurrent() { self?.isServerRunning = false }
             case .cancelled:
                 logger.debug("NW server cancelled")
-                self?.isServerRunning = false
+                if isCurrent() { self?.isServerRunning = false }
             default:
                 break
             }
         }
 
-        listener?.start(queue: .global(qos: .utility))
+        newListener.start(queue: .global(qos: .utility))
     }
 
     private func handleNewConnection(_ connection: NWConnection) {
@@ -566,102 +603,73 @@ public class FrameworkServerUtils {
             let wrapper = ConnectionWrapper(connection: connection, timeout: self.connectionTimeoutSeconds)
             self.activeConnections.insert(wrapper)
 
-            connection.stateUpdateHandler = { [weak self, weak wrapper] state in
-                switch state {
-                case .ready:
-                    self?.receiveHTTPRequest(on: connection)
-                case .failed(let error):
-                    logger.debug("Connection failed: \(error.localizedDescription)")
-                    if let wrapper = wrapper {
-                        self?.removeConnection(wrapper)
-                    }
-                    connection.cancel()
-                case .cancelled:
-                    logger.debug("Connection cancelled")
-                    if let wrapper = wrapper {
-                        self?.removeConnection(wrapper)
-                    }
-                default:
-                    break
-                }
+            connection.stateUpdateHandler = { [weak self] state in
+                self?.handleConnectionStateChange(state, on: connection)
             }
 
             connection.start(queue: .global(qos: .utility))
         }
     }
 
-    private func removeConnection(_ wrapper: ConnectionWrapper) {
-        connectionQueue.sync {
-            self.activeConnections.remove(wrapper)
-            wrapper.cancelTimeout()
+    /// Reacts to a client connection's state change. Internal (not private) so
+    /// tests can drive the failed/cancelled paths directly: which one Network.framework
+    /// reports for a dropped client is timing-dependent, so real sockets cannot
+    /// exercise them reliably.
+    func handleConnectionStateChange(_ state: NWConnection.State, on connection: NWConnection) {
+        switch state {
+        case .ready:
+            receiveHTTPRequest(on: connection)
+        case .failed(let error):
+            logger.debug("Connection failed: \(error.localizedDescription)")
+            cancelAIStream(for: connection)
+            discardPendingRequest(for: connection)
+            removeTrackedConnection(for: connection)
+            connection.cancel()
+        case .cancelled:
+            logger.debug("Connection cancelled")
+            cancelAIStream(for: connection)
+            discardPendingRequest(for: connection)
+            removeTrackedConnection(for: connection)
+        default:
+            break
         }
     }
 
-    private func receiveHTTPRequest(on connection: NWConnection) {
-        connection.receive(minimumIncompleteLength: 1, maximumLength: 8192) { [weak self] data, _, isComplete, error in
-
-            if let error = error {
-                logger.error("Error receiving request: \(error.localizedDescription)")
-                connection.cancel()
-                return
-            }
-
-            guard let data = data, let requestString = String(data: data, encoding: .utf8) else {
-                self?.sendHTTPResponse(on: connection, statusCode: CatalystConstants.ErrorCodes.badRequest, body: "Bad Request")
-                return
-            }
-
-            self?.processHTTPRequest(requestString, on: connection)
-
-            if isComplete {
-                connection.cancel()
-            }
-        }
+    /// Internal for the same reason as handleConnectionStateChange.
+    func handleReceiveError(_ error: NWError, on connection: NWConnection) {
+        logger.error("Error receiving request: \(error.localizedDescription)")
+        connection.cancel()
     }
 
-    private func processHTTPRequest(_ requestString: String, on connection: NWConnection) {
-        let lines = requestString.components(separatedBy: "\r\n")
-        guard let requestLine = lines.first else {
-            sendHTTPResponse(on: connection, statusCode: CatalystConstants.ErrorCodes.badRequest, body: "Bad Request")
-            return
+    /// Internal for the same reason as handleConnectionStateChange.
+    func handleSendCompletion(_ error: NWError?, on connection: NWConnection) {
+        if let error = error {
+            logger.debug("Error sending response: \(error.localizedDescription)")
         }
+        connection.cancel()
+    }
 
-        let components = requestLine.components(separatedBy: " ")
-        guard components.count >= 2, components[0] == "GET" else {
-            sendHTTPResponse(on: connection, statusCode: 405, body: "Method Not Allowed")
-            return
+    private func removeTrackedConnection(for connection: NWConnection) {
+        let wrapper = connectionQueue.sync { activeConnections.first { $0.connection === connection } }
+        if let wrapper = wrapper {
+            removeConnection(wrapper)
         }
+    }
 
-        let path = components[1]
-
-        // Handle status endpoint
-        if path == "/framework-\(self.sessionId)/status" {
-            fileQueue.sync {
-                let statusResponse = """
-                {
-                    "status": "running",
-                    "sessionId": "\(self.sessionId)",
-                    "port": \(self.serverPort),
-                    "servedFiles": \(self.servedFiles.count)
-                }
-                """
-                sendHTTPResponse(on: connection, statusCode: 200, body: statusResponse, contentType: "application/json")
-            }
-            return
+    private func removeConnection(_ wrapper: ConnectionWrapper) {
+        connectionQueue.sync {
+            self.activeConnections.remove(wrapper)
+            wrapper.cancelTimeout()
         }
+    }
 
-        // Handle file requests
-        if path.hasPrefix("/framework-\(self.sessionId)/file-") {
-            let fileId = String(path.dropFirst("/framework-\(self.sessionId)/file-".count))
-            serveFile(fileId: fileId, on: connection)
-            return
+    func receiveHTTPRequest(on connection: NWConnection) {
+        connection.receive(minimumIncompleteLength: 1, maximumLength: 8192) { [weak self] data, _, isComplete, error in
+            self?.handleReceivedData(data, isComplete: isComplete, error: error, on: connection)
         }
-
-        // Invalid route
-        sendHTTPResponse(on: connection, statusCode: CatalystConstants.ErrorCodes.fileNotFound, body: "Not Found")
     }
 
-    private func serveFile(fileId: String, on connection: NWConnection) {
+    func serveFile(fileId: String, on connection: NWConnection) {
         fileQueue.sync {
             guard let servedFile = self.servedFiles[fileId] else {
                 logger.warning("File not found for fileId: \(fileId)")
@@ -706,7 +714,7 @@ public class FrameworkServerUtils {
 
         // Add CORS headers
         response += "Access-Control-Allow-Origin: \(allowedOrigin)\r\n"
-        response += "Access-Control-Allow-Methods: GET, OPTIONS\r\n"
+        response += "Access-Control-Allow-Methods: GET, POST, OPTIONS\r\n"
         response += "Access-Control-Allow-Headers: *\r\n"
 
         // Add headers
@@ -771,18 +779,18 @@ public class FrameworkServerUtils {
         })
     }
 
-    private func sendHTTPResponse(on connection: NWConnection, statusCode: Int, body: String, contentType: String = "text/plain") {
+    func sendHTTPResponse(on connection: NWConnection, statusCode: Int, body: String, contentType: String = "text/plain") {
         let bodyData = body.data(using: .utf8) ?? Data()
         sendHTTPResponse(on: connection, statusCode: statusCode, body: bodyData, headers: ["Content-Type": contentType])
     }
 
-    private func sendHTTPResponse(on connection: NWConnection, statusCode: Int, body: Data, headers: [String: String] = [:]) {
+    func sendHTTPResponse(on connection: NWConnection, statusCode: Int, body: Data, headers: [String: String] = [:]) {
         let statusText = HTTPURLResponse.localizedString(forStatusCode: statusCode)
         var response = "HTTP/1.1 \(statusCode) \(statusText)\r\n"
 
         // Add CORS headers
         response += "Access-Control-Allow-Origin: \(allowedOrigin)\r\n"
-        response += "Access-Control-Allow-Methods: GET, OPTIONS\r\n"
+        response += "Access-Control-Allow-Methods: GET, POST, OPTIONS\r\n"
         response += "Access-Control-Allow-Headers: *\r\n"
 
         // Add default headers
@@ -803,11 +811,8 @@ public class FrameworkServerUtils {
         }
         let responseData = responseHeaderData + body
 
-        connection.send(content: responseData, completion: .contentProcessed { error in
-            if let error = error {
-                logger.debug("Error sending response: \(error.localizedDescription)")
-            }
-            connection.cancel()
+        connection.send(content: responseData, completion: .contentProcessed { [weak self] error in
+            self?.handleSendCompletion(error, on: connection)
         })
     }
 

package/dist/native/iosnativeWebView/CoreLogic/Sources/CatalystCoreLogic/Utils/NativeAI.swift

@@ -0,0 +1,76 @@
+//
+//  NativeAI.swift
+//  iosnativeWebView
+//
+//  Types shared between the framework server's native-AI routes and the AI
+//  engine that catalyst-ai plugs in. Mirrors the Kotlin contract in
+//  FrameworkServerUtils.kt: an engine hands the server a "supplier" that
+//  turns (prompt, genConfig, conversationId) into (conversationId, token stream).
+//  catalyst-core has no knowledge of any inference library.
+//
+
+import Foundation
+
+/// Result of one native-AI request: the active conversation id plus the token stream.
+/// Kotlin equivalent: Pair<String, Flow<String>>.
+public typealias NativeAIStream = (conversationId: String, tokens: AsyncThrowingStream<String, Error>)
+
+/// Kotlin equivalent: suspend (String, JSONObject, String?) -> Pair<String, Flow<String>>.
+public typealias NativeAISupplier = (
+    _ prompt: String,
+    _ genConfig: [String: Any],
+    _ conversationId: String?
+) async throws -> NativeAIStream
+
+/// Error codes come from packages/catalyst-core/src/errors/registry.js (AI-xxx) so the
+/// JS side surfaces the same code on iOS and Android.
+public enum NativeAIErrorCode {
+    public static let invalidRequestBody = "AI-003"
+    public static let streamNotReady = "AI-005"
+    public static let requestFailed = "AI-006"
+}
+
+/// An error an engine/server can raise with the registry code that should reach JS.
+public struct NativeAIError: LocalizedError {
+    public let message: String
+    public let code: String
+
+    public init(message: String, code: String = NativeAIErrorCode.requestFailed) {
+        self.message = message
+        self.code = code
+    }
+
+    public var errorDescription: String? { message }
+}
+
+/// Server-Sent Events framing. Frame shapes match Android's /ai/stream exactly:
+/// {"conversationId"}, {"token"}, {"done":true}, {"error"} (+ "code" on iOS).
+enum NativeAISSE {
+    static func frame(_ payload: [String: Any]) -> Data {
+        // Payloads are built from Strings/Bools only, so serialization cannot fail;
+        // the fallback keeps the stream well-formed regardless.
+        let json = (try? JSONSerialization.data(withJSONObject: payload, options: [.withoutEscapingSlashes]))
+            ?? Data("{\"error\":\"serialization failed\"}".utf8)
+        return Data("data: ".utf8) + json + Data("\n\n".utf8)
+    }
+
+    static func conversationId(_ id: String) -> Data { frame(["conversationId": id]) }
+    static func token(_ text: String) -> Data { frame(["token": text]) }
+    static func done() -> Data { frame(["done": true]) }
+    static func error(_ message: String, code: String) -> Data { frame(["error": message, "code": code]) }
+}
+
+/// Parsed body of POST /ai/stream and /ai/generate: { prompt, genConfig, conversationId }.
+struct NativeAIRequest {
+    let prompt: String
+    let genConfig: [String: Any]
+    let conversationId: String?
+
+    init(body: Data) {
+        let object = (try? JSONSerialization.jsonObject(with: body)) as? [String: Any] ?? [:]
+        prompt = object["prompt"] as? String ?? ""
+        genConfig = object["genConfig"] as? [String: Any] ?? [:]
+        let id = (object["conversationId"] as? String) ?? ""
+        conversationId = id.isEmpty ? nil : id
+    }
+}