expect(result).toBeNull();

});

it("accepts targeted bot commands as explicit mentions in requireMention groups", async () => {

const logger = { info: vi.fn() };

const text = "/deploy@bot check status";

const result = await resolveTelegramBody({

cfg: { channels: { telegram: {} } } as never,

msg: {

message_id: 8,

date: 1_700_000_008,

chat: { id: -1001234567890, type: "supergroup", title: "Test Group" },

from: { id: 46, first_name: "Eve" },

text,

entities: [{ type: "bot_command", offset: 0, length: "/deploy@bot".length }],

} as never,

isGroup: true,

chatId: -1001234567890,

senderId: "46",

senderUsername: "",

groupConfig: { requireMention: true } as never,

requireMention: true,

logger,

});

expect(logger.info).not.toHaveBeenCalledWith(

{ chatId: -1001234567890, reason: "no-mention" },

"skipping group message",

);

expect(result?.rawBody).toBe(text);

expect(result?.effectiveWasMentioned).toBe(true);

});

it("does not transcribe group audio for unauthorized senders", async () => {

transcribeFirstAudioMock.mockReset();

const logger = { info: vi.fn() };

}

});

it("treats targeted bot command captions as mentions before media download", async () => {

loadConfig.mockReturnValue({

channels: {

telegram: {

groupPolicy: "open",

groups: { "*": { requireMention: true } },

},

},

});

const fetchSpy = vi.spyOn(globalThis, "fetch").mockImplementation(async () => {

throw new Error("MediaFetchError: ECONNRESET");

});

try {

createTelegramBot({ token: "tok" });

const handler = getOnHandler("message") as (ctx: Record<string, unknown>) => Promise<void>;

const caption = "/inspect@openclaw_bot";

await handler({

message: {

chat: { id: -100456, type: "supergroup", title: "Ops Chat" },

message_id: 81184,

date: 1736380800,

caption,

caption_entities: [{ type: "bot_command", offset: 0, length: caption.length }],

photo: [{ file_id: "p1" }],

from: { id: 55, is_bot: false, first_name: "u" },

},

me: { id: 999, username: "openclaw_bot" },

getFile: async () => ({ file_path: "photos/p1.jpg" }),

});

expect(sendMessageSpy).toHaveBeenCalledWith(

-100456,

"⚠️ Failed to download media. Please try again.",

{

reply_parameters: {

message_id: 81184,

allow_sending_without_reply: true,

},

},

);

expect(replySpy).not.toHaveBeenCalled();

} finally {

fetchSpy.mockRestore();

}

});

it("notifies requireMention group replies to the bot when media download fails", async () => {

loadConfig.mockReturnValue({

channels: {

return false;

}

function isBotCommandAddressedToMention(command: string, mention: string): boolean {

const normalized = normalizeLowercaseStringOrEmpty(command);

if (!normalized.startsWith("/") || !normalized.endsWith(mention)) {

return false;

}

const atIndex = normalized.lastIndexOf(mention);

return atIndex > 1;

}

export function hasBotMention(msg: Message, botUsername: string) {

const { text, entities } = getTelegramTextParts(msg);

const mention = normalizeLowercaseStringOrEmpty(`@${botUsername}`);

if (hasStandaloneTelegramMention(normalizeLowercaseStringOrEmpty(text), mention)) {

return true;

}

for (const ent of entities) {

if (ent.type !== "mention") {

continue;

}

const slice = text.slice(ent.offset, ent.offset + ent.length);

if (normalizeLowercaseStringOrEmpty(slice) === mention) {

if (ent.type === "mention" && normalizeLowercaseStringOrEmpty(slice) === mention) {

return true;

}

if (ent.type === "bot_command" && isBotCommandAddressedToMention(slice, mention)) {

return true;

}

}

).toBe(true);

});

it("matches bot command entities addressed to this bot", () => {

const text = "/deploy@gaian check status";

expect(

hasBotMention(

{

text,

entities: [{ type: "bot_command", offset: 0, length: "/deploy@gaian".length }],

chat: { id: 1, type: "supergroup" },

} as any,

"gaian",

),

).toBe(true);

});

it("does not match bot command entities addressed to another bot", () => {

const text = "/deploy@other_bot check status";

expect(

hasBotMention(

{

text,

entities: [{ type: "bot_command", offset: 0, length: "/deploy@other_bot".length }],

chat: { id: 1, type: "supergroup" },

} as any,

"gaian",

),

).toBe(false);

});

it("matches mention followed by punctuation", () => {

expect(

hasBotMention(