import ai.openclaw.app.gateway.GatewayRequestRejected

put("succeedsParent", JsonPrimitive(false))

val res = requestSessionCreateWithDispositionFallback(createGatewayId, params)

private suspend fun requestSessionCreateWithDispositionFallback(

gatewayId: String?,

params: JsonObject,

): String =

try {

requestGatewayBound(gatewayId, "sessions.create", params.toString())

} catch (err: GatewayRequestRejected) {

val message = err.gatewayError.message

val isOlderGateway =

err.gatewayError.code == "INVALID_REQUEST" &&

message.contains("invalid sessions.create params") &&

message.contains("succeedsParent")

if (!isOlderGateway || "succeedsParent" !in params) throw err

// Older Gateways cannot express a linked parallel child. Keep New Chat parallel by

// dropping the parent lifecycle fields instead of falling back to legacy rollover.

val legacyParams =

JsonObject(

params.filterKeys { key ->

key != "succeedsParent" && key != "parentSessionKey" && key != "emitCommandHooks"

},

)

requestGatewayBound(gatewayId, "sessions.create", legacyParams.toString())

}

import ai.openclaw.app.gateway.GatewayRequestRejected

import ai.openclaw.app.gateway.GatewaySession

assertTrue(create.second.orEmpty().contains("\"succeedsParent\":false"))

@OptIn(ExperimentalCoroutinesApi::class)

@Test

fun startNewChatRetriesWithoutParentLifecycleAgainstOlderGateway() =

runTest {

val requests = mutableListOf<Pair<String, String?>>()

var createCalls = 0

val controller =

ChatController(

scope = this,

json = json,

requestGateway = { method, paramsJson ->

requests += method to paramsJson

when (method) {

"sessions.create" -> {

createCalls += 1

if (createCalls == 1) {

throw GatewayRequestRejected(

GatewaySession.ErrorShape(

code = "INVALID_REQUEST",

message =

"invalid sessions.create params: at root: unexpected property 'succeedsParent'",

),

)

}

"""{"ok":true,"key":"agent:main:dashboard:fresh"}"""

}

"chat.history" -> """{"sessionId":"fresh-session","messages":[]}"""

"health" -> "{}"

"sessions.list" -> """{"sessions":[]}"""

else -> "{}"

}

},

)

controller.handleGatewayEvent("health", null)

controller.load("main")

advanceUntilIdle()

assertTrue(controller.startNewChatAwait())

val creates = requests.filter { it.first == "sessions.create" }

assertEquals(2, creates.size)

assertTrue(creates[0].second.orEmpty().contains("\"succeedsParent\":false"))

assertEquals(false, creates[1].second.orEmpty().contains("\"succeedsParent\""))

assertEquals(false, creates[1].second.orEmpty().contains("\"parentSessionKey\""))

assertEquals(false, creates[1].second.orEmpty().contains("\"emitCommandHooks\""))

assertTrue(creates[1].second.orEmpty().contains("\"agentId\":\"main\""))

assertTrue(creates[1].second.orEmpty().contains("\"label\":\"New chat\""))

assertEquals("agent:main:dashboard:fresh", controller.sessionKey.value)

}

public let succeedsparent: Bool?

succeedsparent: Bool? = nil,

self.succeedsparent = succeedsparent

case succeedsparent = "succeedsParent"

- `sessions.create` creates a new session entry. Optional `model` and `thinkingLevel` values persist the initial model and reasoning overrides atomically. `worktree: true` provisions a managed worktree; optional `worktreeBaseRef`/`worktreeName` select the base ref and branch name, and `execNode` (`operator.admin`) binds session exec to a node host. The created worktree is echoed in the result and persisted on the session row (`worktree: { id, branch, repoRoot }`). When the entry is created but its nested initial `chat.send` is rejected, the successful result includes `runStarted: false` and `runError`; clients can preserve the prompt and retry against the returned session key. A caller that passes `parentSessionKey` with `emitCommandHooks: true` should also declare the lifecycle disposition of a distinct child: `succeedsParent: true` ends the parent with `session_end`, while `false` keeps the parent active and emits only the child's `session_start`. Omitting `succeedsParent` preserves the legacy parent-rollover behavior for existing clients. The disposition requires both parent linkage and command hooks; a fork cannot succeed its parent. Main-session reset-in-place behavior is unchanged because no distinct child is created.

For `sessions.create` calls with `parentSessionKey` and `emitCommandHooks: true`, a distinct child always receives `session_start`. Callers declare whether the parent also receives terminal `session_end` with `succeedsParent`: `true` means successor, `false` means parallel child. Omission preserves the legacy parent-rollover behavior. The `command:new` and `before_reset` hooks still describe the requested `/new` action in both cases.

import { describe, expect, it } from "vitest";

import { validateNodeInvokeProgressParams } from "../index.js";

describe("node protocol schemas", () => {

it("accepts bounded progress chunks and rejects extra fields", () => {

expect(

validateNodeInvokeProgressParams({

invokeId: "invoke-1",

nodeId: "node-1",

seq: 0,

chunk: "stdout line",

}),

).toBe(true);

expect(

validateNodeInvokeProgressParams({

invokeId: "invoke-1",

nodeId: "node-1",

seq: 0,

chunk: "x".repeat(16 * 1024 + 1),

}),

).toBe(false);

expect(

validateNodeInvokeProgressParams({

invokeId: "invoke-1",

nodeId: "node-1",

seq: 0,

chunk: "stdout line",

extra: "not allowed",

}),

).toBe(false);

});

export const NodeInvokeProgressParamsSchema = closedObject({

invokeId: NonEmptyString,

nodeId: NonEmptyString,

seq: Type.Integer({ minimum: 0 }),

// Empty chunks are liveness heartbeats for captured stderr or capped stdout.

chunk: Type.String({ maxLength: 16 * 1024 }),

it("rejects extra fields in dispatch params and results", () => {

const active = {

state: "active" as const,

...basePlacement,

...workerOwnedFields,

};

expect(

validateSessionsDispatchResult({

ok: true,

key: "agent:main:dispatch",

sessionId: "session-1",

placement: active,

extra: true,

}),

).toBe(false);

expect(

validateSessionsDispatchParams({

key: "agent:main:dispatch",

profileId: "development",

extra: true,

}),

).toBe(false);

});