- Infra/json: retry transient `File changed during read` races while loading JSON state so config and state reads recover instead of failing the turn. (#84285)

- Providers/Ollama: resolve configured Ollama Cloud `OLLAMA_API_KEY` markers to the real discovery key so cloud provider entries keep authenticated model catalog access. (#85037)

- Discord: keep persistent component registry fallback warnings actionable by forwarding structured error and cause metadata through the runtime logger. Fixes #84185. (#84190) Thanks @100menotu001.

- Gateway/sessions: preserve compatible session auth profile overrides when switching models within the same provider, including provider-auth aliases. Fixes #81837. (#81886) Thanks @TurboTheTurtle.

- Gateway/status: surface inbound delivery telemetry counters and transport-liveness warnings in `openclaw status --all`. Fixes #49577. (#72724)

- Docker: prune package-excluded plugin source workspaces and dependency closures so runtime images do not keep packages for plugins that were not opted in.

try {

getOptionalDiscordRuntime()

?.logging.getChildLogger({ plugin: "discord", feature: "component-registry-state" })

.warn("Discord persistent component registry state failed", { error: String(error) });

.warn("Discord persistent component registry state failed", formatRegistryError(error));

} catch {

// Best effort only: persistent state must never break Discord interactions.

}

}

function formatRegistryError(error: unknown): Record<string, unknown> {

if (!(error instanceof Error)) {

return { error: formatRegistryErrorValue(error) };

}

const details: Record<string, unknown> = {

error: String(error),

errorName: error.name,

errorMessage: error.message,

};

if (error.stack) {

details.errorStack = error.stack;

}

const cause = (error as { cause?: unknown }).cause;

if (cause instanceof Error) {

details.errorCause = String(cause);

details.errorCauseName = cause.name;

details.errorCauseMessage = cause.message;

if (cause.stack) {

details.errorCauseStack = cause.stack;

}

} else if (cause !== undefined) {

details.errorCause = formatRegistryErrorValue(cause);

}

return details;

}

function formatRegistryErrorValue(value: unknown): string {

if (typeof value === "string") {

return value;

}

if (

typeof value === "number" ||

typeof value === "boolean" ||

typeof value === "bigint" ||

typeof value === "symbol"

) {

return String(value);

}

if (value === null) {

return "null";

}

try {

return JSON.stringify(value) ?? Object.prototype.toString.call(value);

} catch {

return Object.prototype.toString.call(value);

}

}

function disablePersistentComponentRegistry(error: unknown): void {

persistentRegistryDisabled = true;

persistentComponentStore = undefined;

it("falls back to the in-memory registry when persistent state cannot open", async () => {

const warn = vi.fn();

const cause = new TypeError("disk busy");

const { setDiscordRuntime } = await import("./runtime.js");

setDiscordRuntime({

state: {

openKeyedStore: vi.fn(() => {

throw new Error("sqlite unavailable");

const error = new Error("sqlite unavailable") as Error & { cause?: unknown };

error.cause = cause;

throw error;

}),

},

logging: { getChildLogger: () => ({ warn }) },

expect(fallbackEntry?.label).toBe("Fallback");

expect(typeof fallbackEntry?.createdAt).toBe("number");

expect(typeof fallbackEntry?.expiresAt).toBe("number");

expect(warn).toHaveBeenCalled();

expect(warn).toHaveBeenCalledWith(

"Discord persistent component registry state failed",

expect.objectContaining({

error: "Error: sqlite unavailable",

errorName: "Error",

errorMessage: "sqlite unavailable",

errorCause: "TypeError: disk busy",

errorCauseName: "TypeError",

errorCauseMessage: "disk busy",

}),

);

});

});

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

const loggingMocks = vi.hoisted(() => {

const childLogger = {

debug: vi.fn(),

info: vi.fn(),

warn: vi.fn(),

error: vi.fn(),

};

return {

childLogger,

getChildLogger: vi.fn(() => childLogger),

};

});

vi.mock("../../globals.js", () => ({

shouldLogVerbose: vi.fn(() => false),

}));

vi.mock("../../logging.js", () => ({

getChildLogger: loggingMocks.getChildLogger,

}));

let createRuntimeLogging: typeof import("./runtime-logging.js").createRuntimeLogging;

beforeEach(async () => {

vi.clearAllMocks();

loggingMocks.getChildLogger.mockReturnValue(loggingMocks.childLogger);

({ createRuntimeLogging } = await import("./runtime-logging.js"));

});

describe("createRuntimeLogging", () => {

it("forwards structured metadata to child loggers", () => {

const logging = createRuntimeLogging();

const logger = logging.getChildLogger({ plugin: "discord" }, { level: "warn" });

const meta = {

errorName: "Error",

errorCauseName: "TypeError",

};

logger.debug?.("debug details", meta);

logger.info("info details", meta);

logger.warn("warn details", meta);

logger.error("error details", meta);

expect(loggingMocks.getChildLogger).toHaveBeenCalledWith(

{ plugin: "discord" },

{ level: "warn" },

);

expect(loggingMocks.childLogger.debug).toHaveBeenCalledWith(meta, "debug details");

expect(loggingMocks.childLogger.info).toHaveBeenCalledWith(meta, "info details");

expect(loggingMocks.childLogger.warn).toHaveBeenCalledWith(meta, "warn details");

expect(loggingMocks.childLogger.error).toHaveBeenCalledWith(meta, "error details");

});

});

import { normalizeLogLevel } from "../../logging/levels.js";

import type { PluginRuntime } from "./types.js";

function writeRuntimeLog(

log: (...args: unknown[]) => void,

message: string,

meta?: Record<string, unknown>,

): void {

if (meta && Object.keys(meta).length > 0) {

log(meta, message);

return;

}

log(message);

}

export function createRuntimeLogging(): PluginRuntime["logging"] {

return {

shouldLogVerbose,

level: opts?.level ? normalizeLogLevel(opts.level) : undefined,

});

return {

debug: (message) => logger.debug?.(message),

info: (message) => logger.info(message),

warn: (message) => logger.warn(message),

error: (message) => logger.error(message),

debug: (message, meta) => {

if (logger.debug) {

writeRuntimeLog(logger.debug.bind(logger), message, meta);

}

},

info: (message, meta) => writeRuntimeLog(logger.info.bind(logger), message, meta),

warn: (message, meta) => writeRuntimeLog(logger.warn.bind(logger), message, meta),

error: (message, meta) => writeRuntimeLog(logger.error.bind(logger), message, meta),

};

},

};