### Fixes

- Codex harness: route native `request_user_input` prompts back to the originating chat, preserve queued follow-up answers, and honor newer app-server command approval amendment decisions.

- Agents/replay: stop OpenAI/Codex transcript replay from synthesizing missing tool results while still preserving synthetic repair on Anthropic, Gemini, and Bedrock transport-owned sessions. (#61556) Thanks @VictorJeon and @vincentkoc.

- Telegram/media replies: parse remote markdown image syntax into outbound media payloads on the final reply path, so Telegram group chats stop falling back to plain-text image URLs when the model or a tool emits `` instead of a `MEDIA:` token. (#66191) Thanks @apezam and @vincentkoc.

- Agents/WebChat: surface non-retryable provider failures such as billing, auth, and rate-limit errors from the embedded runner instead of logging `surface_error` and leaving webchat with no rendered error. Fixes #70124. (#70848) Thanks @truffle-dev.

Codex MCP tool approval elicitations are routed through OpenClaw's plugin

approval flow when Codex marks `_meta.codex_approval_kind` as

`"mcp_tool_call"`; other elicitation and free-form input requests still fail

closed.

`"mcp_tool_call"`. Codex `request_user_input` prompts are sent back to the

originating chat, and the next queued follow-up message answers that native

server request instead of being steered as extra context. Other MCP elicitation

requests still fail closed.

When the selected model uses the Codex harness, native thread compaction is

delegated to Codex app-server. OpenClaw keeps a transcript mirror for channel

);

});

it("describes command approvals from parsed command actions when available", async () => {

const params = createParams();

mockCallGatewayTool.mockResolvedValueOnce({

id: "plugin:approval-actions",

decision: "allow-once",

});

await handleCodexAppServerApprovalRequest({

method: "item/commandExecution/requestApproval",

requestParams: {

threadId: "thread-1",

turnId: "turn-1",

itemId: "cmd-actions",

command: "bash -lc 'pnpm test extensions/codex'",

commandActions: [{ command: "pnpm test extensions/codex" }],

},

paramsForRun: params,

threadId: "thread-1",

turnId: "turn-1",

});

const [, , requestPayload] = mockCallGatewayTool.mock.calls[0] ?? [];

expect(requestPayload).toEqual(

expect.objectContaining({

description: expect.stringContaining("Command: pnpm test extensions/codex"),

}),

);

expect(requestPayload).toEqual(

expect.objectContaining({

description: expect.not.stringContaining("bash -lc"),

}),

);

expect(params.onAgentEvent).toHaveBeenCalledWith(

expect.objectContaining({

stream: "approval",

data: expect.objectContaining({ command: "pnpm test extensions/codex" }),

}),

);

});

it("fails closed when no approval route is available", async () => {

const params = createParams();

mockCallGatewayTool.mockResolvedValueOnce({

).toEqual({

decision: "accept",

});

expect(

buildApprovalResponse(

"item/commandExecution/requestApproval",

{

availableDecisions: [

"accept",

{

acceptWithExecpolicyAmendment: {

execpolicy_amendment: {

permissions: [{ permission: "allow", command: ["pnpm", "test"] }],

},

},

},

],

},

"approved-session",

),

).toEqual({

decision: {

acceptWithExecpolicyAmendment: {

execpolicy_amendment: {

permissions: [{ permission: "allow", command: ["pnpm", "test"] }],

},

},

},

});

expect(

buildApprovalResponse(

"item/commandExecution/requestApproval",

{

availableDecisions: [

{

applyNetworkPolicyAmendment: {

network_policy_amendment: {

domain: "registry.npmjs.org",

},

},

},

],

},

"approved-session",

),

).toEqual({

decision: {

applyNetworkPolicyAmendment: {

network_policy_amendment: {

domain: "registry.npmjs.org",

},

},

},

});

expect(buildApprovalResponse("item/fileChange/requestApproval", undefined, "denied")).toEqual({

decision: "decline",

});

readString(params.requestParams, "itemId") ??

readString(params.requestParams, "callId") ??

readString(params.requestParams, "approvalId");

const command = readCommand(params.requestParams);

const command = readDisplayCommand(params.requestParams);

const reason = readString(params.requestParams, "reason");

const kind = approvalKindForMethod(params.method);

const permissionLines =

if (outcome === "denied" || outcome === "unavailable") {

return "decline";

}

if (outcome === "approved-session" && hasAvailableDecision(requestParams, "acceptForSession")) {

return "acceptForSession";

if (outcome === "approved-session") {

if (hasAvailableDecision(requestParams, "acceptForSession")) {

return "acceptForSession";

}

const amendmentDecision = findAvailableCommandAmendmentDecision(requestParams);

if (amendmentDecision) {

return amendmentDecision;

}

}

return "accept";

}

return available.includes(decision);

}

function findAvailableCommandAmendmentDecision(

requestParams: JsonObject | undefined,

): JsonValue | undefined {

const available = requestParams?.availableDecisions;

if (!Array.isArray(available)) {

return undefined;

}

return available.find(

(entry): entry is JsonObject =>

isJsonObject(entry) &&

(isJsonObject(entry.acceptWithExecpolicyAmendment) ||

isJsonObject(entry.applyNetworkPolicyAmendment)),

);

}

function approvalResolutionMessage(outcome: AppServerApprovalOutcome): string {

if (outcome === "approved-session") {

return "Codex app-server approval granted for the session.";

params.onAgentEvent?.({ stream: "approval", data: data as unknown as Record<string, unknown> });

}

function readDisplayCommand(record: JsonObject | undefined): string | undefined {

const actionCommand = readCommandActions(record);

if (actionCommand) {

return actionCommand;

}

return readCommand(record);

}

function readCommandActions(record: JsonObject | undefined): string | undefined {

const actions = record?.commandActions;

if (!Array.isArray(actions)) {

return undefined;

}

const commands = actions

.map((action) => (isJsonObject(action) ? readString(action, "command") : undefined))

.filter((command): command is string => Boolean(command));

return commands.length > 0 ? commands.join(" && ") : undefined;

}

function readCommand(record: JsonObject | undefined): string | undefined {

const command = record?.command;

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

await run;

});

it("routes request_user_input prompts through the active run follow-up queue", async () => {

let notify: (notification: CodexServerNotification) => Promise<void> = async () => undefined;

let handleRequest:

| ((request: { id: string; method: string; params?: unknown }) => Promise<unknown>)

| undefined;

const request = vi.fn(async (method: string) => {

if (method === "thread/start") {

return threadStartResult();

}

if (method === "turn/start") {

return turnStartResult();

}

return {};

});

__testing.setCodexAppServerClientFactoryForTests(

async () =>

({

request,

addNotificationHandler: (handler: typeof notify) => {

notify = handler;

return () => undefined;

},

addRequestHandler: (

handler: (request: {

id: string;

method: string;

params?: unknown;

}) => Promise<unknown>,

) => {

handleRequest = handler;

return () => undefined;

},

}) as never,

);

const params = createParams(

path.join(tempDir, "session.jsonl"),

path.join(tempDir, "workspace"),

);

params.onBlockReply = vi.fn();

const run = runCodexAppServerAttempt(params);

await vi.waitFor(

() => expect(request.mock.calls.some(([method]) => method === "turn/start")).toBe(true),

{ interval: 1 },

);

await vi.waitFor(() => expect(handleRequest).toBeTypeOf("function"), { interval: 1 });

const response = handleRequest?.({

id: "request-input-1",

method: "item/tool/requestUserInput",

params: {

threadId: "thread-1",

turnId: "turn-1",

itemId: "ask-1",

questions: [

{

id: "mode",

header: "Mode",

question: "Pick a mode",

isOther: false,

isSecret: false,

options: [

{ label: "Fast", description: "Use less reasoning" },

{ label: "Deep", description: "Use more reasoning" },

],

},

],

},

});

await vi.waitFor(() => expect(params.onBlockReply).toHaveBeenCalledTimes(1), { interval: 1 });

expect(queueAgentHarnessMessage("session-1", "2")).toBe(true);

await expect(response).resolves.toEqual({

answers: { mode: { answers: ["Deep"] } },

});

expect(request).not.toHaveBeenCalledWith(

"turn/steer",

expect.objectContaining({ expectedTurnId: "turn-1" }),

);

await notify({

method: "turn/completed",

params: {

threadId: "thread-1",

turnId: "turn-1",

turn: { id: "turn-1", status: "completed" },

},

});

await run;

});

it("does not leak unhandled rejections when shutdown closes before interrupt", async () => {

const unhandledRejections: unknown[] = [];

const onUnhandledRejection = (reason: unknown) => {

recordCodexTrajectoryContext,

} from "./trajectory.js";

import { mirrorCodexAppServerTranscript } from "./transcript-mirror.js";

import { createCodexUserInputBridge } from "./user-input-bridge.js";

import { filterToolsForVisionInputs } from "./vision-tools.js";

let clientFactory = defaultCodexAppServerClientFactory;

let projector: CodexAppServerEventProjector | undefined;

let turnId: string | undefined;

const pendingNotifications: CodexServerNotification[] = [];

let userInputBridge: ReturnType<typeof createCodexUserInputBridge> | undefined;

let completed = false;

let timedOut = false;

let resolveCompletion: (() => void) | undefined;

let notificationQueue: Promise<void> = Promise.resolve();

const handleNotification = async (notification: CodexServerNotification) => {

userInputBridge?.handleNotification(notification);

if (!projector || !turnId) {

pendingNotifications.push(notification);

return;

signal: runAbortController.signal,

});

}

if (request.method === "item/tool/requestUserInput") {

return userInputBridge?.handleRequest({

id: request.id,

params: request.params,

});

}

if (request.method !== "item/tool/call") {

if (isCodexAppServerApprovalRequest(request.method)) {

return handleApprovalRequest({

}

turnId = turn.turn.id;

const activeTurnId = turn.turn.id;

userInputBridge = createCodexUserInputBridge({

paramsForRun: params,

threadId: thread.threadId,

turnId: activeTurnId,

signal: runAbortController.signal,

});

trajectoryRecorder?.recordEvent("prompt.submitted", {

threadId: thread.threadId,

turnId: activeTurnId,

const handle = {

kind: "embedded" as const,

queueMessage: async (text: string) => {

if (userInputBridge?.handleQueuedMessage(text)) {

return;

}

await client.request("turn/steer", {

threadId: thread.threadId,

expectedTurnId: activeTurnId,

});

}

await trajectoryRecorder?.flush();

userInputBridge?.cancelPending();

clearTimeout(timeout);

notificationCleanup();

requestCleanup();