- CLI: make parser, startup, config, guardrail, channel, agent, task, session, and MCP failures explain what happened and point to the next recovery command.

- GitHub Copilot: refresh the model catalog from `${baseUrl}/models` so per-account entitlement and accurate context windows surface at runtime; static manifest catalog (now including `gpt-5.5`) remains the fallback when discovery is disabled or the API is unreachable.

- Active Memory: support concrete `plugins.entries.active-memory.config.toolsAllow` recall tool names for custom memory plugins while keeping the built-in memory-core default on `memory_search`/`memory_get` and preserving `memory_recall` automatically for `plugins.slots.memory: "memory-lancedb"`.

- Telegram: share the grammY API throttler across polling and ad hoc send clients for the same bot token, so visible draft previews and CLI sends use one quota gate. Thanks @anagnorisis2peripeteia.

- Telegram/Feishu: honor configured per-agent and global `reasoningDefault` values when deciding whether channel reasoning previews should stream or stay hidden, addressing the preview-default part of #73182. Thanks @anagnorisis2peripeteia.

- Docker: run the runtime image under `tini` so long-lived containers reap orphaned child processes and forward signals correctly. (#77885) Thanks @VintageAyu.

- Google/Gemini: normalize retired `google/gemini-3-pro-preview` and `google-gemini-cli/gemini-3-pro-preview` selections to `google/gemini-3.1-pro-preview` before they are written to model config.

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

import { clearAccountThrottlersForTest, getOrCreateAccountThrottler } from "./account-throttler.js";

describe("getOrCreateAccountThrottler", () => {

beforeEach(() => {

clearAccountThrottlersForTest();

});

it("shares throttlers per bot token", () => {

const first = getOrCreateAccountThrottler("tok");

const second = getOrCreateAccountThrottler("tok");

const other = getOrCreateAccountThrottler("other");

expect(second).toBe(first);

expect(other).not.toBe(first);

});

});

import { apiThrottler } from "./bot.runtime.js";

type ApiThrottlerTransformer = ReturnType<typeof apiThrottler>;

const throttlerByToken = new Map<string, ApiThrottlerTransformer>();

export function getOrCreateAccountThrottler(

token: string,

createThrottler: () => ApiThrottlerTransformer = apiThrottler,

): ApiThrottlerTransformer {

let throttler = throttlerByToken.get(token);

if (!throttler) {

throttler = createThrottler();

throttlerByToken.set(token, throttler);

}

return throttler;

}

export function clearAccountThrottlersForTest(): void {

throttlerByToken.clear();

}

normalizeOptionalLowercaseString,

normalizeOptionalString,

} from "openclaw/plugin-sdk/text-runtime";

import { getOrCreateAccountThrottler } from "./account-throttler.js";

import { resolveTelegramAccount } from "./accounts.js";

import { normalizeTelegramApiRoot } from "./api-root.js";

import type { TelegramBotDeps } from "./bot-deps.js";

? { ...(client ? { client } : {}), ...(opts.botInfo ? { botInfo: opts.botInfo } : {}) }

: undefined;

const bot = new botRuntime.Bot(opts.token, botConfig);

bot.api.config.use(botRuntime.apiThrottler());

bot.api.config.use(getOrCreateAccountThrottler(opts.token, botRuntime.apiThrottler));

// Catch all errors from bot middleware to prevent unhandled rejections

bot.catch((err) => {

runtime.error?.(danger(`telegram bot error: ${formatUncaughtError(err)}`));

getTelegramSequentialKey,

setTelegramBotRuntimeForTest,

} = await import("./bot-core.js");

const { clearAccountThrottlersForTest } = await import("./account-throttler.js");

const { resetTelegramForumFlagCacheForTest } = await import("./bot/helpers.js");

let createTelegramBot: (

opts: TelegramBotOptions,

});

beforeEach(() => {

resetTelegramForumFlagCacheForTest();

clearAccountThrottlersForTest();

throttlerSpy.mockReset();

setTelegramBotRuntimeForTest(

telegramBotRuntimeForTest as unknown as Parameters<typeof setTelegramBotRuntimeForTest>[0],

);

expect(useSpy).toHaveBeenCalledWith("throttler");

});

it("reuses the grammY throttler for the same token", () => {

createTelegramBot({ token: "tok" });

createTelegramBot({ token: "tok" });

createTelegramBot({ token: "other" });

expect(throttlerSpy).toHaveBeenCalledTimes(2);

expect(useSpy).toHaveBeenCalledTimes(3);

});

it("logs middleware errors through grammY catch without rethrowing", () => {

const runtime = {

error: vi.fn(),

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

import { beforeEach, vi } from "vitest";

const { botApi, botCtorSpy } = vi.hoisted(() => ({

const { botApi, botConfigUseSpy, botCtorSpy } = vi.hoisted(() => ({

botConfigUseSpy: vi.fn(),

botApi: {

deleteMessage: vi.fn(),

editForumTopic: vi.fn(),

}));

type TelegramSendTestMocks = {

botApi: Record<string, MockFn>;

botApi: typeof botApi;

botConfigUseSpy: MockFn;

botCtorSpy: MockFn;

loadConfig: MockFn;

resolveStorePath: MockFn;

ALL_UPDATE_TYPES: ["message"],

},

Bot: class {

api = botApi;

api = {

...botApi,

config: {

use: botConfigUseSpy,

},

};

catch = vi.fn();

constructor(

public token: string,

export function getTelegramSendTestMocks(): TelegramSendTestMocks {

return {

botApi,

botConfigUseSpy,

botCtorSpy,

loadConfig,

resolveStorePath,

undiciEnvHttpProxyAgentCtor.mockClear();

undiciProxyAgentCtor.mockClear();

botCtorSpy.mockReset();

botConfigUseSpy.mockReset();

for (const fn of Object.values(botApi)) {

fn.mockReset();

}

const {

botApi,

botConfigUseSpy,

botCtorSpy,

imageMetadata,

loadConfig,

);

});

it("installs the shared grammY throttler on send clients", async () => {

botApi.sendMessage.mockResolvedValue({ message_id: 1, chat: { id: "123" } });

await sendMessageTelegram("123", "hi", { cfg: TELEGRAM_TEST_CFG, token: "tok" });

expect(botConfigUseSpy).toHaveBeenCalledWith(expect.any(Function));

});

it("falls back to plain text when Telegram rejects HTML and preserves send params", async () => {

const parseErr = new Error(

"400: Bad Request: can't parse entities: Can't find end of the entity starting at byte offset 9",

import { createSubsystemLogger, logVerbose } from "openclaw/plugin-sdk/runtime-env";

import { formatErrorMessage } from "openclaw/plugin-sdk/ssrf-runtime";

import { normalizeOptionalString, redactSensitiveText } from "openclaw/plugin-sdk/text-runtime";

import { getOrCreateAccountThrottler } from "./account-throttler.js";

import { type ResolvedTelegramAccount, resolveTelegramAccount } from "./accounts.js";

import { withTelegramApiErrorLogging } from "./api-logging.js";

import { normalizeTelegramApiRoot } from "./api-root.js";

});

const token = resolveToken(opts.token, account);

const client = resolveTelegramClientOptions(account);

const api = (opts.api ?? new Bot(token, client ? { client } : undefined).api) as TelegramApi;

let api: TelegramApi;

if (opts.api) {

api = opts.api as TelegramApi;

} else {

const bot = new Bot(token, client ? { client } : undefined);

bot.api.config.use(getOrCreateAccountThrottler(token));

api = bot.api;

}

return { cfg, account, api };

}