### Fixes

- Agents/Pi: suppress persistence for synthetic mid-turn overflow continuation prompts, so transcript-retry recovery does not write the "continue from transcript" prompt as a new user turn. Thanks @vincentkoc.

- Telegram: keep reply-dispatch lazy provider runtime chunks behind stable dist names and delete `/reasoning stream` previews after final delivery so package updates and live reasoning drafts do not leave Telegram turns broken or noisy. Thanks @BunsDev.

- Exec approvals: detect `env -S` split-string command-carrier risks when `-S`/`-s` is combined with other env short options, so approval explanations do not miss split payloads hidden behind `env -iS...`. Thanks @vincentkoc.

- Google Meet: log the concrete agent-mode TTS provider, model, voice, output format, and sample rate after speech synthesis, so Meet logs show which voice backend spoke each reply.

- Voice Call: mark realtime calls completed when the realtime provider closes normally, so Twilio/OpenAI/Google realtime stop events do not leave active call records behind. Thanks @vincentkoc.

Telegram-only reasoning stream:

- `/reasoning stream` sends reasoning to the live preview while generating

- the reasoning preview is deleted after final delivery; use `/reasoning on` when reasoning should remain visible

- final answer is sent without reasoning text

</Accordion>

- `/reasoning on|off|stream` controls visibility.

- Reasoning content still counts toward token usage when produced by the model.

- Telegram supports reasoning stream into the draft bubble.

- Telegram supports reasoning stream into a transient draft bubble that is deleted after final delivery; use `/reasoning on` for persistent reasoning output.

Details: [Thinking + reasoning directives](/tools/thinking) and [Token use](/reference/token-use).

- Uses `sendMessage` + `editMessageText` preview updates across DMs and group/topics.

- Sends a fresh final message instead of editing in place when a preview has been visible for about one minute, then cleans up the preview so Telegram's timestamp reflects reply completion.

- Preview streaming is skipped when Telegram block streaming is explicitly enabled (to avoid double-streaming).

- `/reasoning stream` can write reasoning to preview.

- `/reasoning stream` can write reasoning to a transient preview that is deleted after final delivery.

Discord:

);

});

it("keeps reasoning preview message when reasoning is streamed but final is answer-only", async () => {

it("clears reasoning preview message when reasoning is streamed but final is answer-only", async () => {

const { reasoningDraftStream } = setupDraftStreams({

answerMessageId: 999,

reasoningMessageId: 111,

expect(reasoningDraftStream.update).toHaveBeenCalledWith(

"Reasoning:\n_Word: strawberry. r appears at 3, 8, 9._",

);

expect(reasoningDraftStream.clear).not.toHaveBeenCalled();

expect(reasoningDraftStream.clear).toHaveBeenCalledTimes(1);

expect(editMessageTelegram).toHaveBeenCalledWith(

123,

999,

continue;

}

if (info.kind === "final") {

if (reasoningLane.hasStreamedMessage) {

activePreviewLifecycleByLane.reasoning = "complete";

retainPreviewOnCleanupByLane.reasoning = true;

}

reasoningStepState.resetForNextStep();

}

}

// gateway may resolve these only after an npm package tree replacement.

["server-close-DsVPJDIx.js", "server-close.runtime.js"],

["server-close-DvAvfgr8.js", "server-close.runtime.js"],

// v2026.5.3 beta reply-dispatch lazy chunks.

["provider-dispatcher-6EQEtc-t.js", "provider-dispatcher.js"],

["provider-dispatcher-BpL2E92x.js", "provider-dispatcher.js"],

["provider-dispatcher-JG96SkLX.js", "provider-dispatcher.js"],

];

const LEGACY_CLI_EXIT_COMPAT_CHUNKS = [

{

target: "signal:+15551234567",

channel: "signal",

},

{

field: "message",

input: "Reasoning:\n_internal plan_\n\nVisible answer",

expected: "Visible answer",

target: "telegram:123",

channel: "telegram",

},

{

field: "message",

input: "Reasoning:\n_internal plan_\n_more internal notes_",

expected: "",

target: "telegram:123",

channel: "telegram",

},

])(

"sanitizes reasoning tags in $field before sending",

async ({ channel, target, field, input, expected }) => {

function actionNeedsExplicitTarget(action: ChannelMessageActionName): boolean {

return EXPLICIT_TARGET_ACTIONS.has(action);

}

function stripFormattedReasoningMessage(text: string): string {

const stripped = stripReasoningTagsFromText(text);

const lines = stripped.split(/\r?\n/u);

if (lines[0]?.trim() !== "Reasoning:") {

return stripped;

}

let index = 1;

while (index < lines.length) {

const trimmed = lines[index]?.trim() ?? "";

if (!trimmed || (trimmed.startsWith("_") && trimmed.endsWith("_") && trimmed.length >= 2)) {

index += 1;

continue;

}

break;

}

return lines.slice(index).join("\n").trim();

}

function buildRoutingSchema() {

return {

channel: Type.Optional(Type.String()),

// in tool arguments, and the messaging tool send path has no other tag filtering.

for (const field of ["text", "content", "message", "caption"]) {

if (typeof params[field] === "string") {

params[field] = stripReasoningTagsFromText(params[field]);

params[field] = stripFormattedReasoningMessage(params[field]);

}

}

const pluginModuleLoaderJitiFactoryOverrideKey = Symbol.for(

"openclaw.pluginModuleLoaderJitiFactoryOverride",

);

const testRequire = createRequire(import.meta.url);

afterEach(() => {

for (const tempDir of tempDirs.splice(0)) {

target,

}));

const createJiti = vi.fn(() => loadWithJiti);

const sourceExtensions = [".ts", ".tsx", ".mts", ".cts"] as const;

const sourceHooks = new Map<string, NodeJS.RequireExtensions[string] | undefined>();

for (const extension of sourceExtensions) {

sourceHooks.set(extension, testRequire.extensions[extension]);

delete testRequire.extensions[extension];

}

vi.resetModules();

stubPluginModuleLoaderJitiFactory(createJiti as unknown as PluginModuleLoaderFactory);

const loaderModule = await importFreshModule<typeof import("./module-loader.js")>(

fs.mkdirSync(path.dirname(modulePath), { recursive: true });

fs.writeFileSync(modulePath, "export const ok = true;\n", "utf8");

const testRequire = createRequire(import.meta.url);

const originalTsHook = testRequire.extensions[".ts"];

delete testRequire.extensions[".ts"];

try {

expect(

loaderModule.loadChannelPluginModule({

loadedBy: "jiti",

target: fs.realpathSync.native(modulePath),

});

expect(createJiti).toHaveBeenCalledOnce();

expect(createJiti).toHaveBeenCalledWith(

expect.stringContaining("module-loader.ts"),

expect.objectContaining({ tryNative: false }),

);

expect(loadWithJiti).toHaveBeenCalledWith(fs.realpathSync.native(modulePath));

} finally {

if (originalTsHook) {

testRequire.extensions[".ts"] = originalTsHook;

for (const [extension, hook] of sourceHooks) {

if (hook) {

testRequire.extensions[extension] = hook;

} else {

delete testRequire.extensions[extension];

}

}

}

expect(createJiti).toHaveBeenCalledOnce();

expect(createJiti).toHaveBeenCalledWith(

expect.stringContaining("module-loader.ts"),

expect.objectContaining({ tryNative: false }),

);

expect(loadWithJiti).toHaveBeenCalledWith(fs.realpathSync.native(modulePath));

});

});