}

});

it("returns a timeout error when capabilities diagnostics exceed the timeout", async () => {

let diagnosticSignal: AbortSignal | undefined;

const fetchPermissionsSpy = vi

.spyOn(sendModule, "fetchChannelPermissionsDiscord")

.mockImplementation(

async (_channelId, opts) =>

await new Promise<never>((_, reject) => {

diagnosticSignal = opts.signal;

opts.signal?.addEventListener(

"abort",

() => reject(new Error("permission lookup aborted")),

{ once: true },

);

}),

);

try {

const cfg = createCfg();

const diagnostics = await discordPlugin.status!.buildCapabilitiesDiagnostics!({

account: resolveAccount(cfg),

timeoutMs: 10,

cfg,

target: "channel:222",

});

const timeoutPerms = recordField(diagnostics?.details?.permissions, "permissions");

expect(String(timeoutPerms.error)).toContain("timed out");

expect(diagnostics?.lines?.[0]?.tone).toBe("error");

expect(objectArgAt(fetchPermissionsSpy, 0, 1).timeoutMs).toBe(10);

expect(diagnosticSignal?.aborted).toBe(true);

} finally {

fetchPermissionsSpy.mockRestore();

}

});

it("uses direct Discord startup helpers for async startup enrichment", async () => {

const runtimeProbeDiscord = vi.fn(async () => {

throw new Error("runtime Discord probe should not be used");

setThreadBindingIdleTimeoutBySessionKey,

setThreadBindingMaxAgeBySessionKey,

} from "./monitor/thread-bindings.session-updates.js";

import { withAbortTimeout } from "./monitor/timeouts.js";

import { looksLikeDiscordTargetId, normalizeDiscordMessagingTarget } from "./normalize.js";

import { discordOutbound } from "./outbound-adapter.js";

import { resolveDiscordOutboundSessionRoute } from "./outbound-session-route.js";

}

return lines;

},

buildCapabilitiesDiagnostics: async ({ account, target }) => {

buildCapabilitiesDiagnostics: async ({ account, target, timeoutMs }) => {

if (!target?.trim()) {

return undefined;

}

},

};

try {

const perms = await (

await loadDiscordSendModule()

).fetchChannelPermissionsDiscord(parsedTarget.id, {

cfg: statusCfg,

token,

accountId: account.accountId ?? undefined,

const sendModule = await loadDiscordSendModule();

const perms = await withAbortTimeout({

timeoutMs,

createTimeoutError: () =>

new Error(`Capabilities diagnostic timed out after ${timeoutMs}ms`),

run: async (signal) =>

await sendModule.fetchChannelPermissionsDiscord(parsedTarget.id, {

cfg: statusCfg,

token,

accountId: account.accountId ?? undefined,

signal,

timeoutMs,

}),

});

const requiredPermissions = resolveRequiredDiscordChannelPermissions(perms.channelType);

const missingRequired = requiredPermissions.filter(

expect(result.account.config.retry).toEqual({ attempts: 7 });

});

it("applies a caller timeout to a dedicated REST client", () => {

const cfg = { channels: { discord: { token: "discord-token" } } } as OpenClawConfig;

const result = createDiscordRestClient({ cfg, timeoutMs: 250 });

expect(result.rest.options.timeout).toBe(250);

});

it("still fails closed when no explicit token is provided and config token is unresolved", () => {

vi.stubEnv("DISCORD_BOT_TOKEN", "env-token");

const cfg = {

accountId?: string;

rest?: RequestClient;

retry?: RetryConfig;

signal?: AbortSignal;

timeoutMs?: number;

verbose?: boolean;

};

cfg: OpenClawConfig,

rest?: RequestClient,

proxyFetch?: typeof fetch,

signal?: AbortSignal,

timeoutMs?: number,

) {

if (rest) {

return rest;

}

const resolvedProxyFetch = proxyFetch ?? resolveDiscordProxyFetchForAccount(account, cfg);

return createDiscordRequestClient(

token,

resolvedProxyFetch ? { fetch: resolvedProxyFetch } : undefined,

);

return createDiscordRequestClient(token, {

...(resolvedProxyFetch ? { fetch: resolvedProxyFetch } : {}),

...(signal ? { signal } : {}),

...(timeoutMs !== undefined ? { timeout: timeoutMs } : {}),

});

}

function resolveAccountWithoutToken(params: {

accountId: account.accountId,

fallbackToken: account.token,

});

const rest = resolveRest(token, account, resolvedCfg, opts.rest, proxyContext.proxyFetch);

const rest = resolveRest(

token,

account,

resolvedCfg,

opts.rest,

proxyContext.proxyFetch,

opts.signal,

opts.timeoutMs,

);

return { token, rest, account };

}

baseUrl?: string;

apiVersion?: number;

userAgent?: string;

signal?: AbortSignal;

timeout?: number;

queueRequests?: boolean;

maxQueueSize?: number;

const controller = new AbortController();

const timeout = setTimeout(() => controller.abort(), this.options.timeout ?? 15_000);

timeout.unref?.();

const signal = this.options.signal

? AbortSignal.any([this.options.signal, controller.signal])

: controller.signal;

this.requestControllers.add(controller);

try {

const response = await (this.customFetch ?? fetch)(url, {

method,

headers,

body: await normalizeFetchBody(body, headers),

signal: controller.signal,

signal,

});

const text = await response.text();

const parsed = coerceResponseBody(text);

expect(abortable.receivedSignal.aborted).toBe(true);

});

it("lets a caller signal cancel active proxied fetches", async () => {

const abortable = createAbortableFetchMock();

const controller = new AbortController();

const client = createDiscordRequestClient("Bot test-token", {

fetch: abortable.fetch as never,

queueRequests: false,

signal: controller.signal,

timeout: 5_000,

});

const request = client.get("/channels/123/messages");

await vi.waitFor(() => expect(abortable.fetch).toHaveBeenCalledTimes(1));

controller.abort();

await expectAbortError(request);

expect(abortable.receivedSignal?.aborted).toBe(true);

});

it("provides the REST client's timeout signal even without a caller signal", async () => {

let receivedSignal: AbortSignal | undefined;

channelId: string,

opts: DiscordReactOpts,

): Promise<DiscordPermissionsSummary> {

opts.signal?.throwIfAborted();

const rest = resolveDiscordRest(opts);

const channel = await getChannel(rest, channelId);

opts.signal?.throwIfAborted();

const channelType = "type" in channel ? channel.type : undefined;

const guildId = "guild_id" in channel ? channel.guild_id : undefined;

if (!guildId) {

}

const botId = await fetchBotUserId(rest);

opts.signal?.throwIfAborted();

const [guild, member] = await Promise.all([

getGuild(rest, guildId),

getGuildMember(rest, guildId, botId),

]);

opts.signal?.throwIfAborted();

const permissions = resolveMemberChannelPermissionBits({

guildId,

expect(res.isDm).toBe(false);

});

it("stops permission lookup when the caller deadline aborts", async () => {

const { rest, getMock } = makeDiscordRest();

const controller = new AbortController();

getMock.mockImplementationOnce(async () => {

controller.abort();

return {

id: "chan1",

guild_id: "guild1",

permission_overwrites: [],

};

});

await expect(

fetchChannelPermissionsDiscord("chan1", {

rest,

token: "t",

cfg: DISCORD_TEST_CFG,

signal: controller.signal,

}),

).rejects.toMatchObject({ name: "AbortError" });

expect(getMock).toHaveBeenCalledTimes(1);

});

it("treats Administrator as all permissions despite overwrites", async () => {

const { rest, getMock } = makeDiscordRest();

getMock

rest?: RequestClient;

verbose?: boolean;

retry?: RetryConfig;

signal?: AbortSignal;

timeoutMs?: number;

};

export type DiscordReactionRuntimeContext = DiscordRuntimeAccountContext & {