- ACP/gateway: preserve `AcpRuntimeError` cause chain (code/method/JSON-RPC detail) through the lifecycle boundary so gateway logs, telegram replies, and tool-result text show the actual upstream failure instead of opaque `Internal error`/`[object Object]`, with redaction applied before the chain reaches log or reply surfaces.

- Channels/iMessage: wire `action: "reply"` attachments through `imsg send-rich --file` when the installed imsg build advertises that capability (probed once via `imsg send-rich --help` and cached on the private-API status). Reply now hydrates `media`/`mediaUrl`/`fileUrl`/`mediaUrls[0]`/`filePath`/`path`/base64 `buffer`+`filename` through the shared outbound resolver, stages buffers via the existing `withTempFile` helper, rejects `http(s)://` URL attachments with a targeted error pointing callers at `send`'s full attachment-resolver pipeline, and falls back to the explicit `imsg#114 not landed yet` error on older imsg builds. Depends on the upstream `openclaw/imsg#114` capability landing in an installable release; until then the new path stays gated and users see the same explicit fallback `#79822` introduced. (#79864) Thanks @omarshahine.

- Telegram: preserve the first-preview debounce while appending true partial-stream deltas, so edited draft previews no longer duplicate earlier text when providers emit incremental output. (#80045) Thanks @TurboTheTurtle.

- Volcengine/Kimi: strip provider-unsupported tool schema length and item constraint keywords for direct and coding-plan models so hosted Kimi runs do not reject message tools with `minLength`. Fixes #38817.

## 2026.5.9

import type { ModelCompatConfig } from "openclaw/plugin-sdk/provider-model-shared";

export const VOLCENGINE_UNSUPPORTED_TOOL_SCHEMA_KEYWORDS = [

"minLength",

"maxLength",

"minItems",

"maxItems",

"minContains",

"maxContains",

] as const;

function mergeUnsupportedToolSchemaKeywords(existing: readonly string[] | undefined): string[] {

return Array.from(new Set([...(existing ?? []), ...VOLCENGINE_UNSUPPORTED_TOOL_SCHEMA_KEYWORDS]));

}

export function resolveVolcengineToolSchemaCompatPatch(

compat?: ModelCompatConfig,

): ModelCompatConfig {

return {

unsupportedToolSchemaKeywords: mergeUnsupportedToolSchemaKeywords(

compat?.unsupportedToolSchemaKeywords,

),

};

}

export function applyVolcengineToolSchemaCompat<T extends { compat?: ModelCompatConfig }>(

model: T,

): T {

const unsupportedToolSchemaKeywords = mergeUnsupportedToolSchemaKeywords(

model.compat?.unsupportedToolSchemaKeywords,

);

if (

model.compat?.unsupportedToolSchemaKeywords?.length === unsupportedToolSchemaKeywords.length &&

unsupportedToolSchemaKeywords.every(

(keyword, index) => model.compat?.unsupportedToolSchemaKeywords?.[index] === keyword,

)

) {

return model;

}

return {

...model,

compat: {

...model.compat,

unsupportedToolSchemaKeywords,

},

};

}

export { buildDoubaoCodingProvider, buildDoubaoProvider } from "./provider-catalog.js";

export {

buildDoubaoModelDefinition,

import { resolve } from "node:path";

import { registerSingleProviderPlugin } from "openclaw/plugin-sdk/plugin-test-runtime";

import { describe, expect, it } from "vitest";

import {

VOLCENGINE_UNSUPPORTED_TOOL_SCHEMA_KEYWORDS,

resolveVolcengineToolSchemaCompatPatch,

} from "./api.js";

import plugin from "./index.js";

import { DOUBAO_CODING_MODEL_CATALOG, DOUBAO_MODEL_CATALOG } from "./models.js";

"volcengine-plan": "volcengine",

});

});

it("marks direct and coding models with tool schema keyword compat", async () => {

const provider = await registerSingleProviderPlugin(plugin);

expect(provider.hookAliases).toContain("volcengine-plan");

expect(resolveVolcengineToolSchemaCompatPatch()).toEqual({

unsupportedToolSchemaKeywords: [...VOLCENGINE_UNSUPPORTED_TOOL_SCHEMA_KEYWORDS],

});

const normalized = provider.normalizeResolvedModel?.({

provider: "volcengine-plan",

modelId: "kimi-k2.5",

model: {

id: "kimi-k2.5",

provider: "volcengine-plan",

api: "openai-completions",

compat: { unsupportedToolSchemaKeywords: ["not"] },

},

} as never);

expect(normalized?.compat?.unsupportedToolSchemaKeywords).toEqual([

"not",

...VOLCENGINE_UNSUPPORTED_TOOL_SCHEMA_KEYWORDS,

]);

});

});

import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";

import { createProviderApiKeyAuthMethod } from "openclaw/plugin-sdk/provider-auth-api-key";

import { ensureModelAllowlistEntry } from "openclaw/plugin-sdk/provider-onboard";

import { applyVolcengineToolSchemaCompat } from "./api.js";

import { DOUBAO_CODING_MODEL_CATALOG, DOUBAO_MODEL_CATALOG } from "./models.js";

import { buildDoubaoCodingProvider, buildDoubaoProvider } from "./provider-catalog.js";

import { buildVolcengineSpeechProvider } from "./speech-provider.js";

label: "Volcengine",

docsPath: "/concepts/model-providers#volcano-engine-doubao",

envVars: ["VOLCANO_ENGINE_API_KEY"],

hookAliases: ["volcengine-plan"],

auth: [

createProviderApiKeyAuthMethod({

providerId: PROVIDER_ID,

}));

return [...volcengineModels, ...volcenginePlanModels];

},

normalizeResolvedModel: ({ model }) => applyVolcengineToolSchemaCompat(model),

});

api.registerSpeechProvider(buildVolcengineSpeechProvider());

},