]);

});

it("forwards gateway client scopes into Telegram send target resolution", async () => {

await handleTelegramAction(

{

action: "sendMessage",

to: "@testchannel",

content: "Hello from CLI",

},

telegramConfig(),

{ gatewayClientScopes: ["operator.write"] },

);

const call = mockCall(sendMessageTelegram, 0, "gateway-scoped send");

expect(requireRecord(call[2], "gateway-scoped send options").gatewayClientScopes).toEqual([

"operator.write",

]);

});

it("forwards gateway client scopes into Telegram poll target resolution", async () => {

await handleTelegramAction(

{

action: "poll",

to: "@testchannel",

question: "Ready?",

answers: ["Yes", "No"],

},

telegramConfig(),

{ gatewayClientScopes: ["operator.write"] },

);

const call = mockCall(sendPollTelegram, 0, "gateway-scoped poll");

expect(requireRecord(call[2], "gateway-scoped poll options").gatewayClientScopes).toEqual([

"operator.write",

]);

});

it.each([

{

name: "react",

mediaReadFile?: (filePath: string) => Promise<Buffer>;

sessionKey?: string | null;

inboundEventKind?: string;

gatewayClientScopes?: readonly string[];

},

): Promise<AgentToolResult<unknown>> {

const { action, accountId } = {

mediaUrl: mediaUrl || undefined,

mediaLocalRoots: options?.mediaLocalRoots,

mediaReadFile: options?.mediaReadFile,

gatewayClientScopes: options?.gatewayClientScopes,

buttons,

replyToMessageId: replyToMessageId ?? undefined,

messageThreadId: messageThreadId ?? undefined,

messageThreadId: messageThreadId ?? undefined,

isAnonymous: isAnonymous ?? undefined,

silent: silent ?? undefined,

gatewayClientScopes: options?.gatewayClientScopes,

},

);

notifyVisibleOutboundSuccess(to, messageThreadId);

{},

{

mediaLocalRoots: [],

mediaReadFile: undefined,

sessionKey: "telegram-session",

gatewayClientScopes: undefined,

},

);

});

cfg,

accountId,

mediaLocalRoots,

mediaReadFile,

sessionKey,

inboundEventKind,

toolContext,

gatewayClientScopes,

}) => {

const telegramAction = resolveTelegramMessageActionName(action);

if (!telegramAction) {

: {}),

},

cfg,

{ mediaLocalRoots, sessionKey, inboundEventKind },

{ mediaLocalRoots, mediaReadFile, sessionKey, inboundEventKind, gatewayClientScopes },

);

},

};

token: "tok",

}),

);

expect(

mockObjectArg(createTelegramBotMock, "createTelegramBot").updateOffset,

).toBeUndefined();

expect(mockObjectArg(createTelegramBotMock, "createTelegramBot").updateOffset).toEqual({

lastUpdateId: null,

onUpdateId: expect.any(Function),

});

expect(init).toHaveBeenCalledBefore(handleUpdate);

expect(handleUpdate).toHaveBeenCalledWith({ update_id: 42, message: { text: "hello" } });

} finally {

const fetchAbortController = new AbortController();

this.#activeFetchAbort = fetchAbortController;

const telegramTransport = this.#transportState.acquireForNextCycle();

const updateOffset = this.opts.isolatedIngress?.enabled

? undefined

: {

lastUpdateId: this.opts.getLastUpdateId(),

onUpdateId: this.opts.persistUpdateId,

};

const updateOffset = {

lastUpdateId: this.opts.getLastUpdateId(),

onUpdateId: this.opts.persistUpdateId,

};

try {

return createTelegramBot({

token: this.opts.token,

TelegramIngressWorkerMessage,

TelegramIngressWorkerOptions,

} from "./telegram-ingress-worker.js";

import { writeTelegramUpdateOffset } from "./update-offset-store.js";

const options = workerData as TelegramIngressWorkerOptions;

const pollLimit = 100;

});

if (lastUpdateId === null || updateId > lastUpdateId) {

lastUpdateId = updateId;

await writeTelegramUpdateOffset({

accountId: options.accountId,

botToken: options.token,

updateId,

});

}

post({ type: "spooled", updateId, queued: result.length });

}

};

toolContext?: ChannelThreadingToolContext;

dryRun?: boolean;

gatewayClientScopes?: readonly string[];

};

export type ChannelToolSend = {

"send-test-message-action-media-roots",

);

const { respond } = await runMessageActionRequest({

channel: "telegram",

action: "sendAttachment",

params: { chatId: "123", mediaUrl: `${TEST_AGENT_WORKSPACE}/render.png` },

agentId: "work",

idempotencyKey: "idem-message-action-media-roots",

});

const { respond } = await runMessageActionRequest(

{

channel: "telegram",

action: "sendAttachment",

params: { chatId: "123", mediaUrl: `${TEST_AGENT_WORKSPACE}/render.png` },

agentId: "work",

idempotencyKey: "idem-message-action-media-roots",

},

{ connect: { scopes: ["operator.write"] } },

);

expect(firstRespondCall(respond)[0]).toBe(true);

const actionCall = lastDispatchChannelMessageActionCall();

expect(actionCall?.mediaLocalRoots).toContain(TEST_AGENT_WORKSPACE);

expect(actionCall?.gatewayClientScopes).toEqual(["operator.write"]);

});

it("forces senderIsOwner=false for narrowly-scoped callers but honors it for full operators", async () => {

),

toolContext: request.toolContext,

dryRun: false,

gatewayClientScopes: client?.connect?.scopes ?? [],

});

if (!handled) {

const error = errorShape(