val relaySessionId: String,

)

private const val REALTIME_AGENT_CONSULT_TOOL = "openclaw_agent_consult"

private const val REALTIME_AGENT_CONTROL_TOOL = "openclaw_agent_control"

private data class RealtimeToolCompletion(

val state: String,

val messageEl: JsonElement?,

pendingRealtimeToolCalls.add(callId)

scope.launch {

try {

if (name == REALTIME_AGENT_CONTROL_TOOL) {

submitRealtimeAgentControl(callId = callId, relaySessionId = relaySessionId, args = args)

return@launch

}

if (forced) {

submitRealtimeToolWorking(callId, relaySessionId)

}

result =

buildJsonObject {

put("status", JsonPrimitive("working"))

put("tool", JsonPrimitive("openclaw_agent_consult"))

put("tool", JsonPrimitive(REALTIME_AGENT_CONSULT_TOOL))

put(

"message",

JsonPrimitive(

)

}

private suspend fun submitRealtimeAgentControl(

callId: String,

relaySessionId: String,

args: JsonElement?,

) {

val argsObject = args.asObjectOrNull()

val text = argsObject?.get("text").asStringOrNull()?.trim().orEmpty()

val mode = argsObject?.get("mode").asStringOrNull()?.trim()

val params =

buildJsonObject {

put("sessionId", JsonPrimitive(relaySessionId))

put("sessionKey", JsonPrimitive(mainSessionKey.ifBlank { "main" }))

put("text", JsonPrimitive(text.ifEmpty { "status" }))

if (!mode.isNullOrEmpty()) put("mode", JsonPrimitive(mode))

}

val response = session.request("talk.session.steer", params.toString(), timeoutMs = 15_000)

val result = json.parseToJsonElement(response).asObjectOrNull()

if (result != null) {

submitRealtimeToolResult(callId = callId, result = result, sessionId = relaySessionId)

} else {

submitRealtimeToolError(callId, "control call returned no result", relaySessionId)

}

}

private fun upsertRealtimeConversation(

role: VoiceConversationRole,

text: String,

@MainActor

final class RealtimeTalkRelaySession {

private static let agentControlToolName = "openclaw_agent_control"

struct Options {

let sessionKey: String

let provider: String?

else { return }

self.onStatus("Thinking…")

do {

if name == Self.agentControlToolName {

try await self.handleAgentControlToolCall(

callId: callId,

relaySessionId: relaySessionId,

args: payload["args"])

return

}

let completionStream = await self.gateway.subscribeServerEvents(bufferingNewest: 200)

let args = payload["args"]?.foundationValue ?? [:]

let startPayload: [String: Any] = [

}

}

private func handleAgentControlToolCall(

callId: String,

relaySessionId: String,

args: AnyCodable?) async throws

{

let controlArgs = args?.dictionaryValue ?? [:]

var payload: [String: Any] = [

"sessionId": relaySessionId,

"sessionKey": self.options.sessionKey,

"text": controlArgs["text"]?.stringValue?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "status",

]

if let mode = controlArgs["mode"]?.stringValue?.trimmingCharacters(in: .whitespacesAndNewlines),

!mode.isEmpty

{

payload["mode"] = mode

}

let response = try await self.requestJSON(

method: "talk.session.steer",

payload: payload,

decodeAs: AnyCodable.self,

timeoutSeconds: 30)

let result = response.dictionaryValue?.mapValues(\.foundationValue) ?? [

"result": response.foundationValue,

]

try await self.submitToolResult(callId: callId, result: result)

self.onStatus("Listening (Realtime)")

}

private func submitToolResult(callId: String, result: [String: Any]) async throws {

guard let relaySessionId else { return }

let payload: [String: Any] = [

}

}

public struct TalkClientSteerParams: Codable, Sendable {

public let sessionkey: String

public let text: String

public let mode: AnyCodable?

public init(

sessionkey: String,

text: String,

mode: AnyCodable?)

{

self.sessionkey = sessionkey

self.text = text

self.mode = mode

}

private enum CodingKeys: String, CodingKey {

case sessionkey = "sessionKey"

case text

case mode

}

}

public struct TalkAgentControlResult: Codable, Sendable {

public let ok: Bool

public let mode: AnyCodable

public let sessionkey: String

public let sessionid: String?

public let active: Bool

public let queued: Bool?

public let aborted: Bool?

public let target: AnyCodable?

public let reason: String?

public let message: String

public let speak: Bool

public let show: Bool

public let suppress: Bool

public let providerresult: [String: AnyCodable]?

public let enqueuedatms: Double?

public let deliveredatms: Double?

public init(

ok: Bool,

mode: AnyCodable,

sessionkey: String,

sessionid: String?,

active: Bool,

queued: Bool?,

aborted: Bool?,

target: AnyCodable?,

reason: String?,

message: String,

speak: Bool,

show: Bool,

suppress: Bool,

providerresult: [String: AnyCodable]?,

enqueuedatms: Double?,

deliveredatms: Double?)

{

self.ok = ok

self.mode = mode

self.sessionkey = sessionkey

self.sessionid = sessionid

self.active = active

self.queued = queued

self.aborted = aborted

self.target = target

self.reason = reason

self.message = message

self.speak = speak

self.show = show

self.suppress = suppress

self.providerresult = providerresult

self.enqueuedatms = enqueuedatms

self.deliveredatms = deliveredatms

}

private enum CodingKeys: String, CodingKey {

case ok

case mode

case sessionkey = "sessionKey"

case sessionid = "sessionId"

case active

case queued

case aborted

case target

case reason

case message

case speak

case show

case suppress

case providerresult = "providerResult"

case enqueuedatms = "enqueuedAtMs"

case deliveredatms = "deliveredAtMs"

}

}

public struct TalkClientToolCallParams: Codable, Sendable {

public let sessionkey: String

public let callid: String

}

}

public struct TalkSessionSteerParams: Codable, Sendable {

public let sessionid: String

public let sessionkey: String?

public let text: String

public let mode: AnyCodable?

public init(

sessionid: String,

sessionkey: String?,

text: String,

mode: AnyCodable?)

{

self.sessionid = sessionid

self.sessionkey = sessionkey

self.text = text

self.mode = mode

}

private enum CodingKeys: String, CodingKey {

case sessionid = "sessionId"

case sessionkey = "sessionKey"

case text

case mode

}

}

public struct TalkSessionSubmitToolResultParams: Codable, Sendable {

public let sessionid: String

public let callid: String

["poll", ["operator.write"]],

["talk.client.create", ["operator.write"]],

["talk.client.toolCall", ["operator.write"]],

["talk.client.steer", ["operator.write"]],

["talk.session.create", ["operator.write"]],

["talk.session.join", ["operator.write"]],

["talk.session.appendAudio", ["operator.write"]],

["talk.session.cancelTurn", ["operator.write"]],

["talk.session.cancelOutput", ["operator.write"]],

["talk.session.submitToolResult", ["operator.write"]],

["talk.session.steer", ["operator.write"]],

["talk.session.close", ["operator.write"]],

["update.status", ["operator.admin"]],

["config.schema", ["operator.admin"]],

for (const method of [

"talk.client.create",

"talk.client.toolCall",

"talk.client.steer",

"talk.session.create",

"talk.session.join",

"talk.session.appendAudio",

"talk.session.cancelTurn",

"talk.session.cancelOutput",

"talk.session.submitToolResult",

"talk.session.steer",

"talk.session.close",

]) {

expect(authorizeOperatorScopesForMethod(method, ["operator.write"])).toEqual({

{ name: "talk.config", scope: "operator.read" },

{ name: "talk.client.create", scope: "operator.write" },

{ name: "talk.client.toolCall", scope: "operator.write" },

{ name: "talk.client.steer", scope: "operator.write" },

{ name: "talk.session.create", scope: "operator.write" },

{ name: "talk.session.join", scope: "operator.write" },

{ name: "talk.session.appendAudio", scope: "operator.write" },

{ name: "talk.session.cancelTurn", scope: "operator.write" },

{ name: "talk.session.cancelOutput", scope: "operator.write" },

{ name: "talk.session.submitToolResult", scope: "operator.write" },

{ name: "talk.session.steer", scope: "operator.write" },

{ name: "talk.session.close", scope: "operator.write" },

{ name: "talk.speak", scope: "operator.write" },

{ name: "talk.mode", scope: "operator.write" },

validateTalkConfigResult,

validateTalkEvent,

validateTalkClientCreateParams,

validateTalkClientSteerParams,

validateTalkClientToolCallParams,

validateTalkAgentControlResult,

validateTalkSessionAppendAudioParams,

validateTalkSessionCancelOutputParams,

validateTalkSessionCancelTurnParams,

validateTalkSessionCreateParams,

validateTalkSessionJoinParams,

validateTalkSessionJoinResult,

validateTalkSessionSubmitToolResultParams,

validateTalkSessionSteerParams,

validateTalkSessionTurnParams,

validateTalkSessionTurnResult,

validateWakeParams,

});

});

describe("validateTalkAgentControlParams", () => {

it("accepts client and session steering params plus structured outcomes", () => {

expect(

validateTalkClientSteerParams({

sessionKey: "agent:main:main",

text: "use the safer path",

mode: "steer",

}),

).toBe(true);

expect(

validateTalkSessionSteerParams({

sessionId: "talk-1",

sessionKey: "agent:main:main",

text: "status",

mode: "status",

}),

).toBe(true);

expect(

validateTalkAgentControlResult({

ok: true,

mode: "cancel",

sessionKey: "agent:main:main",

sessionId: "session-1",

active: true,

aborted: true,

message: "Cancelled the active OpenClaw run.",

speak: true,

show: true,

suppress: false,

providerResult: {

status: "cancelled",

message: "Cancelled the active OpenClaw run.",

},

}),

).toBe(true);

});

});

describe("validateTalkSessionRelayParams", () => {

it("accepts session audio, cancel, output cancel, and tool result params", () => {

expect(