Vendor OpenClaw source as Adolf fork baseline

Adolf is a fork/vendored clone of github.com/openclaw/openclaw (v2026.6.11),
free to diverge. Tree copied sans upstream .git; upstream remote added for
future syncs. Node pinned to 24 (.nvmrc); engines already require >=22.19.
Preserves docs/ARCHITECTURE.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LeqyaxJF2nbRXJtae2kNB2

apps/ios/Sources/Chat/AppleReviewDemoChatTransport.swift

@@ -0,0 +1,432 @@
+import Foundation
+import OpenClawChatUI
+import OpenClawProtocol
+
+enum AppleReviewDemoMode {
+    static let setupCode = "APPLE-REVIEW-DEMO"
+    static let gatewayName = "Apple Review Demo Gateway"
+    static let gatewayAddress = "Local demo mode"
+    static let gatewayID = "apple-review-demo"
+
+    static func isSetupCode(_ value: String) -> Bool {
+        value.trimmingCharacters(in: .whitespacesAndNewlines)
+            .localizedCaseInsensitiveCompare(self.setupCode) == .orderedSame
+    }
+
+    static var agents: [AgentSummary] {
+        LocalChatFixture.appleReviewDemo.agents
+    }
+}
+
+enum ScreenshotFixtureMode {
+    static let gatewayName = "OpenClaw Gateway"
+    static let gatewayAddress = "Mac Studio on local network"
+    static let gatewayID = "screenshot-fixture-gateway"
+
+    static var agents: [AgentSummary] {
+        LocalChatFixture.appScreenshots.agents
+    }
+}
+
+struct LocalChatFixture {
+    let sessionKey: String
+    let sessionIDPrefix: String
+    let displayName: String
+    let subject: String
+    let workspace: String
+    let modelProvider: String
+    let modelID: String
+    let modelName: String
+    let responsePrefix: String
+    let seedMessages: [String]
+    let agents: [AgentSummary]
+
+    static let appleReviewDemo = LocalChatFixture(
+        sessionKey: "main",
+        sessionIDPrefix: "apple-review-demo",
+        displayName: "Apple Review Demo",
+        subject: "Gateway review flow",
+        workspace: "Apple Review Demo",
+        modelProvider: "demo",
+        modelID: "local-demo",
+        modelName: "Apple Review Demo",
+        responsePrefix: "Demo mode is active.",
+        seedMessages: [
+            """
+            Apple Review demo mode is active. This local chat transport lets reviewers inspect the iOS app \
+            without a private Gateway.
+            """,
+        ],
+        agents: [
+            AgentSummary(
+                id: "main",
+                name: "Main",
+                identity: ["emoji": AnyCodable("OC")],
+                workspace: "Apple Review Demo",
+                model: ["provider": AnyCodable("demo"), "model": AnyCodable("local-demo")],
+                agentruntime: ["kind": AnyCodable("local")],
+                thinkinglevels: nil,
+                thinkingoptions: ["auto", "low", "medium"],
+                thinkingdefault: "auto"),
+        ])
+
+    static let appScreenshots = LocalChatFixture(
+        sessionKey: "main",
+        sessionIDPrefix: "screenshot-fixture",
+        displayName: "Molty",
+        subject: "Mobile command center",
+        workspace: "OpenClaw",
+        modelProvider: "openai",
+        modelID: "gpt-5.5",
+        modelName: "GPT-5.5",
+        responsePrefix: "OpenClaw is connected to your gateway.",
+        seedMessages: ProcessInfo.processInfo.arguments.contains("--openclaw-empty-chat-fixture")
+            ? []
+            : ["Ready when you are. I can check a project, coordinate an agent, or prepare the next step."],
+        agents: [
+            AgentSummary(
+                id: "main",
+                name: "Molty",
+                identity: ["emoji": AnyCodable("M")],
+                workspace: "OpenClaw",
+                model: ["provider": AnyCodable("openai"), "model": AnyCodable("gpt-5.5")],
+                agentruntime: ["kind": AnyCodable("gateway")],
+                thinkinglevels: nil,
+                thinkingoptions: ["auto", "low", "medium", "high"],
+                thinkingdefault: "auto"),
+            AgentSummary(
+                id: "research",
+                name: "Research",
+                identity: ["emoji": AnyCodable("RS")],
+                workspace: "OpenClaw",
+                model: ["provider": AnyCodable("openai"), "model": AnyCodable("gpt-5.5")],
+                agentruntime: ["kind": AnyCodable("gateway")],
+                thinkinglevels: nil,
+                thinkingoptions: ["auto", "low", "medium", "high"],
+                thinkingdefault: "medium"),
+            AgentSummary(
+                id: "automation",
+                name: "Automation",
+                identity: ["emoji": AnyCodable("AU")],
+                workspace: "OpenClaw",
+                model: ["provider": AnyCodable("openai"), "model": AnyCodable("gpt-5.5")],
+                agentruntime: ["kind": AnyCodable("gateway")],
+                thinkinglevels: nil,
+                thinkingoptions: ["auto", "low", "medium", "high"],
+                thinkingdefault: "auto"),
+        ])
+}
+
+struct LocalFixtureChatTransport: OpenClawChatTransport {
+    private let fixture: LocalChatFixture
+    private let store: LocalFixtureChatStore
+
+    init(fixture: LocalChatFixture) {
+        self.fixture = fixture
+        self.store = LocalFixtureChatStore(fixture: fixture)
+    }
+
+    func createSession(
+        key: String,
+        label _: String?,
+        parentSessionKey _: String?) async throws -> OpenClawChatCreateSessionResponse
+    {
+        try await self.store.createSession(key: key)
+    }
+
+    func requestHistory(sessionKey: String) async throws -> OpenClawChatHistoryPayload {
+        try await self.store.history(sessionKey: sessionKey)
+    }
+
+    func listModels() async throws -> [OpenClawChatModelChoice] {
+        [
+            OpenClawChatModelChoice(
+                modelID: self.fixture.modelID,
+                name: self.fixture.modelName,
+                provider: self.fixture.modelProvider,
+                contextWindow: 128_000),
+        ]
+    }
+
+    func sendMessage(
+        sessionKey: String,
+        message: String,
+        thinking _: String,
+        idempotencyKey: String,
+        attachments _: [OpenClawChatAttachmentPayload]) async throws -> OpenClawChatSendResponse
+    {
+        try await self.store.sendMessage(
+            sessionKey: sessionKey,
+            message: message,
+            runId: idempotencyKey)
+    }
+
+    func abortRun(sessionKey _: String, runId _: String) async throws {}
+
+    func listSessions(limit _: Int?) async throws -> OpenClawChatSessionsListResponse {
+        try await self.store.sessions()
+    }
+
+    func setSessionModel(sessionKey _: String, model _: String?) async throws {}
+
+    func setSessionThinking(sessionKey _: String, thinkingLevel _: String) async throws {}
+
+    func requestHealth(timeoutMs _: Int) async throws -> Bool {
+        true
+    }
+
+    func waitForRunCompletion(runId _: String, timeoutMs _: Int) async -> Bool {
+        true
+    }
+
+    func events() -> AsyncStream<OpenClawChatTransportEvent> {
+        AsyncStream { continuation in
+            continuation.yield(.health(ok: true))
+            continuation.finish()
+        }
+    }
+
+    func setActiveSessionKey(_: String) async throws {}
+
+    func resetSession(sessionKey _: String) async throws {
+        await self.store.reset()
+    }
+
+    func compactSession(sessionKey _: String) async throws {}
+}
+
+struct AppleReviewDemoChatTransport: OpenClawChatTransport {
+    private let transport = LocalFixtureChatTransport(fixture: .appleReviewDemo)
+
+    func createSession(
+        key: String,
+        label: String?,
+        parentSessionKey: String?) async throws -> OpenClawChatCreateSessionResponse
+    {
+        try await self.transport.createSession(key: key, label: label, parentSessionKey: parentSessionKey)
+    }
+
+    func requestHistory(sessionKey: String) async throws -> OpenClawChatHistoryPayload {
+        try await self.transport.requestHistory(sessionKey: sessionKey)
+    }
+
+    func listModels() async throws -> [OpenClawChatModelChoice] {
+        try await self.transport.listModels()
+    }
+
+    func sendMessage(
+        sessionKey: String,
+        message: String,
+        thinking: String,
+        idempotencyKey: String,
+        attachments: [OpenClawChatAttachmentPayload]) async throws -> OpenClawChatSendResponse
+    {
+        try await self.transport.sendMessage(
+            sessionKey: sessionKey,
+            message: message,
+            thinking: thinking,
+            idempotencyKey: idempotencyKey,
+            attachments: attachments)
+    }
+
+    func abortRun(sessionKey: String, runId: String) async throws {
+        try await self.transport.abortRun(sessionKey: sessionKey, runId: runId)
+    }
+
+    func listSessions(limit: Int?) async throws -> OpenClawChatSessionsListResponse {
+        try await self.transport.listSessions(limit: limit)
+    }
+
+    func setSessionModel(sessionKey: String, model: String?) async throws {
+        try await self.transport.setSessionModel(sessionKey: sessionKey, model: model)
+    }
+
+    func setSessionThinking(sessionKey: String, thinkingLevel: String) async throws {
+        try await self.transport.setSessionThinking(sessionKey: sessionKey, thinkingLevel: thinkingLevel)
+    }
+
+    func requestHealth(timeoutMs: Int) async throws -> Bool {
+        try await self.transport.requestHealth(timeoutMs: timeoutMs)
+    }
+
+    func waitForRunCompletion(runId: String, timeoutMs: Int) async -> Bool {
+        await self.transport.waitForRunCompletion(runId: runId, timeoutMs: timeoutMs)
+    }
+
+    func events() -> AsyncStream<OpenClawChatTransportEvent> {
+        self.transport.events()
+    }
+
+    func setActiveSessionKey(_ sessionKey: String) async throws {
+        try await self.transport.setActiveSessionKey(sessionKey)
+    }
+
+    func resetSession(sessionKey: String) async throws {
+        try await self.transport.resetSession(sessionKey: sessionKey)
+    }
+
+    func compactSession(sessionKey: String) async throws {
+        try await self.transport.compactSession(sessionKey: sessionKey)
+    }
+}
+
+private actor LocalFixtureChatStore {
+    private let fixture: LocalChatFixture
+    private var messages: [OpenClawChatMessage]
+
+    init(fixture: LocalChatFixture) {
+        self.fixture = fixture
+        self.messages = Self.seedMessages(fixture: fixture)
+    }
+
+    func createSession(key: String) throws -> OpenClawChatCreateSessionResponse {
+        try Self.decode(
+            CreateSessionPayload(ok: true, key: key, sessionId: "\(self.fixture.sessionIDPrefix)-\(key)"),
+            as: OpenClawChatCreateSessionResponse.self)
+    }
+
+    func history(sessionKey: String) throws -> OpenClawChatHistoryPayload {
+        let normalizedSessionKey = Self.normalizedSessionKey(sessionKey, fallback: self.fixture.sessionKey)
+        return try Self.decode(
+            HistoryPayload(
+                sessionKey: normalizedSessionKey,
+                sessionId: "\(self.fixture.sessionIDPrefix)-\(normalizedSessionKey)",
+                messages: self.messages,
+                thinkingLevel: "auto"),
+            as: OpenClawChatHistoryPayload.self)
+    }
+
+    func sendMessage(sessionKey _: String, message: String, runId: String) throws -> OpenClawChatSendResponse {
+        let now = Date().timeIntervalSince1970 * 1000
+        self.messages.append(
+            Self.message(
+                role: "user",
+                text: message,
+                timestamp: now,
+                idempotencyKey: "\(runId):user"))
+        let trimmed = message.trimmingCharacters(in: .whitespacesAndNewlines)
+        let subject = trimmed.isEmpty ? "that request" : "\"\(trimmed)\""
+        self.messages.append(
+            Self.message(
+                role: "assistant",
+                text: """
+                \(self.fixture.responsePrefix) I can help with \(subject), summarize current project context, \
+                prepare agent actions, and keep the mobile workflow connected to the gateway.
+                """,
+                timestamp: now + 1))
+        return try Self.decode(
+            SendPayload(runId: runId, status: "ok"),
+            as: OpenClawChatSendResponse.self)
+    }
+
+    func sessions() throws -> OpenClawChatSessionsListResponse {
+        let entry = OpenClawChatSessionEntry(
+            key: self.fixture.sessionKey,
+            kind: "chat",
+            displayName: self.fixture.displayName,
+            surface: "ios",
+            subject: self.fixture.subject,
+            room: nil,
+            space: nil,
+            updatedAt: Date().timeIntervalSince1970 * 1000,
+            sessionId: "\(self.fixture.sessionIDPrefix)-\(self.fixture.sessionKey)",
+            systemSent: true,
+            abortedLastRun: false,
+            thinkingLevel: "auto",
+            verboseLevel: nil,
+            inputTokens: nil,
+            outputTokens: nil,
+            totalTokens: nil,
+            modelProvider: self.fixture.modelProvider,
+            model: self.fixture.modelID,
+            contextTokens: 128_000,
+            thinkingLevels: Self.thinkingLevels,
+            thinkingOptions: Self.thinkingOptions,
+            thinkingDefault: "auto")
+        return OpenClawChatSessionsListResponse(
+            ts: Date().timeIntervalSince1970 * 1000,
+            path: nil,
+            count: 1,
+            defaults: OpenClawChatSessionsDefaults(
+                modelProvider: self.fixture.modelProvider,
+                model: self.fixture.modelID,
+                contextTokens: 128_000,
+                thinkingLevels: Self.thinkingLevels,
+                thinkingOptions: Self.thinkingOptions,
+                thinkingDefault: "auto",
+                mainSessionKey: self.fixture.sessionKey),
+            sessions: [entry])
+    }
+
+    func reset() {
+        self.messages = Self.seedMessages(fixture: self.fixture)
+    }
+
+    private static var thinkingOptions: [String] {
+        ["auto", "low", "medium", "high"]
+    }
+
+    private static var thinkingLevels: [OpenClawChatThinkingLevelOption] {
+        [
+            OpenClawChatThinkingLevelOption(id: "auto", label: "Auto"),
+            OpenClawChatThinkingLevelOption(id: "low", label: "Low"),
+            OpenClawChatThinkingLevelOption(id: "medium", label: "Medium"),
+            OpenClawChatThinkingLevelOption(id: "high", label: "High"),
+        ]
+    }
+
+    private static func seedMessages(fixture: LocalChatFixture) -> [OpenClawChatMessage] {
+        let now = Date().timeIntervalSince1970 * 1000
+        return fixture.seedMessages.enumerated().map { index, text in
+            self.message(role: "assistant", text: text, timestamp: now + Double(index))
+        }
+    }
+
+    private static func message(
+        role: String,
+        text: String,
+        timestamp: Double,
+        idempotencyKey: String? = nil) -> OpenClawChatMessage
+    {
+        OpenClawChatMessage(
+            role: role,
+            content: [
+                OpenClawChatMessageContent(
+                    type: "text",
+                    text: text,
+                    mimeType: nil,
+                    fileName: nil,
+                    content: nil),
+            ],
+            timestamp: timestamp,
+            idempotencyKey: idempotencyKey)
+    }
+
+    private static func normalizedSessionKey(_ value: String, fallback: String) -> String {
+        let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return trimmed.isEmpty ? fallback : trimmed
+    }
+
+    private static func decode<T: Decodable>(_ value: some Encodable, as type: T.Type) throws -> T {
+        let data = try JSONEncoder().encode(value)
+        return try JSONDecoder().decode(type, from: data)
+    }
+
+    private struct HistoryPayload: Encodable {
+        var sessionKey: String
+        var sessionId: String?
+        var messages: [OpenClawChatMessage]?
+        var thinkingLevel: String?
+    }
+
+    private struct SendPayload: Encodable {
+        var runId: String
+        var status: String
+    }
+
+    private struct CreateSessionPayload: Encodable {
+        var ok: Bool?
+        var key: String
+        var sessionId: String?
+    }
+}

apps/ios/Sources/Chat/IOSGatewayChatTransport.swift

@@ -0,0 +1,389 @@
+import Foundation
+import OpenClawChatUI
+import OpenClawKit
+import OpenClawProtocol
+import OSLog
+
+struct IOSGatewayChatTransport: OpenClawChatTransport {
+    static let logger = Logger(subsystem: "ai.openclawfoundation.app", category: "ios.chat.transport")
+    static let defaultChatSendTimeoutMs = 30000
+    static let compactionRequestTimeoutSeconds = 0
+    private let gateway: GatewayNodeSession
+
+    private struct CreateSessionParams: Codable {
+        var key: String
+        var label: String?
+        var parentSessionKey: String?
+    }
+
+    private struct RunParams: Codable {
+        var sessionKey: String
+        var runId: String
+    }
+
+    private struct ListSessionsParams: Codable {
+        var includeGlobal: Bool
+        var includeUnknown: Bool
+        var limit: Int?
+    }
+
+    private struct SessionKeyParams: Codable {
+        var key: String
+    }
+
+    private struct ChatSendParams: Codable {
+        var sessionKey: String
+        var message: String
+        var thinking: String
+        var attachments: [OpenClawChatAttachmentPayload]?
+        var timeoutMs: Int
+        var idempotencyKey: String
+    }
+
+    private struct CommandsListRequestParams: Codable {
+        var scope: String
+        var includeArgs: Bool
+        var agentId: String?
+    }
+
+    private struct AgentWaitParams: Codable {
+        var runId: String
+        var timeoutMs: Int
+    }
+
+    private struct AgentWaitResponse: Codable {
+        var runId: String?
+        var status: String?
+        var error: String?
+    }
+
+    struct AgentWaitCompletion: Equatable {
+        var runId: String
+        var status: String
+        var completed: Bool
+    }
+
+    static func isAgentWaitCompletionStatus(_ status: String) -> Bool {
+        switch status.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() {
+        case "ok", "completed", "success", "succeeded":
+            true
+        default:
+            false
+        }
+    }
+
+    init(gateway: GatewayNodeSession) {
+        self.gateway = gateway
+    }
+
+    static func agentWaitRequestTimeoutSeconds(timeoutMs: Int) -> Int {
+        max(1, Int(ceil(Double(timeoutMs) / 1000.0)) + 5)
+    }
+
+    static func makeListSessionsParamsJSON(limit: Int?) throws -> String {
+        try self.encodeParams(ListSessionsParams(includeGlobal: true, includeUnknown: false, limit: limit))
+    }
+
+    static func makeChatSendParamsJSON(
+        sessionKey: String,
+        message: String,
+        thinking: String,
+        idempotencyKey: String,
+        attachments: [OpenClawChatAttachmentPayload]) throws -> String
+    {
+        let params = ChatSendParams(
+            sessionKey: sessionKey,
+            message: message,
+            thinking: thinking,
+            attachments: attachments.isEmpty ? nil : attachments,
+            timeoutMs: self.defaultChatSendTimeoutMs,
+            idempotencyKey: idempotencyKey)
+        return try self.encodeParams(params)
+    }
+
+    static func makeCommandsListParamsJSON(sessionKey: String? = nil) throws -> String {
+        try self.encodeParams(CommandsListRequestParams(
+            scope: "text",
+            includeArgs: true,
+            agentId: self.agentID(fromSessionKey: sessionKey)))
+    }
+
+    static func agentID(fromSessionKey sessionKey: String?) -> String? {
+        let parts = (sessionKey ?? "")
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .split(separator: ":", omittingEmptySubsequences: false)
+        guard parts.count >= 3, parts[0].lowercased() == "agent" else { return nil }
+        let agentID = String(parts[1]).trimmingCharacters(in: .whitespacesAndNewlines)
+        return agentID.isEmpty ? nil : agentID
+    }
+
+    static func decodeAgentWaitCompletion(_ data: Data, fallbackRunId: String) throws -> AgentWaitCompletion {
+        let decoded = try JSONDecoder().decode(AgentWaitResponse.self, from: data)
+        let status = (decoded.status ?? "unknown").lowercased()
+        return AgentWaitCompletion(
+            runId: decoded.runId ?? fallbackRunId,
+            status: status,
+            completed: self.isAgentWaitCompletionStatus(status))
+    }
+
+    private static func makeCreateSessionParamsJSON(
+        key: String,
+        label: String?,
+        parentSessionKey: String?) throws -> String
+    {
+        let params = CreateSessionParams(
+            key: key,
+            label: label,
+            parentSessionKey: parentSessionKey)
+        return try self.encodeParams(params)
+    }
+
+    private static func makeRunParamsJSON(sessionKey: String, runId: String) throws -> String {
+        try self.encodeParams(RunParams(sessionKey: sessionKey, runId: runId))
+    }
+
+    private static func makeSessionKeyParamsJSON(_ sessionKey: String) throws -> String {
+        try self.encodeParams(SessionKeyParams(key: sessionKey))
+    }
+
+    private static func makeHistoryParamsJSON(sessionKey: String) throws -> String {
+        struct Params: Codable { var sessionKey: String }
+        return try self.encodeParams(Params(sessionKey: sessionKey))
+    }
+
+    private static func makeAgentWaitParamsJSON(runId: String, timeoutMs: Int) throws -> String {
+        try self.encodeParams(AgentWaitParams(runId: runId, timeoutMs: timeoutMs))
+    }
+
+    private static func encodeParams(_ params: some Encodable) throws -> String {
+        let data = try JSONEncoder().encode(params)
+        guard let json = String(bytes: data, encoding: .utf8) else {
+            throw EncodingError.invalidValue(
+                params,
+                EncodingError.Context(codingPath: [], debugDescription: "Encoded gateway params were not UTF-8"))
+        }
+        return json
+    }
+
+    func createSession(
+        key: String,
+        label: String?,
+        parentSessionKey: String?) async throws -> OpenClawChatCreateSessionResponse
+    {
+        let json = try Self.makeCreateSessionParamsJSON(
+            key: key,
+            label: label,
+            parentSessionKey: parentSessionKey)
+        let res = try await self.gateway.request(method: "sessions.create", paramsJSON: json, timeoutSeconds: 15)
+        return try JSONDecoder().decode(OpenClawChatCreateSessionResponse.self, from: res)
+    }
+
+    func abortRun(sessionKey: String, runId: String) async throws {
+        let json = try Self.makeRunParamsJSON(sessionKey: sessionKey, runId: runId)
+        _ = try await self.gateway.request(method: "chat.abort", paramsJSON: json, timeoutSeconds: 10)
+    }
+
+    func listSessions(limit: Int?) async throws -> OpenClawChatSessionsListResponse {
+        let json = try Self.makeListSessionsParamsJSON(limit: limit)
+        let res = try await self.gateway.request(method: "sessions.list", paramsJSON: json, timeoutSeconds: 15)
+        return try JSONDecoder().decode(OpenClawChatSessionsListResponse.self, from: res)
+    }
+
+    func setActiveSessionKey(_ sessionKey: String) async throws {
+        struct Params: Codable { var key: String }
+        let data = try JSONEncoder().encode(Params(key: sessionKey))
+        let json = String(data: data, encoding: .utf8)
+        _ = try await self.gateway.request(
+            method: "sessions.messages.subscribe",
+            paramsJSON: json,
+            timeoutSeconds: 10)
+    }
+
+    func resetSession(sessionKey: String) async throws {
+        let json = try Self.makeSessionKeyParamsJSON(sessionKey)
+        _ = try await self.gateway.request(method: "sessions.reset", paramsJSON: json, timeoutSeconds: 10)
+    }
+
+    func compactSession(sessionKey: String) async throws {
+        let json = try Self.makeSessionKeyParamsJSON(sessionKey)
+        let response = try await self.gateway.request(
+            method: "sessions.compact",
+            paramsJSON: json,
+            timeoutSeconds: Self.compactionRequestTimeoutSeconds)
+        try OpenClawSessionsCompactResponse.requireSuccess(from: response)
+    }
+
+    func requestHistory(sessionKey: String) async throws -> OpenClawChatHistoryPayload {
+        let json = try Self.makeHistoryParamsJSON(sessionKey: sessionKey)
+        let res = try await self.gateway.request(method: "chat.history", paramsJSON: json, timeoutSeconds: 15)
+        return try JSONDecoder().decode(OpenClawChatHistoryPayload.self, from: res)
+    }
+
+    var supportsSlashCommandCatalog: Bool {
+        true
+    }
+
+    func listCommands(sessionKey: String) async throws -> [OpenClawChatCommandChoice] {
+        let json = try Self.makeCommandsListParamsJSON(sessionKey: sessionKey)
+        let res = try await self.gateway.request(method: "commands.list", paramsJSON: json, timeoutSeconds: 15)
+        let decoded = try JSONDecoder().decode(CommandsListResult.self, from: res)
+        return decoded.commands.map(Self.mapCommandChoice)
+    }
+
+    func sendMessage(
+        sessionKey: String,
+        message: String,
+        thinking: String,
+        idempotencyKey: String,
+        attachments: [OpenClawChatAttachmentPayload]) async throws -> OpenClawChatSendResponse
+    {
+        let startLogMessage =
+            "chat.send start sessionKey=\(sessionKey) "
+                + "len=\(message.count) attachments=\(attachments.count)"
+        Self.logger.info(
+            "\(startLogMessage, privacy: .public)")
+        GatewayDiagnostics.log(startLogMessage)
+        let json = try Self.makeChatSendParamsJSON(
+            sessionKey: sessionKey,
+            message: message,
+            thinking: thinking,
+            idempotencyKey: idempotencyKey,
+            attachments: attachments)
+        do {
+            let res = try await self.gateway.request(method: "chat.send", paramsJSON: json, timeoutSeconds: 35)
+            let decoded = try JSONDecoder().decode(OpenClawChatSendResponse.self, from: res)
+            Self.logger.info("chat.send ok runId=\(decoded.runId, privacy: .public)")
+            GatewayDiagnostics.log("chat.send ok runId=\(decoded.runId) status=\(decoded.status)")
+            return decoded
+        } catch {
+            Self.logger.error("chat.send failed \(error.localizedDescription, privacy: .public)")
+            GatewayDiagnostics.log("chat.send failed error=\(error.localizedDescription)")
+            throw error
+        }
+    }
+
+    private static func mapCommandChoice(_ entry: CommandEntry) -> OpenClawChatCommandChoice {
+        let sourceValue = (entry.source.value as? String)?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .lowercased()
+        let source: OpenClawChatCommandChoice.Source = switch sourceValue {
+        case "native":
+            .command
+        case "skill":
+            .skill
+        case "plugin":
+            .plugin
+        default:
+            .unknown
+        }
+        let aliases = (entry.textaliases ?? [])
+            .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
+            .filter { !$0.isEmpty }
+        let id = [
+            source.rawValue,
+            entry.name.trimmingCharacters(in: .whitespacesAndNewlines),
+            aliases.first ?? "",
+        ].joined(separator: ":")
+        return OpenClawChatCommandChoice(
+            id: id,
+            name: entry.name,
+            textAliases: aliases,
+            description: entry.description,
+            source: source,
+            acceptsArgs: entry.acceptsargs)
+    }
+
+    func waitForRunCompletion(runId rawRunId: String, timeoutMs: Int) async -> Bool {
+        let runId = rawRunId.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !runId.isEmpty else { return false }
+
+        do {
+            let json = try Self.makeAgentWaitParamsJSON(runId: runId, timeoutMs: timeoutMs)
+            let requestTimeoutSeconds = Self.agentWaitRequestTimeoutSeconds(timeoutMs: timeoutMs)
+            GatewayDiagnostics.log("agent.wait start runId=\(runId)")
+            let res = try await self.gateway.request(
+                method: "agent.wait",
+                paramsJSON: json,
+                timeoutSeconds: requestTimeoutSeconds)
+            let completion = try Self.decodeAgentWaitCompletion(res, fallbackRunId: runId)
+            GatewayDiagnostics.log("agent.wait completed runId=\(completion.runId) status=\(completion.status)")
+            if !completion.completed {
+                Self.logger.warning(
+                    "agent.wait status \(completion.status, privacy: .public) runId=\(runId, privacy: .public)")
+            }
+            return completion.completed
+        } catch {
+            Self.logger.warning("agent.wait failed \(error.localizedDescription, privacy: .public)")
+            GatewayDiagnostics.log("agent.wait failed runId=\(runId) error=\(error.localizedDescription)")
+            return false
+        }
+    }
+
+    func requestHealth(timeoutMs: Int) async throws -> Bool {
+        let seconds = max(1, Int(ceil(Double(timeoutMs) / 1000.0)))
+        let res = try await self.gateway.request(method: "health", paramsJSON: nil, timeoutSeconds: seconds)
+        return (try? JSONDecoder().decode(OpenClawGatewayHealthOK.self, from: res))?.ok ?? true
+    }
+
+    func events() -> AsyncStream<OpenClawChatTransportEvent> {
+        AsyncStream { continuation in
+            let task = Task {
+                let stream = await self.gateway.subscribeServerEvents()
+                for await evt in stream {
+                    if Task.isCancelled { return }
+                    if let mapped = Self.mapEventFrame(evt) {
+                        continuation.yield(mapped)
+                    }
+                }
+            }
+
+            continuation.onTermination = { @Sendable _ in
+                task.cancel()
+            }
+        }
+    }
+
+    static func mapEventFrame(_ evt: EventFrame) -> OpenClawChatTransportEvent? {
+        switch evt.event {
+        case "tick":
+            return .tick
+        case "seqGap":
+            return .seqGap
+        case "health":
+            guard let payload = evt.payload else { return nil }
+            let ok = (try? GatewayPayloadDecoding.decode(
+                payload,
+                as: OpenClawGatewayHealthOK.self))?.ok ?? true
+            return .health(ok: ok)
+        case "chat":
+            guard let payload = evt.payload else { return nil }
+            guard let chatPayload = try? GatewayPayloadDecoding.decode(
+                payload,
+                as: OpenClawChatEventPayload.self)
+            else {
+                return nil
+            }
+            return .chat(chatPayload)
+        case "session.message":
+            guard let payload = evt.payload else { return nil }
+            guard let message = try? GatewayPayloadDecoding.decode(
+                payload,
+                as: OpenClawSessionMessageEventPayload.self)
+            else {
+                return nil
+            }
+            return .sessionMessage(message)
+        case "agent":
+            guard let payload = evt.payload else { return nil }
+            guard let agentPayload = try? GatewayPayloadDecoding.decode(
+                payload,
+                as: OpenClawAgentEventPayload.self)
+            else {
+                return nil
+            }
+            return .agent(agentPayload)
+        default:
+            return nil
+        }
+    }
+}