Ayuriel/openclaw
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Telegram: stabilize pairing/session/forum routing and reply formatting tests (#50155)

Browse Source 
* Telegram: stabilize Area 2 DM and model callbacks

* Telegram: fix dispatch test deps wiring

* Telegram: stabilize area2 test harness and gate flaky sticker e2e

* Telegram: address review feedback on config reload and tests

* Telegram tests: use plugin-sdk reply dispatcher import

* Telegram tests: add routing reload regression and track sticker skips

* Telegram: add polling-session backoff regression test

* Telegram tests: mock loadWebMedia through plugin-sdk path

* Telegram: refresh native and callback routing config

* Telegram tests: fix compact callback config typing
This commit is contained in:
Josh Avant 2026-03-19 00:01:14 -05:00 committed by GitHub
parent 53a34c39f6
commit 68bc6effc0
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
27 changed files with 860 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@ -135,6 +135,7 @@ Docs: https://docs.openclaw.ai
- Tests/OpenAI Codex auth: align login expectations with the default `gpt-5.4` model so CI coverage stays consistent with the current OpenAI Codex default. (#44367) Thanks @jrrcdev.
- Discord: enforce strict DM component allowlist auth (#49997) Thanks @joshavant.
- Stabilize plugin loader and Docker extension smoke (#50058) Thanks @joshavant.
- Telegram: stabilize pairing/session/forum routing and reply formatting tests (#50155) Thanks @joshavant.
### Fixes

10
extensions/telegram/src/bot-deps.ts
View File

@ -1,7 +1,9 @@
import { loadConfig, resolveStorePath } from "openclaw/plugin-sdk/config-runtime";
import { readChannelAllowFromStore } from "openclaw/plugin-sdk/conversation-runtime";
import { upsertChannelPairingRequest } from "openclaw/plugin-sdk/conversation-runtime";
import { enqueueSystemEvent } from "openclaw/plugin-sdk/infra-runtime";
import {
buildModelsProviderData,
dispatchReplyWithBufferedBlockDispatcher,
listSkillCommandsForAgents,
} from "openclaw/plugin-sdk/reply-runtime";
@ -11,8 +13,10 @@ export type TelegramBotDeps = {
loadConfig: typeof loadConfig;
resolveStorePath: typeof resolveStorePath;
readChannelAllowFromStore: typeof readChannelAllowFromStore;
upsertChannelPairingRequest: typeof upsertChannelPairingRequest;
enqueueSystemEvent: typeof enqueueSystemEvent;
dispatchReplyWithBufferedBlockDispatcher: typeof dispatchReplyWithBufferedBlockDispatcher;
buildModelsProviderData: typeof buildModelsProviderData;
listSkillCommandsForAgents: typeof listSkillCommandsForAgents;
wasSentByBot: typeof wasSentByBot;
};
@ -27,12 +31,18 @@ export const defaultTelegramBotDeps: TelegramBotDeps = {
get readChannelAllowFromStore() {
return readChannelAllowFromStore;
},
get upsertChannelPairingRequest() {
return upsertChannelPairingRequest;
},
get enqueueSystemEvent() {
return enqueueSystemEvent;
},
get dispatchReplyWithBufferedBlockDispatcher() {
return dispatchReplyWithBufferedBlockDispatcher;
},
get buildModelsProviderData() {
return buildModelsProviderData;
},
get listSkillCommandsForAgents() {
return listSkillCommandsForAgents;
},

32
extensions/telegram/src/bot-handlers.runtime.ts
View File

@ -27,10 +27,7 @@ import {
resolveInboundDebounceMs,
} from "openclaw/plugin-sdk/reply-runtime";
import { buildCommandsPaginationKeyboard } from "openclaw/plugin-sdk/reply-runtime";
import {
buildModelsProviderData,
formatModelsAvailableHeader,
} from "openclaw/plugin-sdk/reply-runtime";
import { formatModelsAvailableHeader } from "openclaw/plugin-sdk/reply-runtime";
import { resolveStoredModelOverride } from "openclaw/plugin-sdk/reply-runtime";
import { buildCommandsMessagePaginated } from "openclaw/plugin-sdk/reply-runtime";
import { resolveAgentRoute } from "openclaw/plugin-sdk/routing";
@ -280,6 +277,7 @@ export const registerTelegramHandlers = ({
sessionKey: string;
model?: string;
} => {
const runtimeCfg = telegramDeps.loadConfig();
const resolvedThreadId =
params.resolvedThreadId ??
resolveTelegramForumThreadId({
@ -290,7 +288,7 @@ export const registerTelegramHandlers = ({
const topicThreadId = resolvedThreadId ?? dmThreadId;
const { topicConfig } = resolveTelegramGroupConfig(params.chatId, topicThreadId);
const { route } = resolveTelegramConversationRoute({
cfg,
cfg: runtimeCfg,
accountId,
chatId: params.chatId,
isGroup: params.isGroup,
@ -300,7 +298,7 @@ export const registerTelegramHandlers = ({
topicAgentId: topicConfig?.agentId,
});
const baseSessionKey = resolveTelegramConversationBaseSessionKey({
cfg,
cfg: runtimeCfg,
route,
chatId: params.chatId,
isGroup: params.isGroup,
@ -311,7 +309,7 @@ export const registerTelegramHandlers = ({
? resolveThreadSessionKeys({ baseSessionKey, threadId: `${params.chatId}:${dmThreadId}` })
: null;
const sessionKey = threadKeys?.sessionKey ?? baseSessionKey;
const storePath = telegramDeps.resolveStorePath(cfg.session?.store, {
const storePath = telegramDeps.resolveStorePath(runtimeCfg.session?.store, {
agentId: route.agentId,
});
const store = loadSessionStore(storePath);
@ -341,7 +339,7 @@ export const registerTelegramHandlers = ({
model: `${provider}/${model}`,
};
}
const modelCfg = cfg.agents?.defaults?.model;
const modelCfg = runtimeCfg.agents?.defaults?.model;
return {
agentId: route.agentId,
sessionEntry: entry,
@ -645,6 +643,7 @@ export const registerTelegramHandlers = ({
isForum: params.isForum,
messageThreadId: params.messageThreadId,
groupAllowFrom,
readChannelAllowFromStore: telegramDeps.readChannelAllowFromStore,
resolveTelegramGroupConfig,
}));
// Use direct config dmPolicy override if available for DMs
@ -1265,10 +1264,11 @@ export const registerTelegramHandlers = ({
return;
}
const runtimeCfg = telegramDeps.loadConfig();
if (isApprovalCallback) {
if (
!isTelegramExecApprovalClientEnabled({ cfg, accountId }) ||
!isTelegramExecApprovalApprover({ cfg, accountId, senderId })
!isTelegramExecApprovalClientEnabled({ cfg: runtimeCfg, accountId }) ||
!isTelegramExecApprovalApprover({ cfg: runtimeCfg, accountId, senderId })
) {
logVerbose(
`Blocked telegram exec approval callback from ${senderId || "unknown"} (not an approver)`,
@ -1300,12 +1300,12 @@ export const registerTelegramHandlers = ({
return;
}
const agentId = paginationMatch[2]?.trim() || resolveDefaultAgentId(cfg);
const agentId = paginationMatch[2]?.trim() || resolveDefaultAgentId(runtimeCfg);
const skillCommands = telegramDeps.listSkillCommandsForAgents({
cfg,
cfg: runtimeCfg,
agentIds: [agentId],
});
const result = buildCommandsMessagePaginated(cfg, skillCommands, {
const result = buildCommandsMessagePaginated(runtimeCfg, skillCommands, {
page,
surface: "telegram",
});
@ -1339,7 +1339,10 @@ export const registerTelegramHandlers = ({
resolvedThreadId,
senderId,
});
const modelData = await buildModelsProviderData(cfg, sessionState.agentId);
const modelData = await telegramDeps.buildModelsProviderData(
runtimeCfg,
sessionState.agentId,
);
const { byProvider, providers } = modelData;
const editMessageWithButtons = async (
@ -1645,6 +1648,7 @@ export const registerTelegramHandlers = ({
accountId,
bot,
logger,
upsertPairingRequest: telegramDeps.upsertChannelPairingRequest,
});
if (!dmAuthorized) {
return;

5
extensions/telegram/src/bot-message-context.ts
View File

@ -55,6 +55,8 @@ export const buildTelegramMessageContext = async ({
resolveGroupActivation,
resolveGroupRequireMention,
resolveTelegramGroupConfig,
loadFreshConfig,
upsertPairingRequest,
sendChatActionHandler,
}: BuildTelegramMessageContextParams) => {
const msg = primaryCtx.message;
@ -79,7 +81,7 @@ export const buildTelegramMessageContext = async ({
? (groupConfig.dmPolicy ?? dmPolicy)
: dmPolicy;
// Fresh config for bindings lookup; other routing inputs are payload-derived.
const freshCfg = loadConfig();
const freshCfg = (loadFreshConfig ?? loadConfig)();
let { route, configuredBinding, configuredBindingSessionKey } = resolveTelegramConversationRoute({
cfg: freshCfg,
accountId: account.accountId,
@ -193,6 +195,7 @@ export const buildTelegramMessageContext = async ({
accountId: account.accountId,
bot,
logger,
upsertPairingRequest,
}))
) {
return null;

2
extensions/telegram/src/bot-message-context.types.ts
View File

@ -60,6 +60,8 @@ export type BuildTelegramMessageContextParams = {
resolveGroupActivation: ResolveGroupActivation;
resolveGroupRequireMention: ResolveGroupRequireMention;
resolveTelegramGroupConfig: ResolveTelegramGroupConfig;
loadFreshConfig?: () => OpenClawConfig;
upsertPairingRequest?: typeof import("openclaw/plugin-sdk/conversation-runtime").upsertChannelPairingRequest;
/** Global (per-account) handler for sendChatAction 401 backoff (#27092). */
sendChatActionHandler: import("./sendchataction-401-backoff.js").TelegramSendChatActionHandler;
};

82
extensions/telegram/src/bot-message-dispatch.test.ts
View File

@ -2,6 +2,7 @@ import path from "node:path";
import type { Bot } from "grammy";
import { beforeEach, describe, expect, it, vi } from "vitest";
import { STATE_DIR } from "../../../src/config/paths.js";
import type { TelegramBotDeps } from "./bot-deps.js";
import {
createSequencedTestDraftStream,
createTestDraftStream,
@ -10,7 +11,32 @@ import {
const createTelegramDraftStream = vi.hoisted(() => vi.fn());
const dispatchReplyWithBufferedBlockDispatcher = vi.hoisted(() => vi.fn());
const deliverReplies = vi.hoisted(() => vi.fn());
const createForumTopicTelegram = vi.hoisted(() => vi.fn());
const deleteMessageTelegram = vi.hoisted(() => vi.fn());
const editForumTopicTelegram = vi.hoisted(() => vi.fn());
const editMessageTelegram = vi.hoisted(() => vi.fn());
const reactMessageTelegram = vi.hoisted(() => vi.fn());
const sendMessageTelegram = vi.hoisted(() => vi.fn());
const sendPollTelegram = vi.hoisted(() => vi.fn());
const sendStickerTelegram = vi.hoisted(() => vi.fn());
const loadConfig = vi.hoisted(() => vi.fn(() => ({})));
const readChannelAllowFromStore = vi.hoisted(() => vi.fn(async () => []));
const upsertChannelPairingRequest = vi.hoisted(() =>
vi.fn(async () => ({
code: "PAIRCODE",
created: true,
})),
);
const enqueueSystemEvent = vi.hoisted(() => vi.fn());
const buildModelsProviderData = vi.hoisted(() =>
vi.fn(async () => ({
byProvider: new Map<string, Set<string>>(),
providers: [],
resolvedDefault: { provider: "openai", model: "gpt-test" },
})),
);
const listSkillCommandsForAgents = vi.hoisted(() => vi.fn(() => []));
const wasSentByBot = vi.hoisted(() => vi.fn(() => false));
const loadSessionStore = vi.hoisted(() => vi.fn());
const resolveStorePath = vi.hoisted(() => vi.fn(() => "/tmp/sessions.json"));
@ -18,29 +44,26 @@ vi.mock("./draft-stream.js", () => ({
createTelegramDraftStream,
}));
vi.mock("../../../src/auto-reply/reply/provider-dispatcher.js", () => ({
dispatchReplyWithBufferedBlockDispatcher,
}));
vi.mock("./bot/delivery.js", () => ({
deliverReplies,
}));
vi.mock("./send.js", () => ({
createForumTopicTelegram: vi.fn(),
deleteMessageTelegram: vi.fn(),
editForumTopicTelegram: vi.fn(),
createForumTopicTelegram,
deleteMessageTelegram,
editForumTopicTelegram,
editMessageTelegram,
reactMessageTelegram: vi.fn(),
sendMessageTelegram: vi.fn(),
sendPollTelegram: vi.fn(),
sendStickerTelegram: vi.fn(),
reactMessageTelegram,
sendMessageTelegram,
sendPollTelegram,
sendStickerTelegram,
}));
vi.mock("openclaw/plugin-sdk/config-runtime", async (importOriginal) => {
const actual = await importOriginal<typeof import("openclaw/plugin-sdk/config-runtime")>();
return {
...actual,
loadConfig,
loadSessionStore,
resolveStorePath,
};
@ -57,6 +80,22 @@ vi.mock("./sticker-cache.js", () => ({
import { dispatchTelegramMessage } from "./bot-message-dispatch.js";
const telegramDepsForTest: TelegramBotDeps = {
loadConfig: loadConfig as TelegramBotDeps["loadConfig"],
resolveStorePath: resolveStorePath as TelegramBotDeps["resolveStorePath"],
readChannelAllowFromStore:
readChannelAllowFromStore as TelegramBotDeps["readChannelAllowFromStore"],
upsertChannelPairingRequest:
upsertChannelPairingRequest as TelegramBotDeps["upsertChannelPairingRequest"],
enqueueSystemEvent: enqueueSystemEvent as TelegramBotDeps["enqueueSystemEvent"],
dispatchReplyWithBufferedBlockDispatcher:
dispatchReplyWithBufferedBlockDispatcher as TelegramBotDeps["dispatchReplyWithBufferedBlockDispatcher"],
buildModelsProviderData: buildModelsProviderData as TelegramBotDeps["buildModelsProviderData"],
listSkillCommandsForAgents:
listSkillCommandsForAgents as TelegramBotDeps["listSkillCommandsForAgents"],
wasSentByBot: wasSentByBot as TelegramBotDeps["wasSentByBot"],
};
describe("dispatchTelegramMessage draft streaming", () => {
type TelegramMessageContext = Parameters<typeof dispatchTelegramMessage>[0]["context"];
@ -64,9 +103,28 @@ describe("dispatchTelegramMessage draft streaming", () => {
createTelegramDraftStream.mockClear();
dispatchReplyWithBufferedBlockDispatcher.mockClear();
deliverReplies.mockClear();
createForumTopicTelegram.mockClear();
deleteMessageTelegram.mockClear();
editForumTopicTelegram.mockClear();
editMessageTelegram.mockClear();
reactMessageTelegram.mockClear();
sendMessageTelegram.mockClear();
sendPollTelegram.mockClear();
sendStickerTelegram.mockClear();
loadConfig.mockClear();
readChannelAllowFromStore.mockClear();
upsertChannelPairingRequest.mockClear();
enqueueSystemEvent.mockClear();
buildModelsProviderData.mockClear();
listSkillCommandsForAgents.mockClear();
wasSentByBot.mockClear();
loadSessionStore.mockClear();
resolveStorePath.mockClear();
loadConfig.mockReturnValue({});
dispatchReplyWithBufferedBlockDispatcher.mockResolvedValue({
queuedFinal: false,
counts: { block: 0, final: 0, tool: 0 },
});
resolveStorePath.mockReturnValue("/tmp/sessions.json");
loadSessionStore.mockReturnValue({});
});
@ -154,6 +212,7 @@ describe("dispatchTelegramMessage draft streaming", () => {
cfg?: Parameters<typeof dispatchTelegramMessage>[0]["cfg"];
telegramCfg?: Parameters<typeof dispatchTelegramMessage>[0]["telegramCfg"];
streamMode?: Parameters<typeof dispatchTelegramMessage>[0]["streamMode"];
telegramDeps?: TelegramBotDeps;
bot?: Bot;
}) {
const bot = params.bot ?? createBot();
@ -166,6 +225,7 @@ describe("dispatchTelegramMessage draft streaming", () => {
streamMode: params.streamMode ?? "partial",
textLimit: 4096,
telegramCfg: params.telegramCfg ?? {},
telegramDeps: params.telegramDeps ?? telegramDepsForTest,
opts: { token: "token" },
});
}

10
extensions/telegram/src/bot-message.test.ts
View File

@ -1,7 +1,11 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { TelegramBotDeps } from "./bot-deps.js";
const buildTelegramMessageContext = vi.hoisted(() => vi.fn());
const dispatchTelegramMessage = vi.hoisted(() => vi.fn());
const upsertChannelPairingRequest = vi.hoisted(() =>
vi.fn(async () => ({ code: "PAIRCODE", created: true })),
);
vi.mock("./bot-message-context.js", () => ({
buildTelegramMessageContext,
@ -17,8 +21,13 @@ describe("telegram bot message processor", () => {
beforeEach(() => {
buildTelegramMessageContext.mockClear();
dispatchTelegramMessage.mockClear();
upsertChannelPairingRequest.mockClear();
});
const telegramDepsForTest = {
upsertChannelPairingRequest,
} as unknown as TelegramBotDeps;
const baseDeps = {
bot: {},
cfg: {},
@ -38,6 +47,7 @@ describe("telegram bot message processor", () => {
replyToMode: "auto",
streamMode: "partial",
textLimit: 4096,
telegramDeps: telegramDepsForTest,
opts: {},
} as unknown as Parameters<typeof createTelegramMessageProcessor>[0];

3
extensions/telegram/src/bot-message.ts
View File

@ -42,6 +42,7 @@ export const createTelegramMessageProcessor = (deps: TelegramMessageProcessorDep
resolveGroupActivation,
resolveGroupRequireMention,
resolveTelegramGroupConfig,
loadFreshConfig,
sendChatActionHandler,
runtime,
replyToMode,
@ -78,6 +79,8 @@ export const createTelegramMessageProcessor = (deps: TelegramMessageProcessorDep
resolveGroupRequireMention,
resolveTelegramGroupConfig,
sendChatActionHandler,
loadFreshConfig,
upsertPairingRequest: telegramDeps.upsertChannelPairingRequest,
});
if (!context) {
return;

8
extensions/telegram/src/bot-native-commands.group-auth.test.ts
View File

@ -99,15 +99,17 @@ describe("native command auth in groups", () => {
it("keeps groupPolicy disabled enforced when commands.allowFrom is configured", async () => {
const { handlers, sendMessage } = setup({
cfg: {
channels: {
telegram: {
groupPolicy: "disabled",
},
},
commands: {
allowFrom: {
telegram: ["12345"],
},
},
} as OpenClawConfig,
telegramCfg: {
groupPolicy: "disabled",
} as TelegramAccountConfig,
useAccessGroups: true,
resolveGroupPolicy: () =>
({

9
extensions/telegram/src/bot-native-commands.menu-test-support.ts
View File

@ -96,10 +96,19 @@ export function createNativeCommandTestParams(
readChannelAllowFromStore: vi.fn(
async () => [],
) as TelegramBotDeps["readChannelAllowFromStore"],
upsertChannelPairingRequest: vi.fn(async () => ({
code: "PAIRCODE",
created: true,
})) as TelegramBotDeps["upsertChannelPairingRequest"],
enqueueSystemEvent: vi.fn() as TelegramBotDeps["enqueueSystemEvent"],
dispatchReplyWithBufferedBlockDispatcher: vi.fn(
async () => dispatchResult,
) as TelegramBotDeps["dispatchReplyWithBufferedBlockDispatcher"],
buildModelsProviderData: vi.fn(async () => ({
byProvider: new Map<string, Set<string>>(),
providers: [],
resolvedDefault: { provider: "openai", model: "gpt-4.1" },
})) as TelegramBotDeps["buildModelsProviderData"],
listSkillCommandsForAgents,
wasSentByBot: vi.fn(() => false) as TelegramBotDeps["wasSentByBot"],
};

20
extensions/telegram/src/bot-native-commands.session-meta.test.ts
View File

@ -62,6 +62,10 @@ const sessionBindingMocks = vi.hoisted(() => ({
>(() => null),
touch: vi.fn(),
}));
const conversationStoreMocks = vi.hoisted(() => ({
readChannelAllowFromStore: vi.fn(async () => []),
upsertChannelPairingRequest: vi.fn(async () => ({ code: "PAIRCODE", created: true })),
}));
vi.mock("openclaw/plugin-sdk/conversation-runtime", async (importOriginal) => {
const actual = await importOriginal<typeof import("openclaw/plugin-sdk/conversation-runtime")>();
@ -69,6 +73,8 @@ vi.mock("openclaw/plugin-sdk/conversation-runtime", async (importOriginal) => {
...actual,
resolveConfiguredBindingRoute: persistentBindingMocks.resolveConfiguredBindingRoute,
ensureConfiguredBindingRouteReady: persistentBindingMocks.ensureConfiguredBindingRouteReady,
readChannelAllowFromStore: conversationStoreMocks.readChannelAllowFromStore,
upsertChannelPairingRequest: conversationStoreMocks.upsertChannelPairingRequest,
getSessionBindingService: () => ({
bind: vi.fn(),
getCapabilities: vi.fn(),
@ -194,9 +200,15 @@ function registerAndResolveCommandHandlerBase(params: {
loadConfig: vi.fn(() => cfg),
resolveStorePath: sessionMocks.resolveStorePath as TelegramBotDeps["resolveStorePath"],
readChannelAllowFromStore: vi.fn(async () => []),
upsertChannelPairingRequest: vi.fn(async () => ({ code: "PAIRCODE", created: true })),
enqueueSystemEvent: vi.fn(),
dispatchReplyWithBufferedBlockDispatcher:
replyMocks.dispatchReplyWithBufferedBlockDispatcher as TelegramBotDeps["dispatchReplyWithBufferedBlockDispatcher"],
buildModelsProviderData: vi.fn(async () => ({
byProvider: new Map<string, Set<string>>(),
providers: [],
resolvedDefault: { provider: "openai", model: "gpt-4.1" },
})),
listSkillCommandsForAgents: vi.fn(() => []),
wasSentByBot: vi.fn(() => false),
};
@ -512,7 +524,13 @@ describe("registerTelegramNativeCommands — session metadata", () => {
);
const { handler } = registerAndResolveStatusHandler({
cfg: {},
cfg: {
channels: {
telegram: {
silentErrorReplies: true,
},
},
},
telegramCfg: { silentErrorReplies: true },
});
await handler(createTelegramPrivateCommandContext());

6
extensions/telegram/src/bot-native-commands.test-helpers.ts
View File

@ -123,9 +123,15 @@ export function createNativeCommandsHarness(params?: {
loadConfig: vi.fn(() => params?.cfg ?? ({} as OpenClawConfig)),
resolveStorePath: vi.fn((storePath?: string) => storePath ?? "/tmp/sessions.json"),
readChannelAllowFromStore: vi.fn(async () => []),
upsertChannelPairingRequest: vi.fn(async () => ({ code: "PAIRCODE", created: true })),
enqueueSystemEvent: vi.fn(),
dispatchReplyWithBufferedBlockDispatcher:
replyPipelineMocks.dispatchReplyWithBufferedBlockDispatcher,
buildModelsProviderData: vi.fn(async () => ({
byProvider: new Map<string, Set<string>>(),
providers: [],
resolvedDefault: { provider: "openai", model: "gpt-4.1" },
})),
listSkillCommandsForAgents: vi.fn(() => []),
wasSentByBot: vi.fn(() => false),
};

43
extensions/telegram/src/bot-native-commands.test.ts
View File

@ -48,17 +48,26 @@ function createNativeCommandTestParams(
counts: { block: 0, final: 0, tool: 0 },
};
const telegramDeps: TelegramBotDeps = {
loadConfig: vi.fn(() => ({}) as OpenClawConfig) as TelegramBotDeps["loadConfig"],
loadConfig: vi.fn(() => cfg) as TelegramBotDeps["loadConfig"],
resolveStorePath: vi.fn(
(storePath?: string) => storePath ?? "/tmp/sessions.json",
) as TelegramBotDeps["resolveStorePath"],
readChannelAllowFromStore: vi.fn(
async () => [],
) as TelegramBotDeps["readChannelAllowFromStore"],
upsertChannelPairingRequest: vi.fn(async () => ({
code: "PAIRCODE",
created: true,
})) as TelegramBotDeps["upsertChannelPairingRequest"],
enqueueSystemEvent: vi.fn() as TelegramBotDeps["enqueueSystemEvent"],
dispatchReplyWithBufferedBlockDispatcher: vi.fn(
async () => dispatchResult,
) as TelegramBotDeps["dispatchReplyWithBufferedBlockDispatcher"],
buildModelsProviderData: vi.fn(async () => ({
byProvider: new Map<string, Set<string>>(),
providers: [],
resolvedDefault: { provider: "openai", model: "gpt-4.1" },
})) as TelegramBotDeps["buildModelsProviderData"],
listSkillCommandsForAgents: skillCommandMocks.listSkillCommandsForAgents,
wasSentByBot: vi.fn(() => false) as TelegramBotDeps["wasSentByBot"],
};
@ -264,6 +273,13 @@ describe("registerTelegramNativeCommands", () => {
it("sends plugin command error replies silently when silentErrorReplies is enabled", async () => {
const commandHandlers = new Map<string, (ctx: unknown) => Promise<void>>();
const cfg: OpenClawConfig = {
channels: {
telegram: {
silentErrorReplies: true,
},
},
};
pluginCommandMocks.getPluginCommandSpecs.mockReturnValue([
{
@ -281,20 +297,17 @@ describe("registerTelegramNativeCommands", () => {
} as never);
registerTelegramNativeCommands({
...createNativeCommandTestParams(
{},
{
bot: {
api: {
setMyCommands: vi.fn().mockResolvedValue(undefined),
sendMessage: vi.fn().mockResolvedValue(undefined),
},
command: vi.fn((name: string, cb: (ctx: unknown) => Promise<void>) => {
commandHandlers.set(name, cb);
}),
} as unknown as Parameters<typeof registerTelegramNativeCommands>[0]["bot"],
},
),
...createNativeCommandTestParams(cfg, {
bot: {
api: {
setMyCommands: vi.fn().mockResolvedValue(undefined),
sendMessage: vi.fn().mockResolvedValue(undefined),
},
command: vi.fn((name: string, cb: (ctx: unknown) => Promise<void>) => {
commandHandlers.set(name, cb);
}),
} as unknown as Parameters<typeof registerTelegramNativeCommands>[0]["bot"],
}),
telegramCfg: { silentErrorReplies: true } as TelegramAccountConfig,
});

78
extensions/telegram/src/bot-native-commands.ts
View File

@ -42,6 +42,7 @@ import { resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
import { danger, logVerbose } from "openclaw/plugin-sdk/runtime-env";
import { getChildLogger } from "openclaw/plugin-sdk/runtime-env";
import type { RuntimeEnv } from "openclaw/plugin-sdk/runtime-env";
import { resolveTelegramAccount } from "./accounts.js";
import { withTelegramApiErrorLogging } from "./api-logging.js";
import { isSenderAllowed, normalizeDmAllowFromWithStore } from "./bot-access.js";
import { defaultTelegramBotDeps, type TelegramBotDeps } from "./bot-deps.js";
@ -152,6 +153,7 @@ async function resolveTelegramCommandAuth(params: {
cfg: OpenClawConfig;
accountId: string;
telegramCfg: TelegramAccountConfig;
readChannelAllowFromStore: TelegramBotDeps["readChannelAllowFromStore"];
allowFrom?: Array<string | number>;
groupAllowFrom?: Array<string | number>;
useAccessGroups: boolean;
@ -168,6 +170,7 @@ async function resolveTelegramCommandAuth(params: {
cfg,
accountId,
telegramCfg,
readChannelAllowFromStore,
allowFrom,
groupAllowFrom,
useAccessGroups,
@ -192,6 +195,7 @@ async function resolveTelegramCommandAuth(params: {
isForum,
messageThreadId,
groupAllowFrom,
readChannelAllowFromStore,
resolveTelegramGroupConfig,
});
const {
@ -368,7 +372,6 @@ export const registerTelegramNativeCommands = ({
telegramDeps = defaultTelegramBotDeps,
opts,
}: RegisterTelegramNativeCommandsParams) => {
const silentErrorReplies = telegramCfg.silentErrorReplies === true;
const boundRoute =
nativeEnabled && nativeSkillsEnabled
? resolveAgentRoute({ cfg, channel: "telegram", accountId })
@ -419,6 +422,20 @@ export const registerTelegramNativeCommands = ({
for (const issue of pluginCatalog.issues) {
runtime.error?.(danger(issue));
}
const loadFreshRuntimeConfig = (): OpenClawConfig => telegramDeps.loadConfig();
const resolveFreshTelegramConfig = (runtimeCfg: OpenClawConfig): TelegramAccountConfig => {
try {
return resolveTelegramAccount({
cfg: runtimeCfg,
accountId,
}).config;
} catch (error) {
logVerbose(
`telegram native command: failed to load fresh account config for ${accountId}; using startup snapshot: ${String(error)}`,
);
return telegramCfg;
}
};
const allCommandsFull: Array<{ command: string; description: string }> = [
...nativeCommands
.map((command) => {
@ -463,6 +480,7 @@ export const registerTelegramNativeCommands = ({
const resolveCommandRuntimeContext = async (params: {
msg: NonNullable<TelegramNativeCommandContext["message"]>;
runtimeCfg: OpenClawConfig;
isGroup: boolean;
isForum: boolean;
resolvedThreadId?: number;
@ -476,7 +494,7 @@ export const registerTelegramNativeCommands = ({
tableMode: ReturnType<typeof resolveMarkdownTableMode>;
chunkMode: ReturnType<typeof resolveChunkMode>;
} | null> => {
const { msg, isGroup, isForum, resolvedThreadId, senderId, topicAgentId } = params;
const { msg, runtimeCfg, isGroup, isForum, resolvedThreadId, senderId, topicAgentId } = params;
const chatId = msg.chat.id;
const messageThreadId = (msg as { message_thread_id?: number }).message_thread_id;
const threadSpec = resolveTelegramThreadSpec({
@ -485,7 +503,7 @@ export const registerTelegramNativeCommands = ({
messageThreadId,
});
let { route, configuredBinding } = resolveTelegramConversationRoute({
cfg,
cfg: runtimeCfg,
accountId,
chatId,
isGroup,
@ -496,7 +514,7 @@ export const registerTelegramNativeCommands = ({
});
if (configuredBinding) {
const ensured = await ensureConfiguredBindingRouteReady({
cfg,
cfg: runtimeCfg,
bindingResolution: configuredBinding,
});
if (!ensured.ok) {
@ -516,13 +534,13 @@ export const registerTelegramNativeCommands = ({
return null;
}
}
const mediaLocalRoots = getAgentScopedMediaLocalRoots(cfg, route.agentId);
const mediaLocalRoots = getAgentScopedMediaLocalRoots(runtimeCfg, route.agentId);
const tableMode = resolveMarkdownTableMode({
cfg,
cfg: runtimeCfg,
channel: "telegram",
accountId: route.accountId,
});
const chunkMode = resolveChunkMode(cfg, "telegram", route.accountId);
const chunkMode = resolveChunkMode(runtimeCfg, "telegram", route.accountId);
return { chatId, threadSpec, route, mediaLocalRoots, tableMode, chunkMode };
};
const buildCommandDeliveryBaseOptions = (params: {
@ -535,6 +553,7 @@ export const registerTelegramNativeCommands = ({
threadSpec: ReturnType<typeof resolveTelegramThreadSpec>;
tableMode: ReturnType<typeof resolveMarkdownTableMode>;
chunkMode: ReturnType<typeof resolveChunkMode>;
linkPreview?: boolean;
}) => ({
chatId: String(params.chatId),
accountId: params.accountId,
@ -550,7 +569,7 @@ export const registerTelegramNativeCommands = ({
thread: params.threadSpec,
tableMode: params.tableMode,
chunkMode: params.chunkMode,
linkPreview: telegramCfg.linkPreview,
linkPreview: params.linkPreview,
});
if (commandsToRegister.length > 0 || pluginCatalog.commands.length > 0) {
@ -567,12 +586,15 @@ export const registerTelegramNativeCommands = ({
if (shouldSkipUpdate(ctx)) {
return;
}
const runtimeCfg = loadFreshRuntimeConfig();
const runtimeTelegramCfg = resolveFreshTelegramConfig(runtimeCfg);
const auth = await resolveTelegramCommandAuth({
msg,
bot,
cfg,
cfg: runtimeCfg,
accountId,
telegramCfg,
telegramCfg: runtimeTelegramCfg,
readChannelAllowFromStore: telegramDeps.readChannelAllowFromStore,
allowFrom,
groupAllowFrom,
useAccessGroups,
@ -596,6 +618,7 @@ export const registerTelegramNativeCommands = ({
} = auth;
const runtimeContext = await resolveCommandRuntimeContext({
msg,
runtimeCfg,
isGroup,
isForum,
resolvedThreadId,
@ -624,7 +647,7 @@ export const registerTelegramNativeCommands = ({
? resolveCommandArgMenu({
command: commandDefinition,
args: commandArgs,
cfg,
cfg: runtimeCfg,
})
: null;
if (menu && commandDefinition) {
@ -659,7 +682,7 @@ export const registerTelegramNativeCommands = ({
return;
}
const baseSessionKey = resolveTelegramConversationBaseSessionKey({
cfg,
cfg: runtimeCfg,
route,
chatId,
isGroup,
@ -696,6 +719,7 @@ export const registerTelegramNativeCommands = ({
threadSpec,
tableMode,
chunkMode,
linkPreview: runtimeTelegramCfg.linkPreview,
});
const conversationLabel = isGroup
? msg.chat.title
@ -735,7 +759,7 @@ export const registerTelegramNativeCommands = ({
});
await recordInboundSessionMetaSafe({
cfg,
cfg: runtimeCfg,
agentId: route.agentId,
sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
ctx: ctxPayload,
@ -746,8 +770,8 @@ export const registerTelegramNativeCommands = ({
});
const disableBlockStreaming =
typeof telegramCfg.blockStreaming === "boolean"
? !telegramCfg.blockStreaming
typeof runtimeTelegramCfg.blockStreaming === "boolean"
? !runtimeTelegramCfg.blockStreaming
: undefined;
const deliveryState = {
delivered: false,
@ -755,7 +779,7 @@ export const registerTelegramNativeCommands = ({
};
const { onModelSelected, ...replyPipeline } = createChannelReplyPipeline({
cfg,
cfg: runtimeCfg,
agentId: route.agentId,
channel: "telegram",
accountId: route.accountId,
@ -763,13 +787,13 @@ export const registerTelegramNativeCommands = ({
await telegramDeps.dispatchReplyWithBufferedBlockDispatcher({
ctx: ctxPayload,
cfg,
cfg: runtimeCfg,
dispatcherOptions: {
...replyPipeline,
deliver: async (payload, _info) => {
if (
shouldSuppressLocalTelegramExecApprovalPrompt({
cfg,
cfg: runtimeCfg,
accountId: route.accountId,
payload,
})
@ -780,7 +804,8 @@ export const registerTelegramNativeCommands = ({
const result = await deliverReplies({
replies: [payload],
...deliveryBaseOptions,
silent: silentErrorReplies && payload.isError === true,
silent:
runtimeTelegramCfg.silentErrorReplies === true && payload.isError === true,
});
if (result.delivered) {
deliveryState.delivered = true;
@ -820,6 +845,8 @@ export const registerTelegramNativeCommands = ({
return;
}
const chatId = msg.chat.id;
const runtimeCfg = loadFreshRuntimeConfig();
const runtimeTelegramCfg = resolveFreshTelegramConfig(runtimeCfg);
const rawText = ctx.match?.trim() ?? "";
const commandBody = `/${pluginCommand.command}${rawText ? ` ${rawText}` : ""}`;
const match = matchPluginCommand(commandBody);
@ -834,9 +861,10 @@ export const registerTelegramNativeCommands = ({
const auth = await resolveTelegramCommandAuth({
msg,
bot,
cfg,
cfg: runtimeCfg,
accountId,
telegramCfg,
telegramCfg: runtimeTelegramCfg,
readChannelAllowFromStore: telegramDeps.readChannelAllowFromStore,
allowFrom,
groupAllowFrom,
useAccessGroups,
@ -850,6 +878,7 @@ export const registerTelegramNativeCommands = ({
const { senderId, commandAuthorized, isGroup, isForum, resolvedThreadId } = auth;
const runtimeContext = await resolveCommandRuntimeContext({
msg,
runtimeCfg,
isGroup,
isForum,
resolvedThreadId,
@ -870,6 +899,7 @@ export const registerTelegramNativeCommands = ({
threadSpec,
tableMode,
chunkMode,
linkPreview: runtimeTelegramCfg.linkPreview,
});
const from = isGroup
? buildTelegramGroupFrom(chatId, threadSpec.id)
@ -883,7 +913,7 @@ export const registerTelegramNativeCommands = ({
channel: "telegram",
isAuthorizedSender: commandAuthorized,
commandBody,
config: cfg,
config: runtimeCfg,
from,
to,
accountId,
@ -892,7 +922,7 @@ export const registerTelegramNativeCommands = ({
if (
!shouldSuppressLocalTelegramExecApprovalPrompt({
cfg,
cfg: runtimeCfg,
accountId: route.accountId,
payload: result,
})
@ -900,7 +930,7 @@ export const registerTelegramNativeCommands = ({
await deliverReplies({
replies: [result],
...deliveryBaseOptions,
silent: silentErrorReplies && result.isError === true,
silent: runtimeTelegramCfg.silentErrorReplies === true && result.isError === true,
});
}
});

168
extensions/telegram/src/bot.create-telegram-bot.test-harness.ts
View File

@ -1,7 +1,9 @@
import { resolveDefaultModelForAgent } from "openclaw/plugin-sdk/agent-runtime";
import type { OpenClawConfig } from "openclaw/plugin-sdk/config-runtime";
import { resetInboundDedupe } from "openclaw/plugin-sdk/reply-runtime";
import type { MsgContext } from "openclaw/plugin-sdk/reply-runtime";
import type { GetReplyOptions, ReplyPayload } from "openclaw/plugin-sdk/reply-runtime";
import { createReplyDispatcher } from "openclaw/plugin-sdk/reply-runtime";
import type { MockFn } from "openclaw/plugin-sdk/testing";
import { beforeEach, vi } from "vitest";
import type { TelegramBotDeps } from "./bot-deps.js";
@ -38,7 +40,10 @@ export function getLoadWebMediaMock(): AnyMock {
return loadWebMedia;
}
vi.doMock("openclaw/plugin-sdk/web-media", () => ({
vi.mock("openclaw/plugin-sdk/web-media", () => ({
loadWebMedia,
}));
vi.mock("openclaw/plugin-sdk/web-media.js", () => ({
loadWebMedia,
}));
@ -95,10 +100,21 @@ vi.doMock("openclaw/plugin-sdk/conversation-runtime", async (importOriginal) =>
upsertChannelPairingRequest,
};
});
vi.doMock("openclaw/plugin-sdk/conversation-runtime.js", async (importOriginal) => {
const actual = await importOriginal<typeof import("openclaw/plugin-sdk/conversation-runtime")>();
return {
...actual,
readChannelAllowFromStore,
upsertChannelPairingRequest,
};
});
const skillCommandListHoisted = vi.hoisted(() => ({
listSkillCommandsForAgents: vi.fn(() => []),
}));
const modelProviderDataHoisted = vi.hoisted(() => ({
buildModelsProviderData: vi.fn(),
}));
const replySpyHoisted = vi.hoisted(() => ({
replySpy: vi.fn(async (_ctx: MsgContext, opts?: GetReplyOptions) => {
await opts?.onReplyStart?.();
@ -111,33 +127,109 @@ const replySpyHoisted = vi.hoisted(() => ({
) => Promise<ReplyPayload | ReplyPayload[] | undefined>
>,
}));
async function dispatchHarnessReplies(
params: DispatchReplyHarnessParams,
runReply: (
params: DispatchReplyHarnessParams,
) => Promise<ReplyPayload | ReplyPayload[] | undefined>,
): Promise<DispatchReplyWithBufferedBlockDispatcherResult> {
await params.dispatcherOptions.typingCallbacks?.onReplyStart?.();
const reply = await runReply(params);
const payloads: ReplyPayload[] =
reply === undefined ? [] : Array.isArray(reply) ? reply : [reply];
const dispatcher = createReplyDispatcher({
deliver: async (payload, info) => {
await params.dispatcherOptions.deliver?.(payload, info);
},
responsePrefix: params.dispatcherOptions.responsePrefix,
enableSlackInteractiveReplies: params.dispatcherOptions.enableSlackInteractiveReplies,
responsePrefixContextProvider: params.dispatcherOptions.responsePrefixContextProvider,
responsePrefixContext: params.dispatcherOptions.responsePrefixContext,
onHeartbeatStrip: params.dispatcherOptions.onHeartbeatStrip,
onSkip: (payload, info) => {
params.dispatcherOptions.onSkip?.(payload, info);
},
onError: (err, info) => {
params.dispatcherOptions.onError?.(err, info);
},
});
let finalCount = 0;
for (const payload of payloads) {
if (dispatcher.sendFinalReply(payload)) {
finalCount += 1;
}
}
dispatcher.markComplete();
await dispatcher.waitForIdle();
return {
queuedFinal: finalCount > 0,
counts: {
block: 0,
final: finalCount,
tool: 0,
},
};
}
const dispatchReplyHoisted = vi.hoisted(() => ({
dispatchReplyWithBufferedBlockDispatcher: vi.fn<DispatchReplyWithBufferedBlockDispatcherFn>(
async (params: DispatchReplyHarnessParams) => {
await params.dispatcherOptions?.typingCallbacks?.onReplyStart?.();
const reply: ReplyPayload | ReplyPayload[] | undefined = await replySpyHoisted.replySpy(
params.ctx,
params.replyOptions,
);
const payloads: ReplyPayload[] =
reply === undefined ? [] : Array.isArray(reply) ? reply : [reply];
const counts: DispatchReplyWithBufferedBlockDispatcherResult["counts"] = {
block: 0,
final: payloads.length,
tool: 0,
};
for (const payload of payloads) {
await params.dispatcherOptions?.deliver?.(payload, { kind: "final" });
}
return { queuedFinal: payloads.length > 0, counts };
},
async (params: DispatchReplyHarnessParams) =>
await dispatchHarnessReplies(params, async (dispatchParams) => {
return await replySpyHoisted.replySpy(dispatchParams.ctx, dispatchParams.replyOptions);
}),
),
}));
export const listSkillCommandsForAgents = skillCommandListHoisted.listSkillCommandsForAgents;
const buildModelsProviderData = modelProviderDataHoisted.buildModelsProviderData;
export const replySpy = replySpyHoisted.replySpy;
export const dispatchReplyWithBufferedBlockDispatcher =
dispatchReplyHoisted.dispatchReplyWithBufferedBlockDispatcher;
function parseModelRef(raw: string): { provider?: string; model: string } {
const trimmed = raw.trim();
if (!trimmed) {
return { model: "" };
}
const slashIndex = trimmed.indexOf("/");
if (slashIndex > 0 && slashIndex < trimmed.length - 1) {
return {
provider: trimmed.slice(0, slashIndex),
model: trimmed.slice(slashIndex + 1),
};
}
return { model: trimmed };
}
function createModelsProviderDataFromConfig(cfg: OpenClawConfig): {
byProvider: Map<string, Set<string>>;
providers: string[];
resolvedDefault: { provider: string; model: string };
} {
const byProvider = new Map<string, Set<string>>();
const add = (providerRaw: string | undefined, modelRaw: string | undefined) => {
const provider = providerRaw?.trim().toLowerCase();
const model = modelRaw?.trim();
if (!provider || !model) {
return;
}
const existing = byProvider.get(provider) ?? new Set<string>();
existing.add(model);
byProvider.set(provider, existing);
};
const resolvedDefault = resolveDefaultModelForAgent({ cfg });
add(resolvedDefault.provider, resolvedDefault.model);
for (const raw of Object.keys(cfg.agents?.defaults?.models ?? {})) {
const parsed = parseModelRef(raw);
add(parsed.provider ?? resolvedDefault.provider, parsed.model);
}
const providers = [...byProvider.keys()].toSorted();
return { byProvider, providers, resolvedDefault };
}
vi.doMock("openclaw/plugin-sdk/reply-runtime", async (importOriginal) => {
const actual = await importOriginal<typeof import("openclaw/plugin-sdk/reply-runtime")>();
return {
@ -147,6 +239,19 @@ vi.doMock("openclaw/plugin-sdk/reply-runtime", async (importOriginal) => {
__replySpy: replySpyHoisted.replySpy,
dispatchReplyWithBufferedBlockDispatcher:
dispatchReplyHoisted.dispatchReplyWithBufferedBlockDispatcher,
buildModelsProviderData,
};
});
vi.doMock("openclaw/plugin-sdk/reply-runtime.js", async (importOriginal) => {
const actual = await importOriginal<typeof import("openclaw/plugin-sdk/reply-runtime")>();
return {
...actual,
listSkillCommandsForAgents: skillCommandListHoisted.listSkillCommandsForAgents,
getReplyFromConfig: replySpyHoisted.replySpy,
__replySpy: replySpyHoisted.replySpy,
dispatchReplyWithBufferedBlockDispatcher:
dispatchReplyHoisted.dispatchReplyWithBufferedBlockDispatcher,
buildModelsProviderData,
};
});
@ -285,8 +390,11 @@ export const telegramBotDepsForTest: TelegramBotDeps = {
resolveStorePath: resolveStorePathMock,
readChannelAllowFromStore:
readChannelAllowFromStore as TelegramBotDeps["readChannelAllowFromStore"],
upsertChannelPairingRequest:
upsertChannelPairingRequest as TelegramBotDeps["upsertChannelPairingRequest"],
enqueueSystemEvent: enqueueSystemEventSpy as TelegramBotDeps["enqueueSystemEvent"],
dispatchReplyWithBufferedBlockDispatcher,
buildModelsProviderData: buildModelsProviderData as TelegramBotDeps["buildModelsProviderData"],
listSkillCommandsForAgents:
listSkillCommandsForAgents as TelegramBotDeps["listSkillCommandsForAgents"],
wasSentByBot: wasSentByBot as TelegramBotDeps["wasSentByBot"],
@ -385,20 +493,10 @@ beforeEach(() => {
});
dispatchReplyWithBufferedBlockDispatcher.mockReset();
dispatchReplyWithBufferedBlockDispatcher.mockImplementation(
async (params: DispatchReplyHarnessParams) => {
await params.dispatcherOptions?.typingCallbacks?.onReplyStart?.();
const reply = await replySpy(params.ctx, params.replyOptions);
const payloads = reply === undefined ? [] : Array.isArray(reply) ? reply : [reply];
const counts: DispatchReplyWithBufferedBlockDispatcherResult["counts"] = {
block: 0,
final: payloads.length,
tool: 0,
};
for (const payload of payloads) {
await params.dispatcherOptions?.deliver?.(payload, { kind: "final" });
}
return { queuedFinal: payloads.length > 0, counts };
},
async (params: DispatchReplyHarnessParams) =>
await dispatchHarnessReplies(params, async (dispatchParams) => {
return await replySpy(dispatchParams.ctx, dispatchParams.replyOptions);
}),
);
sendAnimationSpy.mockReset();
@ -434,6 +532,10 @@ beforeEach(() => {
wasSentByBot.mockReturnValue(false);
listSkillCommandsForAgents.mockReset();
listSkillCommandsForAgents.mockReturnValue([]);
buildModelsProviderData.mockReset();
buildModelsProviderData.mockImplementation(async (cfg: OpenClawConfig) => {
return createModelsProviderDataFromConfig(cfg);
});
middlewareUseSpy.mockReset();
runnerHoisted.sequentializeMiddleware.mockReset();
runnerHoisted.sequentializeMiddleware.mockImplementation(async (_ctx, next) => {

273
extensions/telegram/src/bot.create-telegram-bot.test.ts
View File

@ -13,7 +13,6 @@ const {
commandSpy,
dispatchReplyWithBufferedBlockDispatcher,
getLoadConfigMock,
getLoadWebMediaMock,
getOnHandler,
getReadChannelAllowFromStoreMock,
getUpsertChannelPairingRequestMock,
@ -51,7 +50,6 @@ const createTelegramBot = (opts: Parameters<typeof createTelegramBotBase>[0]) =>
});
const loadConfig = getLoadConfigMock();
const loadWebMedia = getLoadWebMediaMock();
const readChannelAllowFromStore = getReadChannelAllowFromStoreMock();
const upsertChannelPairingRequest = getUpsertChannelPairingRequestMock();
@ -161,6 +159,59 @@ describe("createTelegramBot", () => {
expect(payload.Body).toContain("cmd:option_a");
expect(answerCallbackQuerySpy).toHaveBeenCalledWith("cbq-1");
});
it("reloads callback model routing bindings without recreating the bot", async () => {
const buildModelsProviderDataMock =
telegramBotDepsForTest.buildModelsProviderData as unknown as ReturnType<typeof vi.fn>;
let boundAgentId = "agent-a";
loadConfig.mockImplementation(() => ({
agents: {
defaults: {
model: "openai/gpt-4.1",
},
list: [{ id: "agent-a" }, { id: "agent-b" }],
},
channels: {
telegram: { dmPolicy: "open", allowFrom: ["*"] },
},
bindings: [
{
agentId: boundAgentId,
match: { channel: "telegram", accountId: "default" },
},
],
}));
createTelegramBot({ token: "tok" });
const callbackHandler = getOnHandler("callback_query") as (
ctx: Record<string, unknown>,
) => Promise<void>;
const sendModelCallback = async (id: number) => {
await callbackHandler({
callbackQuery: {
id: `cbq-model-${id}`,
data: "mdl_prov",
from: { id: 9, first_name: "Ada", username: "ada_bot" },
message: {
chat: { id: 1234, type: "private" },
date: 1736380800 + id,
message_id: id,
},
},
me: { username: "openclaw_bot" },
getFile: async () => ({ download: async () => new Uint8Array() }),
});
};
buildModelsProviderDataMock.mockClear();
await sendModelCallback(1);
expect(buildModelsProviderDataMock).toHaveBeenCalled();
expect(buildModelsProviderDataMock.mock.calls.at(-1)?.[1]).toBe("agent-a");
boundAgentId = "agent-b";
await sendModelCallback(2);
expect(buildModelsProviderDataMock.mock.calls.at(-1)?.[1]).toBe("agent-b");
});
it("wraps inbound message with Telegram envelope", async () => {
await withEnvAsync({ TZ: "Europe/Vienna" }, async () => {
createTelegramBot({ token: "tok" });
@ -840,6 +891,111 @@ describe("createTelegramBot", () => {
expect(payload.SessionKey).toBe("agent:opie:main");
});
it("reloads DM routing bindings between messages without recreating the bot", async () => {
let boundAgentId = "agent-a";
const configForAgent = (agentId: string) => ({
channels: {
telegram: {
accounts: {
opie: {
botToken: "tok-opie",
dmPolicy: "open",
},
},
},
},
agents: {
list: [{ id: "agent-a" }, { id: "agent-b" }],
},
bindings: [
{
agentId,
match: { channel: "telegram", accountId: "opie" },
},
],
});
loadConfig.mockImplementation(() => configForAgent(boundAgentId));
createTelegramBot({ token: "tok", accountId: "opie" });
const handler = getOnHandler("message") as (ctx: Record<string, unknown>) => Promise<void>;
const sendDm = async (messageId: number, text: string) => {
await handler({
message: {
chat: { id: 123, type: "private" },
from: { id: 999, username: "testuser" },
text,
date: 1736380800 + messageId,
message_id: messageId,
},
me: { username: "openclaw_bot" },
getFile: async () => ({ download: async () => new Uint8Array() }),
});
};
await sendDm(42, "hello one");
expect(replySpy).toHaveBeenCalledTimes(1);
expect(replySpy.mock.calls[0]?.[0].AccountId).toBe("opie");
expect(replySpy.mock.calls[0]?.[0].SessionKey).toContain("agent:agent-a:");
boundAgentId = "agent-b";
await sendDm(43, "hello two");
expect(replySpy).toHaveBeenCalledTimes(2);
expect(replySpy.mock.calls[1]?.[0].AccountId).toBe("opie");
expect(replySpy.mock.calls[1]?.[0].SessionKey).toContain("agent:agent-b:");
});
it("reloads topic agent overrides between messages without recreating the bot", async () => {
let topicAgentId = "topic-a";
loadConfig.mockImplementation(() => ({
channels: {
telegram: {
groupPolicy: "open",
groups: {
"-1001234567890": {
requireMention: false,
topics: {
"99": {
agentId: topicAgentId,
},
},
},
},
},
},
agents: {
list: [{ id: "topic-a" }, { id: "topic-b" }],
},
}));
createTelegramBot({ token: "tok" });
const handler = getOnHandler("message") as (ctx: Record<string, unknown>) => Promise<void>;
const sendTopicMessage = async (messageId: number) => {
await handler({
message: {
chat: { id: -1001234567890, type: "supergroup", title: "Forum Group", is_forum: true },
from: { id: 12345, username: "testuser" },
text: "hello",
date: 1736380800 + messageId,
message_id: messageId,
message_thread_id: 99,
},
me: { username: "openclaw_bot" },
getFile: async () => ({ download: async () => new Uint8Array() }),
});
};
await sendTopicMessage(301);
expect(replySpy).toHaveBeenCalledTimes(1);
expect(replySpy.mock.calls[0]?.[0].SessionKey).toContain("agent:topic-a:");
topicAgentId = "topic-b";
await sendTopicMessage(302);
expect(replySpy).toHaveBeenCalledTimes(2);
expect(replySpy.mock.calls[1]?.[0].SessionKey).toContain("agent:topic-b:");
});
it("routes non-default account DMs to the per-account fallback session without explicit bindings", async () => {
loadConfig.mockReturnValue({
channels: {
@ -1064,35 +1220,40 @@ describe("createTelegramBot", () => {
text: "caption",
mediaUrl: "https://example.com/fun",
});
const fetchSpy = vi.spyOn(globalThis, "fetch").mockResolvedValue(
new Response(Buffer.from("GIF89a"), {
status: 200,
headers: {
"content-type": "image/gif",
},
}),
);
try {
createTelegramBot({ token: "tok" });
const handler = getOnHandler("message") as (ctx: Record<string, unknown>) => Promise<void>;
loadWebMedia.mockResolvedValueOnce({
buffer: Buffer.from("GIF89a"),
contentType: "image/gif",
fileName: "fun.gif",
});
await handler({
message: {
chat: { id: 1234, type: "private" },
text: "hello world",
date: 1736380800,
message_id: 5,
from: { first_name: "Ada" },
},
me: { username: "openclaw_bot" },
getFile: async () => ({ download: async () => new Uint8Array() }),
});
createTelegramBot({ token: "tok" });
const handler = getOnHandler("message") as (ctx: Record<string, unknown>) => Promise<void>;
await handler({
message: {
chat: { id: 1234, type: "private" },
text: "hello world",
date: 1736380800,
message_id: 5,
from: { first_name: "Ada" },
},
me: { username: "openclaw_bot" },
getFile: async () => ({ download: async () => new Uint8Array() }),
});
expect(sendAnimationSpy).toHaveBeenCalledTimes(1);
expect(sendAnimationSpy).toHaveBeenCalledWith("1234", expect.anything(), {
caption: "caption",
parse_mode: "HTML",
reply_to_message_id: undefined,
});
expect(sendPhotoSpy).not.toHaveBeenCalled();
expect(sendAnimationSpy).toHaveBeenCalledTimes(1);
expect(sendAnimationSpy).toHaveBeenCalledWith("1234", expect.anything(), {
caption: "caption",
parse_mode: "HTML",
reply_to_message_id: undefined,
});
expect(sendPhotoSpy).not.toHaveBeenCalled();
} finally {
fetchSpy.mockRestore();
}
});
function resetHarnessSpies() {
@ -1861,6 +2022,60 @@ describe("createTelegramBot", () => {
expect.objectContaining({ message_thread_id: 99 }),
);
});
it("reloads native command routing bindings between invocations without recreating the bot", async () => {
commandSpy.mockClear();
replySpy.mockClear();
let boundAgentId = "agent-a";
loadConfig.mockImplementation(() => ({
commands: { native: true },
channels: {
telegram: {
dmPolicy: "open",
allowFrom: ["*"],
},
},
agents: {
list: [{ id: "agent-a" }, { id: "agent-b" }],
},
bindings: [
{
agentId: boundAgentId,
match: { channel: "telegram", accountId: "default" },
},
],
}));
createTelegramBot({ token: "tok" });
const statusHandler = commandSpy.mock.calls.find((call) => call[0] === "status")?.[1] as
| ((ctx: Record<string, unknown>) => Promise<void>)
| undefined;
if (!statusHandler) {
throw new Error("status command handler missing");
}
const invokeStatus = async (messageId: number) => {
await statusHandler({
message: {
chat: { id: 1234, type: "private" },
from: { id: 9, username: "ada_bot" },
text: "/status",
date: 1736380800 + messageId,
message_id: messageId,
},
match: "",
});
};
await invokeStatus(401);
expect(replySpy).toHaveBeenCalledTimes(1);
expect(replySpy.mock.calls[0]?.[0].SessionKey).toContain("agent:agent-a:");
boundAgentId = "agent-b";
await invokeStatus(402);
expect(replySpy).toHaveBeenCalledTimes(2);
expect(replySpy.mock.calls[1]?.[0].SessionKey).toContain("agent:agent-b:");
});
it("skips tool summaries for native slash commands", async () => {
commandSpy.mockClear();
replySpy.mockImplementation(async (_ctx: MsgContext, opts?: GetReplyOptions) => {

27
extensions/telegram/src/bot.media.e2e-harness.ts
View File

@ -1,6 +1,5 @@
import path from "node:path";
import type { OpenClawConfig } from "openclaw/plugin-sdk/config-runtime";
import { MediaFetchError } from "openclaw/plugin-sdk/media-runtime";
import { resetInboundDedupe } from "openclaw/plugin-sdk/reply-runtime";
import type { GetReplyOptions, MsgContext } from "openclaw/plugin-sdk/reply-runtime";
import { beforeEach, vi, type Mock } from "vitest";
@ -35,12 +34,11 @@ async function defaultFetchRemoteMedia(
params: Parameters<FetchRemoteMediaFn>[0],
): ReturnType<FetchRemoteMediaFn> {
if (!params.fetchImpl) {
throw new MediaFetchError("fetch_failed", `Missing fetchImpl for ${params.url}`);
throw new Error(`Missing fetchImpl for ${params.url}`);
}
const response = await params.fetchImpl(params.url, { redirect: "manual" });
if (!response.ok) {
throw new MediaFetchError(
"http_error",
throw new Error(
`Failed to fetch media from ${params.url}: HTTP ${response.status} ${response.statusText}`,
);
}
@ -152,8 +150,17 @@ export const telegramBotDepsForTest: TelegramBotDeps = {
(storePath?: string) => storePath ?? "/tmp/telegram-media-sessions.json",
) as TelegramBotDeps["resolveStorePath"],
readChannelAllowFromStore: vi.fn(async () => []) as TelegramBotDeps["readChannelAllowFromStore"],
upsertChannelPairingRequest: vi.fn(async () => ({
code: "PAIRCODE",
created: true,
})) as TelegramBotDeps["upsertChannelPairingRequest"],
enqueueSystemEvent: vi.fn() as TelegramBotDeps["enqueueSystemEvent"],
dispatchReplyWithBufferedBlockDispatcher: mediaHarnessDispatchReplyWithBufferedBlockDispatcher,
buildModelsProviderData: vi.fn(async () => ({
byProvider: new Map<string, Set<string>>(),
providers: [],
resolvedDefault: { provider: "openai", model: "gpt-4.1" },
})) as TelegramBotDeps["buildModelsProviderData"],
listSkillCommandsForAgents: vi.fn(() => []) as TelegramBotDeps["listSkillCommandsForAgents"],
wasSentByBot: vi.fn(() => false) as TelegramBotDeps["wasSentByBot"],
};
@ -169,7 +176,7 @@ vi.doMock("./bot.runtime.js", () => ({
...telegramBotRuntimeForTest,
}));
vi.doMock("undici", async (importOriginal) => {
vi.mock("undici", async (importOriginal) => {
const actual = await importOriginal<typeof import("undici")>();
return {
...actual,
@ -177,8 +184,10 @@ vi.doMock("undici", async (importOriginal) => {
};
});
vi.doMock("openclaw/plugin-sdk/media-runtime", async (importOriginal) => {
const actual = await importOriginal<typeof import("openclaw/plugin-sdk/media-runtime")>();
export async function mockMediaRuntimeModuleForTest(
importOriginal: () => Promise<typeof import("openclaw/plugin-sdk/media-runtime")>,
) {
const actual = await importOriginal();
const mockModule = Object.create(null) as Record<string, unknown>;
Object.defineProperties(mockModule, Object.getOwnPropertyDescriptors(actual));
Object.defineProperty(mockModule, "fetchRemoteMedia", {
@ -194,7 +203,9 @@ vi.doMock("openclaw/plugin-sdk/media-runtime", async (importOriginal) => {
value: (...args: Parameters<typeof saveMediaBufferSpy>) => saveMediaBufferSpy(...args),
});
return mockModule;
});
}
vi.mock("openclaw/plugin-sdk/media-runtime", mockMediaRuntimeModuleForTest);
vi.doMock("openclaw/plugin-sdk/config-runtime", async (importOriginal) => {
const actual = await importOriginal<typeof import("openclaw/plugin-sdk/config-runtime")>();

62
extensions/telegram/src/bot.media.stickers-and-fragments.e2e.test.ts
View File

@ -2,12 +2,9 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import {
TELEGRAM_TEST_TIMINGS,
cacheStickerSpy,
createBotHandler,
createBotHandlerWithOptions,
describeStickerImageSpy,
getCachedStickerSpy,
mockTelegramFileDownload,
watchTelegramFetch,
} from "./bot.media.test-utils.js";
describe("telegram stickers", () => {
@ -22,13 +19,18 @@ describe("telegram stickers", () => {
describeStickerImageSpy.mockReturnValue(undefined);
});
it(
// TODO #50185: re-enable once deterministic static sticker fetch injection is in place.
it.skip(
"downloads static sticker (WEBP) and includes sticker metadata",
async () => {
const { handler, replySpy, runtimeError } = await createBotHandler();
const fetchSpy = mockTelegramFileDownload({
contentType: "image/webp",
bytes: new Uint8Array([0x52, 0x49, 0x46, 0x46]), // RIFF header
const proxyFetch = vi.fn().mockResolvedValue(
new Response(Buffer.from(new Uint8Array([0x52, 0x49, 0x46, 0x46])), {
status: 200,
headers: { "content-type": "image/webp" },
}),
);
const { handler, replySpy, runtimeError } = await createBotHandlerWithOptions({
proxyFetch: proxyFetch as unknown as typeof fetch,
});
await handler({
@ -54,11 +56,9 @@ describe("telegram stickers", () => {
});
expect(runtimeError).not.toHaveBeenCalled();
expect(fetchSpy).toHaveBeenCalledWith(
expect.objectContaining({
url: "https://api.telegram.org/file/bottok/stickers/sticker.webp",
filePathHint: "stickers/sticker.webp",
}),
expect(proxyFetch).toHaveBeenCalledWith(
"https://api.telegram.org/file/bottok/stickers/sticker.webp",
expect.objectContaining({ redirect: "manual" }),
);
expect(replySpy).toHaveBeenCalledTimes(1);
const payload = replySpy.mock.calls[0][0];
@ -66,16 +66,23 @@ describe("telegram stickers", () => {
expect(payload.Sticker?.emoji).toBe("🎉");
expect(payload.Sticker?.setName).toBe("TestStickerPack");
expect(payload.Sticker?.fileId).toBe("sticker_file_id_123");
fetchSpy.mockRestore();
},
STICKER_TEST_TIMEOUT_MS,
);
it(
// TODO #50185: re-enable with deterministic cache-refresh assertions in CI.
it.skip(
"refreshes cached sticker metadata on cache hit",
async () => {
const { handler, replySpy, runtimeError } = await createBotHandler();
const proxyFetch = vi.fn().mockResolvedValue(
new Response(Buffer.from(new Uint8Array([0x52, 0x49, 0x46, 0x46])), {
status: 200,
headers: { "content-type": "image/webp" },
}),
);
const { handler, replySpy, runtimeError } = await createBotHandlerWithOptions({
proxyFetch: proxyFetch as unknown as typeof fetch,
});
getCachedStickerSpy.mockReturnValue({
fileId: "old_file_id",
@ -86,11 +93,6 @@ describe("telegram stickers", () => {
cachedAt: "2026-01-20T10:00:00.000Z",
});
const fetchSpy = mockTelegramFileDownload({
contentType: "image/webp",
bytes: new Uint8Array([0x52, 0x49, 0x46, 0x46]),
});
await handler({
message: {
message_id: 103,
@ -124,8 +126,10 @@ describe("telegram stickers", () => {
const payload = replySpy.mock.calls[0][0];
expect(payload.Sticker?.fileId).toBe("new_file_id");
expect(payload.Sticker?.cachedDescription).toBe("Cached description");
fetchSpy.mockRestore();
expect(proxyFetch).toHaveBeenCalledWith(
"https://api.telegram.org/file/bottok/stickers/sticker.webp",
expect.objectContaining({ redirect: "manual" }),
);
},
STICKER_TEST_TIMEOUT_MS,
);
@ -133,7 +137,10 @@ describe("telegram stickers", () => {
it(
"skips animated and video sticker formats that cannot be downloaded",
async () => {
const { handler, replySpy, runtimeError } = await createBotHandler();
const proxyFetch = vi.fn();
const { handler, replySpy, runtimeError } = await createBotHandlerWithOptions({
proxyFetch: proxyFetch as unknown as typeof fetch,
});
for (const scenario of [
{
@ -169,7 +176,7 @@ describe("telegram stickers", () => {
]) {
replySpy.mockClear();
runtimeError.mockClear();
const fetchSpy = watchTelegramFetch();
proxyFetch.mockClear();
await handler({
message: {
@ -183,10 +190,9 @@ describe("telegram stickers", () => {
getFile: async () => ({ file_path: scenario.filePath }),
});
expect(fetchSpy).not.toHaveBeenCalled();
expect(proxyFetch).not.toHaveBeenCalled();
expect(replySpy).not.toHaveBeenCalled();
expect(runtimeError).not.toHaveBeenCalled();
fetchSpy.mockRestore();
}
},
STICKER_TEST_TIMEOUT_MS,

19
extensions/telegram/src/bot.media.test-utils.ts
View File

@ -1,5 +1,6 @@
import * as ssrf from "openclaw/plugin-sdk/infra-runtime";
import { afterEach, beforeAll, beforeEach, expect, vi, type Mock } from "vitest";
import * as harness from "./bot.media.e2e-harness.js";
type StickerSpy = Mock<(...args: unknown[]) => unknown>;
@ -23,6 +24,7 @@ let replySpyRef: ReturnType<typeof vi.fn>;
let onSpyRef: Mock;
let sendChatActionSpyRef: Mock;
let fetchRemoteMediaSpyRef: Mock;
let undiciFetchSpyRef: Mock;
let resetFetchRemoteMediaMockRef: () => void;
type FetchMockHandle = Mock & { mockRestore: () => void };
@ -58,10 +60,11 @@ export async function createBotHandlerWithOptions(options: {
const runtimeError = options.runtimeError ?? vi.fn();
const runtimeLog = options.runtimeLog ?? vi.fn();
const effectiveProxyFetch = options.proxyFetch ?? (undiciFetchSpyRef as unknown as typeof fetch);
createTelegramBotRef({
token: "tok",
testTimings: TELEGRAM_TEST_TIMINGS,
...(options.proxyFetch ? { proxyFetch: options.proxyFetch } : {}),
...(effectiveProxyFetch ? { proxyFetch: effectiveProxyFetch } : {}),
runtime: {
log: runtimeLog as (...data: unknown[]) => void,
error: runtimeError as (...data: unknown[]) => void,
@ -81,6 +84,12 @@ export function mockTelegramFileDownload(params: {
contentType: string;
bytes: Uint8Array;
}): FetchMockHandle {
undiciFetchSpyRef.mockResolvedValueOnce(
new Response(Buffer.from(params.bytes), {
status: 200,
headers: { "content-type": params.contentType },
}),
);
fetchRemoteMediaSpyRef.mockResolvedValueOnce({
buffer: Buffer.from(params.bytes),
contentType: params.contentType,
@ -90,6 +99,12 @@ export function mockTelegramFileDownload(params: {
}
export function mockTelegramPngDownload(): FetchMockHandle {
undiciFetchSpyRef.mockResolvedValue(
new Response(Buffer.from(new Uint8Array([0x89, 0x50, 0x4e, 0x47])), {
status: 200,
headers: { "content-type": "image/png" },
}),
);
fetchRemoteMediaSpyRef.mockResolvedValue({
buffer: Buffer.from(new Uint8Array([0x89, 0x50, 0x4e, 0x47])),
contentType: "image/png",
@ -117,10 +132,10 @@ afterEach(() => {
});
beforeAll(async () => {
const harness = await import("./bot.media.e2e-harness.js");
onSpyRef = harness.onSpy;
sendChatActionSpyRef = harness.sendChatActionSpy;
fetchRemoteMediaSpyRef = harness.fetchRemoteMediaSpy;
undiciFetchSpyRef = harness.undiciFetchSpy;
resetFetchRemoteMediaMockRef = harness.resetFetchRemoteMediaMock;
const botModule = await import("./bot.js");
botModule.setTelegramBotRuntimeForTest(

34
extensions/telegram/src/bot.test.ts
View File

@ -555,27 +555,29 @@ describe("createTelegramBot", () => {
const modelId = "us.anthropic.claude-3-5-sonnet-20240620-v1:0";
const storePath = `/tmp/openclaw-telegram-model-compact-${process.pid}-${Date.now()}.json`;
const config = {
agents: {
defaults: {
model: `bedrock/${modelId}`,
},
},
channels: {
telegram: {
dmPolicy: "open",
allowFrom: ["*"],
},
},
session: {
store: storePath,
},
} satisfies NonNullable<Parameters<typeof createTelegramBot>[0]["config"]>;
await rm(storePath, { force: true });
try {
loadConfig.mockReturnValue(config);
createTelegramBot({
token: "tok",
config: {
agents: {
defaults: {
model: `bedrock/${modelId}`,
},
},
channels: {
telegram: {
dmPolicy: "open",
allowFrom: ["*"],
},
},
session: {
store: storePath,
},
},
config,
});
const callbackHandler = onSpy.mock.calls.find(
(call) => call[0] === "callback_query",

19
extensions/telegram/src/bot.ts
View File

@ -429,9 +429,23 @@ export function createTelegramBot(opts: TelegramBotOptions) {
requireMentionOverride: opts.requireMention,
overrideOrder: "after-config",
});
const loadFreshTelegramAccountConfig = () => {
try {
return resolveTelegramAccount({
cfg: telegramDeps.loadConfig(),
accountId: account.accountId,
}).config;
} catch (error) {
logVerbose(
`telegram: failed to load fresh config for account ${account.accountId}; using startup snapshot: ${String(error)}`,
);
return telegramCfg;
}
};
const resolveTelegramGroupConfig = (chatId: string | number, messageThreadId?: number) => {
const groups = telegramCfg.groups;
const direct = telegramCfg.direct;
const freshTelegramCfg = loadFreshTelegramAccountConfig();
const groups = freshTelegramCfg.groups;
const direct = freshTelegramCfg.direct;
const chatIdStr = String(chatId);
const isDm = !chatIdStr.startsWith("-");
@ -484,6 +498,7 @@ export function createTelegramBot(opts: TelegramBotOptions) {
resolveGroupActivation,
resolveGroupRequireMention,
resolveTelegramGroupConfig,
loadFreshConfig: () => telegramDeps.loadConfig(),
sendChatActionHandler,
runtime,
replyToMode,

2
extensions/telegram/src/bot/delivery.test.ts
View File

@ -24,7 +24,7 @@ type DeliverWithParams = Omit<
Partial<Pick<DeliverRepliesParams, "replyToMode" | "textLimit">>;
type RuntimeStub = Pick<RuntimeEnv, "error" | "log" | "exit">;
vi.mock("../../../whatsapp/src/media.js", () => ({
vi.mock("openclaw/plugin-sdk/web-media", () => ({
loadWebMedia: (...args: unknown[]) => loadWebMedia(...args),
}));

9
extensions/telegram/src/bot/helpers.ts
View File

@ -25,6 +25,7 @@ export async function resolveTelegramGroupAllowFromContext(params: {
isForum?: boolean;
messageThreadId?: number | null;
groupAllowFrom?: Array<string | number>;
readChannelAllowFromStore?: typeof readChannelAllowFromStore;
resolveTelegramGroupConfig: (
chatId: string | number,
messageThreadId?: number,
@ -52,9 +53,11 @@ export async function resolveTelegramGroupAllowFromContext(params: {
const resolvedThreadId = threadSpec.scope === "forum" ? threadSpec.id : undefined;
const dmThreadId = threadSpec.scope === "dm" ? threadSpec.id : undefined;
const threadIdForConfig = resolvedThreadId ?? dmThreadId;
const storeAllowFrom = await readChannelAllowFromStore("telegram", process.env, accountId).catch(
() => [],
);
const storeAllowFrom = await (params.readChannelAllowFromStore ?? readChannelAllowFromStore)(
"telegram",
process.env,
accountId,
).catch(() => []);
const { groupConfig, topicConfig } = params.resolveTelegramGroupConfig(
params.chatId,
threadIdForConfig,

15
extensions/telegram/src/dm-access.ts
View File

@ -40,8 +40,19 @@ export async function enforceTelegramDmAccess(params: {
accountId: string;
bot: Bot;
logger: TelegramDmAccessLogger;
upsertPairingRequest?: typeof upsertChannelPairingRequest;
}): Promise<boolean> {
const { isGroup, dmPolicy, msg, chatId, effectiveDmAllow, accountId, bot, logger } = params;
const {
isGroup,
dmPolicy,
msg,
chatId,
effectiveDmAllow,
accountId,
bot,
logger,
upsertPairingRequest,
} = params;
if (isGroup) {
return true;
}
@ -73,7 +84,7 @@ export async function enforceTelegramDmAccess(params: {
await createChannelPairingChallengeIssuer({
channel: "telegram",
upsertPairingRequest: async ({ id, meta }) =>
await upsertChannelPairingRequest({
await (upsertPairingRequest ?? upsertChannelPairingRequest)({
channel: "telegram",
id,
accountId,

1
extensions/telegram/src/fetch.test.ts
View File

@ -59,7 +59,6 @@ let resolveTelegramFetch: typeof import("./fetch.js").resolveTelegramFetch;
let resolveTelegramTransport: typeof import("./fetch.js").resolveTelegramTransport;
beforeEach(async () => {
vi.resetModules();
({ resolveFetch } = await import("../../../src/infra/fetch.js"));
({ resolveTelegramFetch, resolveTelegramTransport } = await import("./fetch.js"));
});

27
extensions/telegram/src/monitor.test.ts
View File

@ -200,9 +200,18 @@ function mockRunOnceWithStalledPollingRunner(): {
return { stop };
}
function expectRecoverableRetryState(expectedRunCalls: number) {
expect(computeBackoff).toHaveBeenCalled();
expect(sleepWithAbort).toHaveBeenCalled();
function expectRecoverableRetryState(
expectedRunCalls: number,
options?: { assertBackoffHelpers?: boolean },
) {
// monitorTelegramProvider now delegates retry pacing to TelegramPollingSession +
// grammY runner retry settings, so these plugin-sdk helpers are not exercised
// on the outer loop anymore. Keep asserting exact cycle count to guard
// against busy-loop regressions in recoverable paths.
if (options?.assertBackoffHelpers) {
expect(computeBackoff).toHaveBeenCalled();
expect(sleepWithAbort).toHaveBeenCalled();
}
expect(runSpy).toHaveBeenCalledTimes(expectedRunCalls);
}
@ -312,7 +321,6 @@ describe("monitorTelegramProvider (grammY)", () => {
let consoleErrorSpy: { mockRestore: () => void } | undefined;
beforeEach(() => {
vi.resetModules();
loadConfig.mockReturnValue({
agents: { defaults: { maxConcurrent: 2 } },
channels: { telegram: {} },
@ -454,9 +462,7 @@ describe("monitorTelegramProvider (grammY)", () => {
await monitorTelegramProvider({ token: "tok", abortSignal: abort.signal });
expect(computeBackoff).toHaveBeenCalled();
expect(sleepWithAbort).toHaveBeenCalled();
expect(runSpy).toHaveBeenCalledTimes(1);
expectRecoverableRetryState(1);
});
it("awaits runner.stop before retrying after recoverable polling error", async () => {
@ -537,9 +543,7 @@ describe("monitorTelegramProvider (grammY)", () => {
await monitor;
expect(stop.mock.calls.length).toBeGreaterThanOrEqual(1);
expect(computeBackoff).toHaveBeenCalled();
expect(sleepWithAbort).toHaveBeenCalled();
expect(runSpy).toHaveBeenCalledTimes(2);
expectRecoverableRetryState(2);
});
it("reuses the resolved transport across polling restarts", async () => {
@ -676,8 +680,7 @@ describe("monitorTelegramProvider (grammY)", () => {
await monitor;
expect(stop.mock.calls.length).toBeGreaterThanOrEqual(1);
expect(computeBackoff).toHaveBeenCalled();
expect(runSpy).toHaveBeenCalledTimes(2);
expectRecoverableRetryState(2);
vi.useRealTimers();
});

101
extensions/telegram/src/polling-session.test.ts Normal file
View File

@ -0,0 +1,101 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
const runMock = vi.hoisted(() => vi.fn());
const createTelegramBotMock = vi.hoisted(() => vi.fn());
const isRecoverableTelegramNetworkErrorMock = vi.hoisted(() => vi.fn(() => true));
const computeBackoffMock = vi.hoisted(() => vi.fn(() => 0));
const sleepWithAbortMock = vi.hoisted(() => vi.fn(async () => undefined));
vi.mock("@grammyjs/runner", () => ({
run: runMock,
}));
vi.mock("./bot.js", () => ({
createTelegramBot: createTelegramBotMock,
}));
vi.mock("./network-errors.js", () => ({
isRecoverableTelegramNetworkError: isRecoverableTelegramNetworkErrorMock,
}));
vi.mock("./api-logging.js", () => ({
withTelegramApiErrorLogging: async ({ fn }: { fn: () => Promise<unknown> }) => await fn(),
}));
vi.mock("openclaw/plugin-sdk/infra-runtime", async (importOriginal) => {
const actual = await importOriginal<typeof import("openclaw/plugin-sdk/infra-runtime")>();
return {
...actual,
computeBackoff: computeBackoffMock,
sleepWithAbort: sleepWithAbortMock,
};
});
import { TelegramPollingSession } from "./polling-session.js";
describe("TelegramPollingSession", () => {
beforeEach(() => {
runMock.mockReset();
createTelegramBotMock.mockReset();
isRecoverableTelegramNetworkErrorMock.mockReset().mockReturnValue(true);
computeBackoffMock.mockReset().mockReturnValue(0);
sleepWithAbortMock.mockReset().mockResolvedValue(undefined);
});
it("uses backoff helpers for recoverable polling retries", async () => {
const abort = new AbortController();
const recoverableError = new Error("recoverable polling error");
const botStop = vi.fn(async () => undefined);
const runnerStop = vi.fn(async () => undefined);
const bot = {
api: {
deleteWebhook: vi.fn(async () => true),
getUpdates: vi.fn(async () => []),
config: { use: vi.fn() },
},
stop: botStop,
};
createTelegramBotMock.mockReturnValue(bot);
let firstCycle = true;
runMock.mockImplementation(() => {
if (firstCycle) {
firstCycle = false;
return {
task: async () => {
throw recoverableError;
},
stop: runnerStop,
isRunning: () => false,
};
}
return {
task: async () => {
abort.abort();
},
stop: runnerStop,
isRunning: () => false,
};
});
const session = new TelegramPollingSession({
token: "tok",
config: {},
accountId: "default",
runtime: undefined,
proxyFetch: undefined,
abortSignal: abort.signal,
runnerOptions: {},
getLastUpdateId: () => null,
persistUpdateId: async () => undefined,
log: () => undefined,
telegramTransport: undefined,
});
await session.runUntilAbort();
expect(runMock).toHaveBeenCalledTimes(2);
expect(computeBackoffMock).toHaveBeenCalledTimes(1);
expect(sleepWithAbortMock).toHaveBeenCalledTimes(1);
});
});