### Fixes

- Agents/code mode: spell out the `exec` tool's JavaScript/TypeScript, no Node module, and catalog-bridge constraints in model-visible schema text so agents can use enabled tools without trial-and-error. (#84269) Thanks @Kaspre.

- Codex: give `image_generate` dynamic-tool calls a 120s default watchdog when no per-call or configured image timeout is set, so image generation no longer falls back to the generic 30s bridge timeout. (#84254) Thanks @moritzmmayerhofer.

- CLI/message: include a stable top-level `messageId` in `openclaw message --json` output when channel sends return one. (#84191) Thanks @100menotu001.

- Gateway/agents: use an agent's `identity.name` in Gateway agent summaries when `agents.list[].name` is unset, so configured agent labels remain visible in clients. (#84355; refs #57835) Thanks @luoyanglang.

- Plugins/hooks: apply a default 30-second timeout to `before_compaction` and `after_compaction` hooks so a hung plugin handler no longer blocks compaction completion. (#84153)

- A positive per-call `timeoutMs` argument.

- For `image_generate`, `agents.defaults.imageGenerationModel.timeoutMs`.

- For `image_generate` without a configured timeout, the 120 second

image-generation default.

- For the media-understanding `image` tool, `tools.media.image.timeoutSeconds`

converted to milliseconds, or the 60 second media default.

- The 30 second dynamic-tool default.

OpenClaw-owned dynamic tool calls are bounded independently from

`appServer.requestTimeoutMs`: Codex `item/tool/call` requests use a 30 second

OpenClaw watchdog by default. A positive per-call `timeoutMs` argument extends

or shortens that specific tool budget. The `image_generate` tool also uses

or shortens that specific tool budget. The `image_generate` tool uses

`agents.defaults.imageGenerationModel.timeoutMs` when the tool call does not

provide its own timeout, and the media-understanding `image` tool uses

provide its own timeout, or a 120 second image-generation default otherwise.

The media-understanding `image` tool uses

`tools.media.image.timeoutSeconds` or its 60 second media default. Dynamic tool

budgets are capped at 600000 ms. On timeout, OpenClaw aborts the tool signal

where supported and returns a failed dynamic-tool response to Codex so the turn

backends. A per-call `timeoutMs` tool parameter overrides the configured

default. Google, OpenRouter, and xAI hosted image providers use 180 second

defaults; Azure OpenAI image generation uses 600 seconds. Codex dynamic-tool

calls honor the same timeout budget, bounded by OpenClaw's 600000 ms

dynamic-tool bridge maximum.

calls use a 120 second `image_generate` bridge default and honor the same

timeout budget when configured, bounded by OpenClaw's 600000 ms dynamic-tool

bridge maximum.

</Accordion>

<Accordion title="Inspect at runtime">

Use `action: "list"` to inspect the currently registered providers,

).toBe(180_000);

});

it("uses a 120 second default for Codex image generation dynamic tool calls", () => {

expect(

testing.resolveDynamicToolCallTimeoutMs({

call: {

threadId: "thread-1",

turnId: "turn-1",

callId: "call-image-generate-default",

namespace: null,

tool: "image_generate",

arguments: { prompt: "cat" },

},

config: undefined,

}),

).toBe(120_000);

});

it("uses the media image timeout for Codex image dynamic tool calls", () => {

expect(

testing.resolveDynamicToolCallTimeoutMs({

const CODEX_DYNAMIC_TOOL_TIMEOUT_MS = 30_000;

const CODEX_DYNAMIC_TOOL_MAX_TIMEOUT_MS = 600_000;

const CODEX_DYNAMIC_IMAGE_GENERATION_TOOL_TIMEOUT_MS = 120_000;

const CODEX_DYNAMIC_IMAGE_TOOL_TIMEOUT_MS = 60_000;

const CODEX_APP_SERVER_STARTUP_CONNECTION_CLOSE_MAX_ATTEMPTS = 3;

const CODEX_APP_SERVER_STARTUP_TIMEOUT_FLOOR_MS = 100;

if (toolName === "image_generate") {

const imageGenerationModel = config?.agents?.defaults?.imageGenerationModel;

if (!imageGenerationModel || typeof imageGenerationModel !== "object") {

return undefined;

return CODEX_DYNAMIC_IMAGE_GENERATION_TOOL_TIMEOUT_MS;

}

return readPositiveFiniteTimeoutMs(imageGenerationModel.timeoutMs);

return (

readPositiveFiniteTimeoutMs(imageGenerationModel.timeoutMs) ??

CODEX_DYNAMIC_IMAGE_GENERATION_TOOL_TIMEOUT_MS

);

}

if (toolName === "image") {

expect(timeoutMs).toBe(123_456);

});

it("uses a 120 second default for side-thread image_generate calls", () => {

const timeoutMs = testing.resolveSideDynamicToolCallTimeoutMs({

call: {

threadId: "side-thread",

turnId: "turn-1",

callId: "tool-1",

tool: "image_generate",

},

config: {} as never,

});

expect(timeoutMs).toBe(120_000);

});

it("cleans up notification handlers when side tool setup fails", async () => {

const client = createFakeClient();

createOpenClawCodingToolsMock.mockImplementation(() => {

const CODEX_SIDE_DYNAMIC_TOOL_TIMEOUT_MS = 30_000;

const CODEX_SIDE_DYNAMIC_TOOL_MAX_TIMEOUT_MS = 600_000;

const CODEX_SIDE_DYNAMIC_IMAGE_GENERATION_TOOL_TIMEOUT_MS = 120_000;

const CODEX_SIDE_DYNAMIC_IMAGE_TOOL_TIMEOUT_MS = 60_000;

const SIDE_QUESTION_COMPLETION_TIMEOUT_MS = 600_000;

const CODEX_SIDE_NATIVE_HOOK_RELAY_MIN_TTL_MS = 30 * 60_000;

const configured =

readSideDynamicToolCallTimeoutMs(params.call.arguments) ??

(params.call.tool === "image_generate"

? readSideImageGenerationModelTimeoutMs(params.config)

? (readSideImageGenerationModelTimeoutMs(params.config) ??

CODEX_SIDE_DYNAMIC_IMAGE_GENERATION_TOOL_TIMEOUT_MS)

: undefined) ??

(params.call.tool === "image"

? (readSideTimeoutSecondsAsMs(params.config?.tools?.media?.image?.timeoutSeconds) ??