### Fixes

- Google/Gemini: normalize retired nested Gemini 3 Pro Preview ids while converting manifest catalog rows into emitted provider config, so `google/gemini-3.1-pro-preview` is used for testing instead of `google/gemini-3-pro-preview`.

- Native apps: advertise the Gateway protocol compatibility range so chat and node sessions can connect to v3 gateways after additive v4 client updates.

- Gateway: avoid synchronous restart-sentinel state probes during post-attach startup, preventing slow Windows or redirected state directories from blocking channel turns. Fixes #79264. Thanks @liyi58.

- Agents/auth: update successful model auth profile status with one locked store write, reducing post-model reply latency from duplicate `auth-profiles.json` saves. Thanks @mcaxtr.

- Agents/image: honor explicit `image` tool model overrides even when `agents.defaults.imageModel` is unset, restoring one-off vision calls for configured multimodal providers. Fixes #79341. Thanks @haumanto.

package ai.openclaw.app.gateway

const val GATEWAY_PROTOCOL_VERSION = 4

const val GATEWAY_MIN_PROTOCOL_VERSION = 3

}

return buildJsonObject {

put("minProtocol", JsonPrimitive(GATEWAY_PROTOCOL_VERSION))

put("minProtocol", JsonPrimitive(GATEWAY_MIN_PROTOCOL_VERSION))

put("maxProtocol", JsonPrimitive(GATEWAY_PROTOCOL_VERSION))

put("client", clientObj)

if (options.caps.isNotEmpty()) put("caps", JsonArray(options.caps.map(::JsonPrimitive)))

@RunWith(RobolectricTestRunner::class)

@Config(sdk = [34])

class GatewaySessionInvokeTest {

@Test

fun connect_advertisesCompatibleProtocolRange() =

runBlocking {

val json = testJson()

val connected = CompletableDeferred<Unit>()

val connectParams = CompletableDeferred<JsonObject>()

val lastDisconnect = AtomicReference("")

val server =

startGatewayServer(json) { webSocket, id, method, frame ->

when (method) {

"connect" -> {

if (!connectParams.isCompleted) {

connectParams.complete(frame["params"]!!.jsonObject)

}

webSocket.send(connectResponseFrame(id))

webSocket.close(1000, "done")

}

}

}

val harness =

createNodeHarness(

connected = connected,

lastDisconnect = lastDisconnect,

) { GatewaySession.InvokeResult.ok("""{"handled":true}""") }

try {

connectNodeSession(harness.session, server.port)

awaitConnectedOrThrow(connected, lastDisconnect, server)

val params = withTimeout(TEST_TIMEOUT_MS) { connectParams.await() }

assertEquals(

GATEWAY_MIN_PROTOCOL_VERSION,

params["minProtocol"]?.jsonPrimitive?.content?.toInt(),

)

assertEquals(

GATEWAY_PROTOCOL_VERSION,

params["maxProtocol"]?.jsonPrimitive?.content?.toInt(),

)

} finally {

shutdownHarness(harness, server)

}

}

@Test

fun connect_usesBootstrapTokenWhenSharedAndDeviceTokensAreAbsent() =

runBlocking {

]

var params: [String: ProtoAnyCodable] = [

"minProtocol": ProtoAnyCodable(GATEWAY_PROTOCOL_VERSION),

"minProtocol": ProtoAnyCodable(GATEWAY_MIN_PROTOCOL_VERSION),

"maxProtocol": ProtoAnyCodable(GATEWAY_PROTOCOL_VERSION),

"client": ProtoAnyCodable(client),

"caps": ProtoAnyCodable([String]()),

import Foundation

import OpenClawKit

import OpenClawProtocol

import Testing

@testable import OpenClaw

struct GatewayChannelConnectTests {

private final class ConnectParamsRecorder: @unchecked Sendable {

private let lock = NSLock()

private var params: [String: Any]?

func record(_ message: URLSessionWebSocketTask.Message) {

guard let params = GatewayWebSocketTestSupport.connectRequestParams(from: message) else {

return

}

self.lock.lock()

self.params = params

self.lock.unlock()

}

func snapshot() -> [String: Any]? {

self.lock.lock()

defer { self.lock.unlock() }

return self.params

}

}

private final class TLSFailureSession: WebSocketSessioning, GatewayTLSFailureProviding, @unchecked Sendable {

private var failure: GatewayTLSValidationFailure?

#expect(session.snapshotMakeCount() == 1)

}

@Test func `connect advertises compatible protocol range`() async throws {

let recorder = ConnectParamsRecorder()

let session = GatewayTestWebSocketSession(

taskFactory: {

GatewayTestWebSocketTask(

sendHook: { _, message, sendIndex in

guard sendIndex == 0 else { return }

recorder.record(message)

})

})

let channel = try GatewayChannelActor(

url: #require(URL(string: "ws://example.invalid")),

token: nil,

session: WebSocketSessionBox(session: session))

try await channel.connect()

let params = try #require(recorder.snapshot())

#expect(params["minProtocol"] as? Int == GATEWAY_MIN_PROTOCOL_VERSION)

#expect(params["maxProtocol"] as? Int == GATEWAY_PROTOCOL_VERSION)

}

@Test func `concurrent connect shares failure`() async throws {

let session = self.makeSession(response: .invalid(delayMs: 200))

let channel = try GatewayChannelActor(

return obj["id"] as? String

}

static func connectRequestParams(from message: URLSessionWebSocketTask.Message) -> [String: Any]? {

guard let obj = self.requestFrameObject(from: message) else { return nil }

guard (obj["type"] as? String) == "req", (obj["method"] as? String) == "connect" else {

return nil

}

return obj["params"] as? [String: Any]

}

static func connectOkData(id: String) -> Data {

let json = """

{

"id": "\(id)",

"ok": false,

"error": {

"code": "INVALID_REQUEST",

"message": "\(message)",

"details": {

"code": "\(detailCode)",

details.merge(nested) { _, nestedValue in nestedValue }

}

if let error {

details["code"] = ProtoAnyCodable(error.code)

if details["code"] == nil {

details["code"] = ProtoAnyCodable(error.code)

}

details["message"] = ProtoAnyCodable(error.message)

if let retryable = error.retryable {

details["retryable"] = ProtoAnyCodable(retryable)

client["modelIdentifier"] = ProtoAnyCodable(model)

}

var params: [String: ProtoAnyCodable] = [

"minProtocol": ProtoAnyCodable(GATEWAY_PROTOCOL_VERSION),

"minProtocol": ProtoAnyCodable(GATEWAY_MIN_PROTOCOL_VERSION),

"maxProtocol": ProtoAnyCodable(GATEWAY_PROTOCOL_VERSION),

"client": ProtoAnyCodable(client),

"caps": ProtoAnyCodable(options.caps),

import Foundation

public let GATEWAY_PROTOCOL_VERSION = 4

public let GATEWAY_MIN_PROTOCOL_VERSION = 3

public enum ErrorCode: String, Codable, Sendable {

case notLinked = "NOT_LINKED"

"id": "c1",

"method": "connect",

"params": {

"minProtocol": 4,

"minProtocol": 3,

"maxProtocol": 4,

"client": {

"id": "openclaw-macos",

- `GatewayFrame` enum with `req`, `res`, `event`, and `unknown` cases

- Strongly typed payload structs/enums

- `ErrorCode` values and `GATEWAY_PROTOCOL_VERSION`

- `ErrorCode` values, `GATEWAY_PROTOCOL_VERSION`, and `GATEWAY_MIN_PROTOCOL_VERSION`

Unknown frame types are preserved as raw payloads for forward compatibility.

## Versioning + compatibility

- `PROTOCOL_VERSION` lives in `src/gateway/protocol/version.ts`.

- Clients send `minProtocol` + `maxProtocol`; the server rejects mismatches.

- Clients send `minProtocol` + `maxProtocol`; the server rejects ranges that

do not include its current protocol.

- The Swift models keep unknown frame types to avoid breaking older clients.

## Schema patterns and conventions