- Google Meet: route stateful `google_meet` tool actions through the gateway-owned runtime so created or joined realtime sessions remain visible to status, speak, and leave after the agent turn ends. Fixes #72440. (#72441) Thanks @BsnizND.

- Google Meet/Voice Call: send Gemini Live a non-blocking consult continuation before long OpenClaw agent consults finish, then deliver the final result when idle so calls and meetings do not sit silent during tool-backed answers. (#72189) Thanks @VACInc.

- Google Meet: preserve Gemini Live function names when replying to realtime tool calls so Google SDK validation accepts the `FunctionResponse` payload. Fixes #72425. (#72426) Thanks @BsnizND.

- Discord/media: keep incidental Markdown image badges in final replies as text unless a channel opts into Markdown-image media extraction, while preserving Telegram Markdown-image media replies and explicit `MEDIA:` attachments. Fixes #72642. Thanks @solavrc and @Bartok9.

- Matrix/E2EE: stabilize recovery and broken-device QA flows while avoiding Matrix device-cleanup sync races that could leave shutdown-time crypto work running. Thanks @gumadeiras.

- Cron: apply `cron.maxConcurrentRuns` to a dedicated `cron-nested` isolated agent-turn lane as well as cron dispatch, so parallel cron jobs no longer serialize on inner LLM execution while non-cron nested flows keep their existing lane behavior. Fixes #72707. Thanks @kagura-agent.

- Cron: report isolated runs as successful when verified cron delivery already delivered the reply, while keeping unresolved Message/Canvas tool failures fatal. Fixes #72732 and #50170; follow-up to #54188. Thanks @zNatix, @pixeldyn, and @ChickenEggRoll.

loopback, link-local, private, and internal hostnames are ignored as attachment

directives; server-side media fetchers still enforce their own network guards.

Plain Markdown image syntax stays text by default. Channels that intentionally

map Markdown image replies to media attachments opt in at their outbound

adapter; Telegram does this so `` can still become a media reply.

These directives are separate. `MEDIA:` and reply/voice tags remain delivery metadata; `[embed ...]` is the web-only rich render path.

Trusted tool-result media uses the same `MEDIA:` / `[[audio_as_voice]]` parser before delivery, so text tool outputs can still mark an audio attachment as a voice note.

deliveryMode: "direct",

chunker: markdownToTelegramHtmlChunks,

chunkerMode: "markdown",

extractMarkdownImages: true,

textChunkLimit: TELEGRAM_TEXT_CHUNK_LIMIT,

sanitizeText: ({ text }) => sanitizeForPlainText(text),

shouldSkipPlainTextSanitization: ({ payload }) => Boolean(payload.channelData),

deliveryMode: "direct" as const,

chunker: chunkMarkdownText,

chunkerMode: "markdown" as const,

extractMarkdownImages: true,

textChunkLimit: 4000,

pollMaxOptions: 10,

};

it("extracts markdown image replies into final payload media urls", async () => {

const { replyPayloads } = await buildReplyPayloads({

...baseParams,

extractMarkdownImages: true,

payloads: [{ text: "Here you go\n\n" }],

});

it("preserves inline caption text when lifting markdown image replies into media", async () => {

const { replyPayloads } = await buildReplyPayloads({

...baseParams,

extractMarkdownImages: true,

payloads: [{ text: 'Look  now' }],

});

const text = "Look  now";

const { replyPayloads } = await buildReplyPayloads({

...baseParams,

extractMarkdownImages: true,

payloads: [{ text }],

});

originatingChannel?: OriginatingChannelType;

originatingTo?: string;

accountId?: string;

extractMarkdownImages?: boolean;

normalizeMediaPaths?: (payload: ReplyPayload) => Promise<ReplyPayload>;

}): Promise<{ replyPayloads: ReplyPayload[]; didLogHeartbeatStrip: boolean }> {

let didLogHeartbeatStrip = params.didLogHeartbeatStrip;

currentMessageId: params.currentMessageId,

silentToken: SILENT_REPLY_TOKEN,

parseMode: "always",

extractMarkdownImages: params.extractMarkdownImages,

});

const mediaNormalizedPayload = await normalizeReplyPayloadMedia({

payload: parsed.payload,

silentToken?: string;

trimLeadingWhitespace?: boolean;

parseMode?: ReplyDirectiveParseMode;

extractMarkdownImages?: boolean;

}): { payload: ReplyPayload; isSilent: boolean } {

const parseMode = params.parseMode ?? "always";

const silentToken = params.silentToken ?? SILENT_REPLY_TOKEN;

(parseMode === "auto" &&

(sourceText.includes("[[") ||

/media:/i.test(sourceText) ||

(params.extractMarkdownImages === true && /!\[[^\]]*]\(/.test(sourceText)) ||

sourceText.includes(silentToken)));

const parsed = shouldParse

? parseReplyDirectives(sourceText, {

currentMessageId: params.currentMessageId,

silentToken,

extractMarkdownImages: params.extractMarkdownImages,

})

: undefined;

isSilent: boolean;

};

export type ReplyDirectiveParseOptions = {

currentMessageId?: string;

silentToken?: string;

extractMarkdownImages?: boolean;

};

export function parseReplyDirectives(

raw: string,

options: { currentMessageId?: string; silentToken?: string } = {},

options: ReplyDirectiveParseOptions = {},

): ReplyDirectiveParseResult {

const split = splitMediaFromOutput(raw);

const split = splitMediaFromOutput(raw, {

extractMarkdownImages: options.extractMarkdownImages,

});

let text = split.text ?? "";

const replyParsed = parseInlineDirectives(text, {

deliveryMode: "direct" | "gateway" | "hybrid";

chunker?: ((text: string, limit: number, ctx?: ChannelOutboundChunkContext) => string[]) | null;

chunkerMode?: "text" | "markdown";

/** Lift remote Markdown image syntax in text into outbound media attachments. */

extractMarkdownImages?: boolean;

textChunkLimit?: number;

sanitizeText?: (params: { text: string; payload: ReplyPayload }) => string;

pollMaxOptions?: number;

);

});

it("keeps markdown images as text for channels that do not opt in", async () => {

const sendMatrix = vi.fn().mockResolvedValue({ messageId: "m-text", roomId: "!room" });

await deliverOutboundPayloads({

cfg: matrixChunkConfig,

channel: "matrix",

to: "!room:example",

payloads: [{ text: "Tech: " }],

deps: { matrix: sendMatrix },

});

expect(sendMatrix).toHaveBeenCalledWith(

"!room:example",

"Tech: ",

expect.not.objectContaining({ mediaUrl: expect.any(String) }),

);

});

it("extracts markdown images for channels that opt in", async () => {

const sendMatrix = vi.fn().mockResolvedValue({ messageId: "m-media", roomId: "!room" });

setActivePluginRegistry(

createTestRegistry([

{

pluginId: "matrix",

source: "test",

plugin: createOutboundTestPlugin({

id: "matrix",

outbound: { ...matrixOutboundForTest, extractMarkdownImages: true },

}),

},

]),

);

await deliverOutboundPayloads({

cfg: matrixChunkConfig,

channel: "matrix",

to: "!room:example",

payloads: [{ text: "Chart  now" }],

deps: { matrix: sendMatrix },

});

expect(sendMatrix).toHaveBeenCalledWith(

"!room:example",

"Chart now",

expect.objectContaining({ mediaUrl: "https://example.com/chart.png" }),

);

});

it("normalizes payloads and drops empty entries", () => {

const normalized = normalizeOutboundPayloads([

{ text: "hi" },