computeInteractionCallbackUrl,

createMattermostInteractionHandler,

generateInteractionToken,

getInteractionCallbackUrl,

getInteractionSecret,

resolveInteractionCallbackPath,

resolveInteractionCallbackUrl,

});

});

// ── Callback URL registry ────────────────────────────────────────────

describe("callback URL registry", () => {

it("stores and retrieves callback URLs", () => {

setInteractionCallbackUrl("acct1", "http://localhost:18789/mattermost/interactions/acct1");

expect(getInteractionCallbackUrl("acct1")).toBe(

"http://localhost:18789/mattermost/interactions/acct1",

);

});

it("returns undefined for unknown account", () => {

expect(getInteractionCallbackUrl("nonexistent-account-id")).toBeUndefined();

});

});

describe("resolveInteractionCallbackUrl", () => {

afterEach(() => {

for (const accountId of ["cached", "default", "acct", "myaccount"]) {

callbackUrls.set(accountId, url);

}

export function getInteractionCallbackUrl(accountId: string): string | undefined {

return callbackUrls.get(accountId);

}

type InteractionCallbackConfig = Pick<OpenClawConfig, "gateway" | "channels"> & {

interactions?: {

callbackBaseUrl?: string;

import {

ChunkedMediaApi,

UploadDailyLimitExceededError,

isChunkedUploadImplemented,

} from "./media-chunked.js";

import type { UploadCacheAdapter } from "./media.js";

import { UPLOAD_PREPARE_FALLBACK_CODE } from "./retry.js";

});

});

describe("media-chunked: isChunkedUploadImplemented", () => {

it("returns true for the filled-in module", () => {

expect(isChunkedUploadImplemented()).toBe(true);

});

});

describe("media-chunked: ChunkedMediaApi.uploadChunked", () => {

beforeEach(() => {

originalFetch = globalThis.fetch;

}

}

// ============ Legacy functional facade ============

/**

* @deprecated The chunked uploader is always implemented.

*

* Legacy feature flag. The chunked uploader is fully implemented, so this

* returns `true`. Retained so that older call sites can be converted

* progressively.

*/

export function isChunkedUploadImplemented(): boolean {

return true;

}

// ============ Source resolution ============

/**

// Whatsapp tests cover approval reactions plugin behavior.

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

import {

buildWhatsAppApprovalReactionHint,

clearWhatsAppApprovalReactionTargetsForTest,

extractWhatsAppApprovalPromptBinding,

maybeResolveWhatsAppApprovalReaction,

resolverMocks.isApprovalNotFoundError.mockReturnValue(false);

});

it("renders thumbs-only reaction choices for allowed decisions", () => {

expect(buildWhatsAppApprovalReactionHint(["allow-once", "deny"])).toBe(

"React with:\n\n👍 Allow Once\n👎 Deny",

);

});

it("exposes allow-always as a reaction choice when allowed", () => {

expect(buildWhatsAppApprovalReactionHint(["allow-once", "allow-always", "deny"])).toBe(

"React with:\n\n👍 Allow Once\n♾️ Allow Always\n👎 Deny",

);

});

it("registers reaction state when only allow-always is available", async () => {

expect(

registerWhatsAppApprovalReactionTarget({

// Whatsapp plugin module implements approval reactions behavior.

import type { WAMessage } from "baileys";

import {

buildApprovalReactionHint,

createApprovalReactionTargetStore,

listApprovalReactionBindings,

resolveApprovalReactionTarget,

return listApprovalReactionBindings({ allowedDecisions });

}

export function buildWhatsAppApprovalReactionHint(

allowedDecisions: readonly ExecApprovalReplyDecision[],

): string | null {

return buildApprovalReactionHint({ allowedDecisions });

}

function normalizeApprovalDecision(value: string): ExecApprovalReplyDecision | null {

const normalized = value.trim().toLowerCase();

if (normalized === "always") {

import {

isXaiToolEnabled,

resolveFallbackXaiAuth,

resolveFallbackXaiApiKey,

resolveXaiToolApiKey,

resolveXaiToolApiKeyWithAuth,

} from "./tool-auth-shared.js";

it("prefers plugin web search keys over legacy grok keys", () => {

expect(

resolveFallbackXaiApiKey({

resolveFallbackXaiAuth({

plugins: {

entries: {

xai: {

},

},

}),

).toBe("plugin-key");

).toEqual({

apiKey: "plugin-key",

source: "plugins.entries.xai.config.webSearch.apiKey",

});

});

it("returns source metadata and managed markers for fallback auth", () => {

return readLegacyGrokFallbackAuth(cfg);

}

export function resolveFallbackXaiApiKey(cfg?: OpenClawConfig): string | undefined {

const plugin = readPluginXaiWebSearchApiKeyResult(cfg);

if (plugin.status === "available") {

return plugin.value;

}

if (plugin.status === "blocked") {

return undefined;

}

const legacy = readLegacyGrokApiKeyResult(cfg);

return legacy.status === "available" ? legacy.value : undefined;

}

export function resolveXaiToolApiKey(params: {

runtimeConfig?: OpenClawConfig;

sourceConfig?: OpenClawConfig;