- Gateway/agents: keep structured reasons when active-run queueing fails and deprecate the legacy boolean queue helper, so steering and subagent wake diagnostics distinguish completed, non-streaming, and compacting runs. Fixes #80156. Thanks @markus-lassfolk.

- Agents/UI: compact exec and tool progress rows by hiding redundant shell tool names, replacing known workspace paths with short context markers, and preserving Discord trace scrubbing for compact command lines.

- ACPX: run and await the embedded ACP backend startup probe by default so the gateway `ready` signal no longer fires before the acpx runtime has either become usable or reported a probe failure; set `OPENCLAW_ACPX_RUNTIME_STARTUP_PROBE=0` to restore lazy startup. Fixes #79596. Thanks @bzelones.

- Gateway/status: surface model-pricing bootstrap and refresh failures as degraded health/status warnings while keeping Gateway liveness healthy. Fixes #79599. Thanks @bzelones.

- OpenAI-compatible models: strip prior assistant reasoning fields from replayed Chat Completions history by default, preventing oMLX/vLLM Qwen follow-up turns from rejecting or stalling on stale `reasoning` payloads. Fixes #46637. Thanks @zipzagster and @lexhoefsloot.

- CLI/onboarding: give non-Azure custom providers a safe generated context window and heal legacy 4k wizard entries without overwriting explicit valid small model limits, preventing first-turn compaction loops. Fixes #79428. (#79911) Thanks @Jefsky.

- OpenAI-compatible models: add `compat.strictMessageKeys` to strip Chat Completions replay messages to `role` and `content` for strict providers that reject OpenAI-style tool and metadata keys. Fixes #50374. Thanks @choutos.

requireRecord(firstTarget.summary, "first target summary");

});

it("surfaces degraded model-pricing health as a warning", async () => {

const { runtime, runtimeLogs, runtimeErrors } = createRuntimeCapture();

const defaultProbeGateway = probeGateway.getMockImplementation();

try {

probeGateway.mockImplementation(async (opts: { url: string }) => {

const result = defaultProbeGateway

? await defaultProbeGateway(opts)

: await mocks.probeGateway(opts);

return {

...result,

health: {

ok: true,

modelPricing: {

state: "degraded",

detail: "OpenRouter pricing fetch failed: TypeError: fetch failed",

sources: [

{

source: "openrouter",

state: "degraded",

detail: "OpenRouter pricing fetch failed: TypeError: fetch failed",

},

],

},

},

};

});

await runGatewayStatus(runtime, { timeout: "1000", json: true });

} finally {

probeGateway.mockReset();

if (defaultProbeGateway) {

probeGateway.mockImplementation(defaultProbeGateway);

}

}

expect(runtimeErrors).toHaveLength(0);

const parsed = JSON.parse(runtimeLogs.join("\n")) as {

degraded?: boolean;

warnings?: Array<{ code?: string; message?: string }>;

};

expect(parsed.degraded).toBe(true);

expect(parsed.warnings).toEqual(

expect.arrayContaining([

expect.objectContaining({

code: "model_pricing_degraded",

message:

"Model pricing degraded: OpenRouter pricing fetch failed: TypeError: fetch failed",

}),

]),

);

});

it("includes diagnostic next steps when no gateway is reachable or discoverable", async () => {

const { runtime, runtimeLogs, runtimeErrors } = createRuntimeCapture();

const defaultProbeGateway = probeGateway.getMockImplementation();

const noReachableGatewayDiagnostic =

"No gateway answered any probe and Bonjour discovery returned no local gateways. Run `openclaw gateway status --deep --require-rpc` to inspect service state, config paths, listener owners, and logs; include `ss -ltnp` or `lsof -nP -iTCP:<port> -sTCP:LISTEN` for the configured port when filing a report.";

function readModelPricingDegradedDetail(health: unknown): string | null {

if (!health || typeof health !== "object") {

return null;

}

const modelPricing = (health as { modelPricing?: unknown }).modelPricing;

if (!modelPricing || typeof modelPricing !== "object") {

return null;

}

const record = modelPricing as { state?: unknown; detail?: unknown };

if (record.state !== "degraded") {

return null;

}

return typeof record.detail === "string" && record.detail.trim()

? record.detail.trim()

: "pricing bootstrap or refresh failed";

}

export function pickPrimaryProbedTarget(probed: GatewayStatusProbedTarget[]) {

const reachable = probed.filter((entry) => isProbeReachable(entry.probe));

return (

targetIds: [result.target.id],

});

}

for (const result of reachable) {

const detail = readModelPricingDegradedDetail(result.probe.health);

if (!detail) {

continue;

}

warnings.push({

code: "model_pricing_degraded",

message: `Model pricing degraded: ${detail}`,

targetIds: [result.target.id],

});

}

return warnings;

}

primaryTargetId: string | null;

}) {

const reachable = params.probed.filter((entry) => isProbeReachable(entry.probe));

const degraded = params.probed.some((entry) => isPostConnectProbeFailure(entry.probe));

const degraded =

params.probed.some((entry) => isPostConnectProbeFailure(entry.probe)) ||

reachable.some((entry) => readModelPricingDegradedDetail(entry.probe.health));

const capability = summarizeGatewayProbeCapability(reachable.map((entry) => entry.probe));

writeRuntimeJson(params.runtime, {

ok: reachable.length > 0,

expect(gatewayRequest?.password).toBe("setup-password");

});

it("prints degraded model-pricing health without failing the command", async () => {

const snapshot = createHealthSummary({

channels: {},

channelOrder: [],

channelLabels: {},

});

snapshot.modelPricing = {

state: "degraded",

sources: [

{

source: "openrouter",

state: "degraded",

lastFailureAt: Date.now(),

detail: "OpenRouter pricing fetch failed: TypeError: fetch failed",

},

],

detail: "OpenRouter pricing fetch failed: TypeError: fetch failed",

lastFailureAt: Date.now(),

};

callGatewayMock.mockResolvedValueOnce(snapshot);

await healthCommand({ json: false, timeoutMs: 5000, config: {} }, runtime as never);

expect(runtime.exit).not.toHaveBeenCalled();

expect(stripAnsi(runtime.log.mock.calls.flat().join("\n"))).toContain(

"Model pricing: degraded (OpenRouter pricing fetch failed: TypeError: fetch failed)",

);

});

it("formats per-account probe timings", () => {

const summary = createHealthSummary({

channels: {

DEFAULT_CHANNEL_STALE_EVENT_THRESHOLD_MS,

evaluateChannelHealth,

} from "../gateway/channel-health-policy.js";

import { getGatewayModelPricingHealth } from "../gateway/model-pricing-cache-state.js";

import { isGatewayModelPricingEnabled } from "../gateway/model-pricing-config.js";

import type { ChannelRuntimeSnapshot } from "../gateway/server-channel-runtime.types.js";

import { info } from "../globals.js";

import { isTruthyEnvValue } from "../infra/env.js";

}`;

}

function formatModelPricingHealthLine(summary: HealthSummary): string | null {

const modelPricing = summary.modelPricing;

if (!modelPricing || modelPricing.state === "disabled") {

return null;

}

if (modelPricing.state === "ok") {

return null;

}

const detail = modelPricing.detail ? ` (${modelPricing.detail})` : "";

return `Model pricing: degraded${detail}`;

}

const resolveHeartbeatSummary = (cfg: OpenClawConfig, agentId: string) =>

resolveHeartbeatSummaryForAgent(cfg, agentId);

durationMs: Date.now() - start,

...(params?.eventLoop ? { eventLoop: params.eventLoop } : {}),

...(pluginHealth ? { plugins: pluginHealth } : {}),

modelPricing: getGatewayModelPricingHealth({ enabled: isGatewayModelPricingEnabled(cfg) }),

channels,

channelOrder,

channelLabels,

if (eventLoopLine) {

runtime.log(styleHealthChannelLine(eventLoopLine, rich));

}

const modelPricingLine = formatModelPricingHealthLine(summary);

if (modelPricingLine) {

runtime.log(styleHealthChannelLine(modelPricingLine, rich));

}

for (const plugin of displayPlugins) {

const channelSummary = summary.channels?.[plugin.id];

if (!channelSummary || channelSummary.linked !== true) {

errors: PluginHealthErrorSummary[];

};

export type ModelPricingHealthSummary =

import("../gateway/model-pricing-cache-state.js").GatewayModelPricingHealth;

export type HealthSummary = {

ok: true;

ts: number;

durationMs: number;

eventLoop?: import("../gateway/server/event-loop-health.js").GatewayEventLoopHealth;

plugins?: PluginHealthSummary;

modelPricing?: ModelPricingHealthSummary;

channels: Record<string, ChannelHealthSummary>;

channelOrder: string[];

channelLabels: Record<string, string>;

| {

connectLatencyMs?: number | null;

error?: string | null;

health?: unknown;

}

| null

| undefined;

self: params.gatewaySelf ?? null,

error: params.gatewayProbe?.error ?? null,

authWarning: params.gatewayProbeAuthWarning ?? null,

...(params.gatewayProbe?.health &&

typeof params.gatewayProbe.health === "object" &&

"modelPricing" in params.gatewayProbe.health

? {

modelPricing: (params.gatewayProbe.health as { modelPricing?: unknown }).modelPricing,

}

: {}),

};

}

}),

).not.toHaveProperty("securityAudit");

});

it("includes model-pricing health from the gateway probe", () => {

const payload = buildStatusJsonPayload({

summary: { ok: true },

surface: {

cfg: { gateway: {} },

update: {

root: "/tmp/openclaw",

installKind: "package",

packageManager: "npm",

} as never,

tailscaleMode: "off",

gatewayMode: "local",

remoteUrlMissing: false,

gatewayConnection: { url: "ws://127.0.0.1:18789" },

gatewayReachable: true,

gatewayProbe: {

connectLatencyMs: 42,

error: null,

health: {

ok: true,

modelPricing: {

state: "degraded",

detail: "OpenRouter pricing fetch failed: TypeError: fetch failed",

sources: [{ source: "openrouter", state: "degraded" }],

},

},

},

gatewayProbeAuth: null,

gatewaySelf: null,

gatewayProbeAuthWarning: null,

gatewayService: { label: "LaunchAgent", installed: false, loadedText: "not installed" },

nodeService: { label: "node", installed: false, loadedText: "not installed" },

},

osSummary: { platform: "linux" },

memory: null,

memoryPlugin: null,

agents: [],

secretDiagnostics: [],

});

expect(payload.gateway).toMatchObject({

modelPricing: {

state: "degraded",

detail: "OpenRouter pricing fetch failed: TypeError: fetch failed",

},

});

});

});

import type { MemoryPluginStatus, MemoryStatusSnapshot } from "./status.scan.shared.js";

import type { StatusSummary } from "./status.types.js";

function readModelPricingHealth(params: {

health?: HealthSummary;

surface: StatusOverviewSurface;

}): HealthSummary["modelPricing"] | undefined {

if (params.health?.modelPricing) {

return params.health.modelPricing;

}

const probeHealth = params.surface.gatewayProbe?.health;

if (!probeHealth || typeof probeHealth !== "object") {

return undefined;

}

const modelPricing = (probeHealth as { modelPricing?: unknown }).modelPricing;

if (!modelPricing || typeof modelPricing !== "object") {

return undefined;

}

const state = (modelPricing as { state?: unknown }).state;

if (state !== "ok" && state !== "degraded" && state !== "disabled") {

return undefined;

}

return modelPricing as HealthSummary["modelPricing"];

}

function buildModelPricingOverviewValue(params: {

health?: HealthSummary["modelPricing"];

ok: (value: string) => string;

warn: (value: string) => string;

muted: (value: string) => string;

}): string | null {

const health = params.health;

if (!health) {

return null;

}

if (health.state !== "degraded") {

return null;

}

const detail = health.detail ? ` · ${health.detail}` : "";

return params.warn(`degraded${detail}`);

}

export function buildStatusCommandOverviewRows(

params: {

opts: {

ok: params.ok,

warn: params.warn,

});

const modelPricingValue = buildModelPricingOverviewValue({

health: readModelPricingHealth({

health: params.health,

surface: params.surface,

}),

ok: params.ok,

warn: params.warn,

muted: params.muted,

});

return buildStatusOverviewRowsFromSurface({

surface: params.surface,

updateValue: params.updateValue,

agentsValue,

suffixRows: [

...(modelPricingValue ? [{ Item: "Model pricing", Value: modelPricingValue }] : []),

{ Item: "Memory", Value: memoryValue },

{ Item: "Plugin compatibility", Value: pluginCompatibilityValue },

{ Item: "Probes", Value: probesValue },

type StatusGatewayProbe = {

connectLatencyMs?: number | null;

error?: string | null;

health?: unknown;

} | null;

type StatusGatewayAuth = {