### Fixes

- ACP sessions: map canonical runtime options to backend-advertised ACP config keys like Claude's `effort` while keeping persisted OpenClaw state canonical. (#79926) Thanks @InTheCloudDan.

- CLI/update: allow restart health probes from the previous gateway protocol during self-update, and make plugin dry-runs report exact npm target versions instead of `unknown` while preserving unchanged status.

- OpenAI/Codex: point gateway missing-key recovery and wizard docs at the canonical `openai/gpt-5.5` plus Codex OAuth route, and fix trajectory export errors so they suggest the valid `openclaw sessions` command.

- Google/Gemini: normalize retired `google/gemini-3-pro-preview` primary, fallback, and model-map refs during config load and unrelated config writes so saved config keeps targeting Gemini 3.1 Pro Preview.

- Discord/voice: synthesize realtime playback timestamps from emitted Discord PCM so OpenAI realtime barge-in truncation no longer sees `audioEndMs=0` and skips legitimate interruptions.

NodeRenameParamsSchema,

type PollParams,

PollParamsSchema,

MIN_PROBE_PROTOCOL_VERSION,

PROTOCOL_VERSION,

type PushTestParams,

PushTestParamsSchema,

TickEventSchema,

ShutdownEventSchema,

ProtocolSchemas,

MIN_PROBE_PROTOCOL_VERSION,

PROTOCOL_VERSION,

ErrorCodes,

errorShape,

ShutdownEvent: ShutdownEventSchema,

} satisfies Record<string, TSchema>;

export { PROTOCOL_VERSION } from "../version.js";

export { MIN_PROBE_PROTOCOL_VERSION, PROTOCOL_VERSION } from "../version.js";

export const PROTOCOL_VERSION = 4 as const;

export const MIN_PROBE_PROTOCOL_VERSION = 3 as const;

getPreauthHandshakeTimeoutMsFromEnv,

GATEWAY_CLIENT_MODES,

GATEWAY_CLIENT_NAMES,

MIN_PROBE_PROTOCOL_VERSION,

NODE_CLIENT,

onceMessage,

openWs,

ws.close();

});

test("allows previous protocol for restart health probes", async () => {

const ws = await openWs(port);

const res = await connectReq(ws, {

minProtocol: MIN_PROBE_PROTOCOL_VERSION,

maxProtocol: MIN_PROBE_PROTOCOL_VERSION,

client: {

id: GATEWAY_CLIENT_NAMES.PROBE,

version: "2026.5.7",

platform: "cli",

mode: GATEWAY_CLIENT_MODES.PROBE,

},

});

expect(res.ok).toBe(true);

expect((res.payload as { type?: unknown } | undefined)?.type).toBe("hello-ok");

ws.close();

});

test("keeps previous protocol rejected for non-probe clients", async () => {

const ws = await openWs(port);

try {

const res = await connectReq(ws, {

minProtocol: MIN_PROBE_PROTOCOL_VERSION,

maxProtocol: MIN_PROBE_PROTOCOL_VERSION,

});

expect(res.ok).toBe(false);

} catch {

// If the server closed before we saw the frame, that's acceptable.

}

ws.close();

});

test("rejects non-connect first request", async () => {

const ws = await openWs(port);

ws.send(JSON.stringify({ type: "req", id: "h1", method: "health" }));

import { withEnvAsync } from "../test-utils/env.js";

import { GATEWAY_CLIENT_MODES, GATEWAY_CLIENT_NAMES } from "../utils/message-channel.js";

import { buildDeviceAuthPayload } from "./device-auth.js";

import { PROTOCOL_VERSION } from "./protocol/index.js";

import { MIN_PROBE_PROTOCOL_VERSION, PROTOCOL_VERSION } from "./protocol/index.js";

import {

createGatewaySuiteHarness,

connectReq,

getFreePort,

getTrackedConnectChallengeNonce,

installGatewayTestHooks,

MIN_PROBE_PROTOCOL_VERSION,

NODE_CLIENT,

onceMessage,

openTailscaleWs,

type ErrorShape,

errorShape,

formatValidationErrors,

MIN_PROBE_PROTOCOL_VERSION,

PROTOCOL_VERSION,

validateConnectParams,

validateRequestFrame,

// protocol negotiation

const { minProtocol, maxProtocol } = connectParams;

if (maxProtocol < PROTOCOL_VERSION || minProtocol > PROTOCOL_VERSION) {

const supportsCurrentProtocol =

maxProtocol >= PROTOCOL_VERSION && minProtocol <= PROTOCOL_VERSION;

const supportsProbeRestartProtocol =

connectParams.client.mode === GATEWAY_CLIENT_MODES.PROBE &&

maxProtocol >= MIN_PROBE_PROTOCOL_VERSION &&

minProtocol <= PROTOCOL_VERSION;

if (!supportsCurrentProtocol && !supportsProbeRestartProtocol) {

markHandshakeFailure("protocol-mismatch", {

minProtocol,

maxProtocol,

expectedProtocol: PROTOCOL_VERSION,

minimumProbeProtocol: MIN_PROBE_PROTOCOL_VERSION,

});

logWsControl.warn(

`protocol mismatch conn=${connId} remote=${remoteAddr ?? "?"} client=${clientLabel} ${connectParams.client.mode} v${connectParams.client.version}`,

);

sendHandshakeErrorResponse(ErrorCodes.INVALID_REQUEST, "protocol mismatch", {

details: { expectedProtocol: PROTOCOL_VERSION },

details: {

expectedProtocol: PROTOCOL_VERSION,

minimumProbeProtocol: MIN_PROBE_PROTOCOL_VERSION,

},

});

close(1002, "protocol mismatch");

return;

);

});

it("uses exact npm spec selectors as dry-run target versions when probes omit metadata", async () => {

const installPath = createInstalledPackageDir({

name: "@acme/demo",

version: "1.2.3",

});

installPluginFromNpmSpecMock.mockResolvedValue({

ok: true,

pluginId: "demo",

targetDir: installPath,

extensions: ["index.ts"],

});

const result = await updateNpmInstalledPlugins({

config: createNpmInstallConfig({

pluginId: "demo",

spec: "@acme/demo@1.2.4",

installPath,

}),

pluginIds: ["demo"],

dryRun: true,

});

expect(result.outcomes[0]).toMatchObject({

pluginId: "demo",

status: "updated",

currentVersion: "1.2.3",

nextVersion: "1.2.4",

message: "Would update demo: 1.2.3 -> 1.2.4.",

});

});

it("keeps exact npm dry-runs unchanged when probe metadata is absent but spec matches", async () => {

const installPath = createInstalledPackageDir({

name: "@acme/demo",

version: "1.2.3",

});

installPluginFromNpmSpecMock.mockResolvedValue({

ok: true,

pluginId: "demo",

targetDir: installPath,

extensions: ["index.ts"],

});

const result = await updateNpmInstalledPlugins({

config: createNpmInstallConfig({

pluginId: "demo",

spec: "@acme/demo@1.2.3",

installPath,

}),

pluginIds: ["demo"],

dryRun: true,

});

expect(result.outcomes[0]).toMatchObject({

pluginId: "demo",

status: "unchanged",

currentVersion: "1.2.3",

nextVersion: "1.2.3",

message: "demo is up to date (1.2.3).",

});

});

it("updates disabled trusted official ClawHub installs through the catalog spec", async () => {

installPluginFromClawHubMock.mockResolvedValue(

createSuccessfulClawHubUpdateResult({

return spec ? parseRegistryNpmSpec(spec)?.name : undefined;

}

function resolveExactNpmSpecVersion(spec: string | undefined): string | undefined {

const parsed = spec ? parseRegistryNpmSpec(spec) : null;

return parsed?.selectorKind === "exact-version" ? parsed.selector : undefined;

}

function resolveClawHubSpecPackageName(spec: string | undefined): string | undefined {

return spec ? parseClawHubPluginSpec(spec)?.name : undefined;

}

continue;

}

const nextVersion = probe.version ?? "unknown";

const probeSpec = usedNpmFallback ? npmSpecs?.fallbackSpec : effectiveSpec;

const resolvedProbeVersion =

probe.version ??

(record.source === "npm" ? resolveExactNpmSpecVersion(probeSpec) : undefined);

const nextVersion = resolvedProbeVersion ?? "unknown";

const currentLabel = currentVersion ?? "unknown";

const gitProbe =

record.source === "git"

const unchanged =

record.source === "git" && record.gitCommit && gitProbe?.commit

? record.gitCommit === gitProbe.commit

: Boolean(currentVersion && probe.version && currentVersion === probe.version);

: Boolean(

currentVersion && resolvedProbeVersion && currentVersion === resolvedProbeVersion,

);

if (unchanged) {

outcomes.push({

pluginId,

status: "unchanged",

currentVersion: currentVersion ?? undefined,

nextVersion: probe.version ?? undefined,

nextVersion: resolvedProbeVersion,

message: `${pluginId} is up to date (${currentLabel}).`,

});

} else {

outcomes.push({

pluginId,

status: "updated",

currentVersion: currentVersion ?? undefined,

nextVersion: probe.version ?? undefined,

nextVersion: resolvedProbeVersion,

message: `Would update ${pluginId}: ${currentLabel} -> ${nextVersion}.`,

});

}