- QA-Lab: wake qa-bus long polls that arrive with stale future cursors after a bus restart, preserving reconnect readiness for harness clients. (#67142) Thanks @hxy91819.

- QA-Lab: stage Multipass transfer scripts under OpenClaw's preferred temp root instead of raw OS temp paths, keeping the VM runner inside temp-path guardrails. (#64098) Thanks @ImLukeF.

- Agents/replies: keep surviving reply media and append a warning when other media references fail, so partial media normalization no longer drops failures silently. Thanks @Jerry-Xin.

- Config/models: accept `thinkingFormat: "together"` in model compat config so Together routes can opt into the Together-specific thinking response shape.

- Plugins/tokenjuice: bump the bundled tokenjuice runtime to 0.7.1, bringing Codex hook approval compatibility, pre-tool command wrapping fixes, and Rolldown/Vitest output compaction improvements into the OpenClaw plugin.

- Agents/OpenAI: stop post-processing GPT-5 final replies with hardcoded brevity caps, preserving full channel responses instead of appending synthetic ellipses, and log when strict-agentic GPT-5 execution activates. Fixes #82910.

visibleTextAlreadyDelivered?: boolean;

};

export const REPLY_MEDIA_FAILURE_WARNING = "⚠️ Media failed.";

export function appendReplyMediaFailureWarning(text: string | undefined): string {

if (!text?.trim()) {

return REPLY_MEDIA_FAILURE_WARNING;

}

if (text.includes(REPLY_MEDIA_FAILURE_WARNING)) {

return text;

}

return `${text}\n${REPLY_MEDIA_FAILURE_WARNING}`;

}

function normalizeTtsSupplementSpokenText(value: unknown): string | undefined {

return typeof value === "string" && value.trim() ? value : undefined;

}

expect(replyPayloads).toHaveLength(2);

expectFields(replyPayloads[0], {

text: "keep text",

text: "keep text\n⚠️ Media failed.",

mediaUrl: undefined,

mediaUrls: undefined,

audioAsVoice: false,

expect(replyPayloads).toHaveLength(0);

});

it("surfaces a warning when non-silent media payloads fail normalization", async () => {

const normalizeMediaPaths = async () => {

throw new Error("file not found");

};

const { replyPayloads } = await buildReplyPayloads({

...baseParams,

payloads: [{ text: "MEDIA: ./missing.png" }],

normalizeMediaPaths,

});

expect(replyPayloads).toHaveLength(1);

expectFields(replyPayloads[0], {

text: "⚠️ Media failed.",

mediaUrl: undefined,

mediaUrls: undefined,

audioAsVoice: false,

});

});

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

const { replyPayloads } = await buildReplyPayloads({

...baseParams,

import { stripLegacyBracketToolCallBlocks } from "../../shared/text/assistant-visible-text.js";

import { stripHeartbeatToken } from "../heartbeat.js";

import {

appendReplyMediaFailureWarning,

copyReplyPayloadMetadata,

getReplyPayloadMetadata,

setReplyPayloadMetadata,

async function normalizeReplyPayloadMedia(params: {

payload: ReplyPayload;

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

suppressMediaFailureWarning?: boolean;

}): Promise<ReplyPayload> {

if (!params.normalizeMediaPaths || !resolveSendableOutboundReplyParts(params.payload).hasMedia) {

return params.payload;

logVerbose(`reply payload media normalization failed: ${String(err)}`);

return copyReplyPayloadMetadata(params.payload, {

...params.payload,

text: params.suppressMediaFailureWarning

? params.payload.text

: appendReplyMediaFailureWarning(params.payload.text),

mediaUrl: undefined,

mediaUrls: undefined,

audioAsVoice: false,

const mediaNormalizedPayload = await normalizeReplyPayloadMedia({

payload: parsed.payload,

normalizeMediaPaths: params.normalizeMediaPaths,

suppressMediaFailureWarning: parsed.isSilent,

});

if (parsed.isSilent && !resolveSendableOutboundReplyParts(mediaNormalizedPayload).hasMedia) {

if (parsed.isSilent) {

mediaNormalizedPayload.text = undefined;

}

return mediaNormalizedPayload;

});

});

it("suppresses generated media-failure warning text for silent block replies", async () => {

const blockReplyPipeline = {

enqueue: vi.fn(),

} as unknown as BlockReplyPipelineLike;

const absPath = path.join("/tmp/home", "openclaw", "survived.png");

const handler = createBlockReplyDeliveryHandler({

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

normalizeStreamingText: (payload) => ({ text: payload.text, skip: false }),

applyReplyToMode: (payload) => payload,

normalizeMediaPaths: async (payload) => ({

...payload,

text: "⚠️ Media failed.",

mediaUrl: absPath,

mediaUrls: [absPath],

}),

typingSignals: {

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

} as unknown as TypingSignaler,

blockStreamingEnabled: true,

blockReplyPipeline,

directlySentBlockKeys: new Set(),

});

await handler({ text: "NO_REPLY\nMEDIA: ./missing.png\nMEDIA: ./survived.png" });

expect(blockReplyPipeline.enqueue).toHaveBeenCalledWith({

text: undefined,

mediaUrl: absPath,

mediaUrls: [absPath],

replyToId: undefined,

replyToCurrent: undefined,

replyToTag: false,

audioAsVoice: false,

});

});

it("preserves reply payload metadata across block-reply normalization", async () => {

const enqueue = vi.fn();

const blockReplyPipeline = {

const mediaNormalizedPayload = params.normalizeMediaPaths

? await params.normalizeMediaPaths(normalized.payload)

: normalized.payload;

if (normalized.isSilent) {

mediaNormalizedPayload.text = undefined;

}

const blockPayload = copyReplyPayloadMetadata(

payload,

params.applyReplyToMode(mediaNormalizedPayload),

expectNoMedia(result);

});

it("keeps surviving media and appends a warning when some reply media is dropped", async () => {

resolveOutboundAttachmentFromUrl.mockRejectedValueOnce(new Error("file not found"));

const normalize = createReplyMediaPathNormalizer({

cfg: {},

sessionKey: "session-key",

workspaceDir: "/tmp/agent-workspace",

});

const result = await normalize({

text: "Here is the surviving attachment",

mediaUrls: ["./out/missing.png", "https://example.com/ok.png"],

});

expect(result.text).toBe("Here is the surviving attachment\n⚠️ Media failed.");

expectMedia(result, "https://example.com/ok.png", ["https://example.com/ok.png"]);

});

it("returns a warning-only text reply when media-only output is dropped upstream", async () => {

resolveOutboundAttachmentFromUrl.mockRejectedValueOnce(new Error("file not found"));

const normalize = createReplyMediaPathNormalizer({

import { resolveOutboundAttachmentFromUrl } from "../../media/outbound-attachment.js";

import { resolveAgentScopedOutboundMediaAccess } from "../../media/read-capability.js";

import { MEDIA_MAX_BYTES } from "../../media/store.js";

import { appendReplyMediaFailureWarning } from "../reply-payload.js";

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

const FILE_URL_RE = /^file:\/\//i;

: MEDIA_MAX_BYTES;

}

function formatBlockedReplyMediaWarning(): string {

return "⚠️ Media failed.";

}

export function createReplyMediaPathNormalizer(params: {

cfg: OpenClawConfig;

sessionKey?: string;

normalizedMedia.push(normalized);

}

const text =

firstMediaDropError === undefined

? payload.text

: appendReplyMediaFailureWarning(payload.text);

if (normalizedMedia.length === 0) {

const warning = firstMediaDropError ? formatBlockedReplyMediaWarning() : undefined;

return {

...payload,

text: warning ? (payload.text ? `${payload.text}\n${warning}` : warning) : payload.text,

text,

mediaUrl: undefined,

mediaUrls: undefined,

};

}

return {

...payload,

text,

mediaUrl: normalizedMedia[0],

mediaUrls: normalizedMedia,

};