### Changes

- WebChat/sessions: keep runtime-only prompt context out of visible transcript history and scrub legacy wrappers from session history surfaces. Thanks @91wan.

- Gradium: add a bundled text-to-speech provider with voice-note and telephony output support. (#64958) Thanks @LaurentMazare.

- Plugins/setup: honor explicit `setup.requiresRuntime: false` as a descriptor-only setup contract while keeping omitted values on the legacy setup-api fallback path. Thanks @vincentkoc.

- Plugins/setup: report descriptor/runtime drift when setup-api registrations disagree with `setup.providers` or `setup.cliBackends`, without rejecting legacy setup plugins. Thanks @vincentkoc.

Scope includes:

- Runtime-only prompt context staying out of user-visible transcript turns

- Tool call id sanitization

- Tool call input validation

- Tool result pairing repair

---

## Global rule: runtime context is not user transcript

Runtime/system context can be added to the model prompt for a turn, but it is

not end-user-authored content. OpenClaw keeps a separate transcript-facing

prompt body for Gateway replies, queued followups, ACP, CLI, and embedded Pi

runs. Stored visible user turns use that transcript body instead of the

runtime-enriched prompt.

For legacy sessions that already persisted runtime wrappers, Gateway history

surfaces apply a display projection before returning messages to WebChat,

TUI, REST, or SSE clients.

---

## Where this runs

All transcript hygiene is centralized in the embedded runner:

- The UI connects to the Gateway WebSocket and uses `chat.history`, `chat.send`, and `chat.inject`.

- `chat.history` is bounded for stability: Gateway may truncate long text fields, omit heavy metadata, and replace oversized entries with `[chat.history omitted: message too large]`.

- `chat.history` is also display-normalized: inline delivery directive tags

- `chat.history` is also display-normalized: runtime-only OpenClaw context,

inbound envelope wrappers, inline delivery directive tags

such as `[[reply_to_*]]` and `[[audio_as_voice]]`, plain-text tool-call XML

payloads (including `<tool_call>...</tool_call>`,

`<function_call>...</function_call>`, `<tool_calls>...</tool_calls>`,

throw new Error("Message (--message) is required");

}

const body = prependInternalEventContext(message, opts.internalEvents);

const transcriptBody = opts.transcriptMessage ?? message;

if (!opts.to && !opts.sessionId && !opts.sessionKey && !opts.agentId) {

throw new Error("Pass --to <E.164>, --session-id, or --agent to choose a session");

}

return {

body,

transcriptBody,

cfg,

normalizedSpawned,

agentCfg,

const prepared = await prepareAgentCommandExecution(opts, runtime);

const {

body,

transcriptBody,

cfg,

normalizedSpawned,

agentCfg,

const { resolveAcpSessionCwd } = await loadAcpSessionIdentifiersRuntime();

sessionEntry = await attemptExecutionRuntime.persistAcpTurnTranscript({

body,

transcriptBody,

finalText: finalTextRaw,

sessionId,

sessionKey,

try {

sessionEntry = await attemptExecutionRuntime.persistCliTurnTranscript({

body,

transcriptBody,

result,

sessionId,

sessionKey: sessionKey ?? sessionId,

workspaceDir: string;

config?: OpenClawConfig;

prompt: string;

transcriptPrompt?: string;

provider: string;

model?: string;

thinkLevel?: ThinkLevel;

});

});

it("persists the transcript body instead of runtime-only CLI prompt context", async () => {

const sessionKey = "agent:main:subagent:cli-transcript-clean";

const sessionEntry: SessionEntry = {

sessionId: "session-cli-transcript-clean",

updatedAt: Date.now(),

};

const sessionStore: Record<string, SessionEntry> = { [sessionKey]: sessionEntry };

await fs.writeFile(storePath, JSON.stringify(sessionStore, null, 2), "utf-8");

const updatedEntry = await persistCliTurnTranscript({

body: [

"<<<BEGIN_OPENCLAW_INTERNAL_CONTEXT>>>",

"secret runtime context",

"<<<END_OPENCLAW_INTERNAL_CONTEXT>>>",

"",

"visible ask",

].join("\n"),

transcriptBody: "visible ask",

result: makeCliResult("hello from cli"),

sessionId: sessionEntry.sessionId,

sessionKey,

sessionEntry,

sessionStore,

storePath,

sessionAgentId: "main",

sessionCwd: tmpDir,

});

const messages = await readSessionMessages(updatedEntry?.sessionFile ?? "");

expect(messages[0]).toMatchObject({

role: "user",

content: "visible ask",

});

});

it("forwards user trigger and channel context to CLI runs", async () => {

const sessionKey = "agent:main:direct:claude-channel-context";

const sessionEntry: SessionEntry = {

type PersistTextTurnTranscriptParams = {

body: string;

transcriptBody?: string;

finalText: string;

sessionId: string;

sessionKey: string;

async function persistTextTurnTranscript(

params: PersistTextTurnTranscriptParams,

): Promise<SessionEntry | undefined> {

const promptText = params.body;

const promptText = params.transcriptBody ?? params.body;

const replyText = params.finalText;

if (!promptText && !replyText) {

return params.sessionEntry;

export async function persistAcpTurnTranscript(params: {

body: string;

transcriptBody?: string;

finalText: string;

sessionId: string;

sessionKey: string;

export async function persistCliTurnTranscript(params: {

body: string;

transcriptBody?: string;

result: EmbeddedPiRunResult;

sessionId: string;

sessionKey: string;

return await persistTextTurnTranscript({

body: params.body,

transcriptBody: params.transcriptBody,

finalText: replyText,

sessionId: params.sessionId,

sessionKey: params.sessionKey,

export type AgentCommandOpts = {

message: string;

/** User-visible transcript body; defaults to message and excludes runtime-only context. */

transcriptMessage?: string;

/** Optional image attachments for multimodal messages. */

images?: ImageContent[];

/** Original inline/offloaded attachment order for inbound images. */

contextTokenBudget: ctxInfo.tokens,

skillsSnapshot: params.skillsSnapshot,

prompt,

transcriptPrompt: params.transcriptPrompt,

images: params.images,

imageOrder: params.imageOrder,

clientTools: params.clientTools,

PREEMPTIVE_OVERFLOW_ERROR_TEXT,

shouldPreemptivelyCompactBeforePrompt,

} from "./preemptive-compaction.js";

import { rewriteSubmittedPromptTranscript } from "./transcript-prompt-rewrite.js";

import type { EmbeddedRunAttemptParams, EmbeddedRunAttemptResult } from "./types.js";

export {

} else {

await abortable(activeSession.prompt(effectivePrompt));

}

rewriteSubmittedPromptTranscript({

sessionManager,

sessionFile: params.sessionFile,

previousLeafId: transcriptLeafId,

submittedPrompt: effectivePrompt,

transcriptPrompt: params.transcriptPrompt,

});

}

} catch (err) {

yieldAborted =