var params: [String: AnyCodable] = [

"message": AnyCodable(trimmed),

"sessionKey": AnyCodable(sessionKey),

"thinking": AnyCodable(invocation.thinking ?? "default"),

"deliver": AnyCodable(invocation.deliver),

"to": AnyCodable(invocation.to ?? ""),

"channel": AnyCodable(invocation.channel.rawValue),

"idempotencyKey": AnyCodable(invocation.idempotencyKey),

]

if let thinking = invocation.thinking?.trimmingCharacters(in: .whitespacesAndNewlines),

!thinking.isEmpty

{

params["thinking"] = AnyCodable(thinking)

}

if let timeout = invocation.timeoutSeconds {

params["timeout"] = AnyCodable(timeout)

}

func chatSend(

sessionKey: String,

message: String,

thinking: String,

thinking: String?,

idempotencyKey: String,

attachments: [OpenClawChatAttachmentPayload],

timeoutMs: Int = 30000) async throws -> OpenClawChatSendResponse

var params: [String: AnyCodable] = [

"sessionKey": AnyCodable(resolvedKey),

"message": AnyCodable(message),

"thinking": AnyCodable(thinking),

"idempotencyKey": AnyCodable(idempotencyKey),

"timeoutMs": AnyCodable(timeoutMs),

]

if let thinking = thinking?.trimmingCharacters(in: .whitespacesAndNewlines),

!thinking.isEmpty

{

params["thinking"] = AnyCodable(thinking)

}

if !attachments.isEmpty {

let encoded = attachments.map { att in

let response = try await GatewayConnection.shared.chatSend(

sessionKey: sessionKey,

message: prompt,

thinking: "low",

thinking: nil,

idempotencyKey: runId,

attachments: [])

guard self.isCurrent(gen) else { return }

struct ForwardOptions {

var sessionKey: String = "main"

var thinking: String = "low"

var thinking: String?

var deliver: Bool = true

var to: String?

var channel: GatewayAgentChannel = .webchat

return ForwardOptions(

sessionKey: sessionKey,

thinking: "low",

deliver: true,

to: to,

channel: channel,

let json = try JSONSerialization.jsonObject(with: payloadData) as? [String: Any]

let params = json?["params"] as? [String: Any]

#expect(params?["thinking"] == nil)

#expect(params?["voiceWakeTrigger"] as? String == "")

}

@Test func `chat send omits thinking when inheriting session default`() async throws {

let recorder = WebSocketMessageRecorder()

let session = GatewayTestWebSocketSession(taskFactory: {

GatewayTestWebSocketTask(sendHook: { task, message, sendIndex in

recorder.append(message)

guard sendIndex > 0,

let data = Self.messageData(message),

let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],

let id = json["id"] as? String

else { return }

task.emitReceiveSuccess(.data(Self.chatSendOkResponseData(id: id)))

})

})

let connection = GatewayConnection(

configProvider: {

(url: URL(string: "ws://127.0.0.1:1")!, token: nil, password: nil)

},

sessionBox: WebSocketSessionBox(session: session))

_ = try await connection.chatSend(

sessionKey: "main",

message: "hello",

thinking: nil,

idempotencyKey: "chat-1",

attachments: [])

await connection.shutdown()

guard let chatMessage = recorder.snapshot().reversed().first(where: { message in

guard let data = Self.messageData(message),

let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any]

else { return false }

return json["method"] as? String == "chat.send"

}) else {

Issue.record("expected chat.send websocket payload")

return

}

guard let payloadData = Self.messageData(chatMessage) else {

Issue.record("unexpected chat.send websocket message type")

return

}

let json = try JSONSerialization.jsonObject(with: payloadData) as? [String: Any]

let params = json?["params"] as? [String: Any]

#expect(params?["thinking"] == nil)

}

private static func messageData(_ message: URLSessionWebSocketTask.Message) -> Data? {

switch message {

case let .string(text):

nil

}

}

private static func chatSendOkResponseData(id: String) -> Data {

Data("""

{

"type": "res",

"id": "\(id)",

"ok": true,

"payload": { "runId": "chat-1", "status": "ok" }

}

""".utf8)

}

}

@Test func `forward options defaults`() {

let opts = VoiceWakeForwarder.ForwardOptions()

#expect(opts.sessionKey == "main")

#expect(opts.thinking == "low")

#expect(opts.thinking == nil)

#expect(opts.deliver == true)

#expect(opts.to == nil)

#expect(opts.channel == .webchat)

#expect(opts.channel == .telegram)

#expect(opts.to == "telegram:6812765697")

#expect(opts.voiceWakeTrigger == "open claw")

#expect(opts.thinking == nil)

#expect(opts.channel.shouldDeliver(opts.deliver) == true)

}

`--custom-api-key` is optional in non-interactive mode. If omitted, onboarding checks `CUSTOM_API_KEY`.

OpenClaw marks common vision model IDs as image-capable automatically. Pass `--custom-image-input` for unknown custom vision IDs, or `--custom-text-input` to force text-only metadata.

Use `--custom-compatibility openai-responses` for OpenAI-compatible endpoints that support `/v1/responses` but not `/v1/chat/completions`.

LM Studio also supports a provider-specific key flag in non-interactive mode:

- `--custom-model-id`

- `--custom-api-key` (optional; falls back to `CUSTOM_API_KEY`)

- `--custom-provider-id` (optional)

- `--custom-compatibility <openai|anthropic>` (optional; default `openai`)

- `--custom-compatibility <openai|openai-responses|anthropic>` (optional; default `openai`)

- `--custom-image-input` / `--custom-text-input` (optional; override inferred model input capability)

</Accordion>

agent: "codex",

mode: "persistent",

model: "gpt-5.4",

sessionOptions: { model: "gpt-5.4" },

});

});

);

});

it("does not normalize model startup for non-Codex ACP agents", async () => {

it("passes model startup through sessionOptions for non-Codex ACP agents", async () => {

const baseStore: TestSessionStore = {

load: vi.fn(async () => undefined),

save: vi.fn(async () => {}),

agent: "main",

mode: "persistent",

model: "openai/gpt-5.5",

sessionOptions: { model: "openai/gpt-5.5" },

});

});

agent: "codex",

mode: "persistent",

model: "gpt-5.5",

sessionOptions: { model: "gpt-5.5" },

});

});

mode: "persistent",

model: "gpt-5.4/xhigh",

thinking: "x-high",

sessionOptions: { model: "gpt-5.4/xhigh" },

});

});

type AcpRuntimeStatus,

type AcpRuntimeTurn,

type AcpRuntimeTurnResult,

type SessionAgentOptions,

} from "acpx/runtime";

import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";

import { redactSensitiveText } from "openclaw/plugin-sdk/security-runtime";

openclawProcessCleanup?: AcpxProcessCleanupDeps;

};

type OpenClawRuntimeTurnInput = Parameters<NonNullable<AcpRuntime["startTurn"]>>[0];

type OpenClawRuntimeEnsureInput = Parameters<AcpRuntime["ensureSession"]>[0];

type AcpxDelegateEnsureInput = Parameters<BaseAcpxRuntime["ensureSession"]>[0];

type ResetAwareSessionStore = AcpSessionStore & {

markFresh: (sessionKey: string) => void;

: override.model;

}

function withAcpxSessionOptions(input: OpenClawRuntimeEnsureInput): AcpxDelegateEnsureInput {

const existingOptions = (input as { sessionOptions?: SessionAgentOptions }).sessionOptions;

const model = input.model?.trim() || existingOptions?.model;

const sessionOptions = model ? { ...existingOptions, model } : existingOptions;

return {

...input,

...(sessionOptions ? { sessionOptions } : {}),

} as AcpxDelegateEnsureInput;

}

function quoteShellArg(value: string): string {

if (/^[A-Za-z0-9_./:=@+-]+$/.test(value)) {

return value;

this.withCodexWrapperDiagnostics({

command: stableLaunchCommand,

fallbackCode: "ACP_SESSION_INIT_FAILED",

run: () => delegate.ensureSession(input),

run: () => delegate.ensureSession(withAcpxSessionOptions(input)),

}),

});

}

this.withCodexWrapperDiagnostics({

command: stableLaunchCommand,

fallbackCode: "ACP_SESSION_INIT_FAILED",

run: () => delegate.ensureSession(normalizedInput),

run: () => delegate.ensureSession(withAcpxSessionOptions(normalizedInput)),

}),

),

});

import {

filterCodexDynamicTools,

resolveCodexDynamicToolsLoading,

resolveCodexDynamicToolsLoadingForModel,

shouldUseDirectCodexDynamicToolsForModel,

} from "./dynamic-tool-profile.js";

import { createCodexDynamicToolBridge } from "./dynamic-tools.js";

import { createCodexTestModel } from "./test-support.js";

expect(resolveCodexDynamicToolsLoading({}, privateQaCodexEnv)).toBe("direct");

});

it("uses direct dynamic tools for OpenAI nano models without tool_search support", () => {

const tools = [createRuntimeDynamicTool("message"), createRuntimeDynamicTool("web_search")];

const toolBridge = createCodexDynamicToolBridge({

tools,

signal: new AbortController().signal,

loading: resolveCodexDynamicToolsLoadingForModel({}, "openai/gpt-5.4-nano"),

});

expect(shouldUseDirectCodexDynamicToolsForModel("gpt-5.4-nano")).toBe(true);

expect(resolveCodexDynamicToolsLoadingForModel({}, "gpt-5.4-nano")).toBe("direct");

expect(resolveCodexDynamicToolsLoadingForModel({}, "gpt-5.5")).toBe("searchable");

const webSearch = toolBridge.specs.find((tool) => tool.name === "web_search");

expect(webSearch).not.toHaveProperty("deferLoading");

expect(webSearch).not.toHaveProperty("namespace");

});

it("quarantines unreadable tool entries before Codex-specific filtering", async () => {

const messageTool = createRuntimeDynamicTool("message");

const sourceTools = new Proxy([messageTool] as RuntimeDynamicToolForTest[], {