};

}

/**

* Lists message actions available across registered channel plugins.

*/

export function listChannelMessageActions(cfg: OpenClawConfig): ChannelMessageActionName[] {

const actions = new Set<ChannelMessageActionName>(["send", "broadcast"]);

for (const plugin of listChannelPlugins()) {

for (const action of resolveMessageActionDiscoveryForPlugin({

pluginId: plugin.id,

actions: plugin.actions,

context: { cfg },

includeActions: true,

}).actions) {

actions.add(action);

}

}

return Array.from(actions);

}

/**

* Lists actions whose schemas do not block cross-channel tool usage.

*/

channelSupportsMessageCapability,

channelSupportsMessageCapabilityForChannel,

listCrossChannelSchemaSupportedMessageActions,

listChannelMessageActions,

listChannelMessageCapabilities,

listChannelMessageCapabilitiesForChannel,

resolveChannelMessageToolMediaSourceParamKeys,

createTestRegistry([{ pluginId: "demo-unified", source: "test", plugin: unifiedPlugin }]),

);

expect(listChannelMessageActions({} as OpenClawConfig)).toEqual(["send", "broadcast", "react"]);

expect(listChannelMessageCapabilities({} as OpenClawConfig)).toEqual(["presentation"]);

expect(

resolveChannelMessageToolSchemaProperties({

createTestRegistry([{ pluginId: "demo-crashing", source: "test", plugin: crashingPlugin }]),

);

expect(listChannelMessageActions({} as OpenClawConfig)).toEqual(["send", "broadcast"]);

expect(listChannelMessageCapabilities({} as OpenClawConfig)).toStrictEqual([]);

expect(errorSpy).toHaveBeenCalledTimes(1);

expect(listChannelMessageActions({} as OpenClawConfig)).toEqual(["send", "broadcast"]);

expect(listChannelMessageCapabilities({} as OpenClawConfig)).toStrictEqual([]);

expect(errorSpy).toHaveBeenCalledTimes(1);

});

getLoadedChannelPlugin: getLoadedChannelPluginMock,

}));

import {

resolveSingleAccountKeysToMove,

shouldMoveSingleAccountChannelKey,

} from "./setup-promotion-helpers.js";

import { resolveSingleAccountKeysToMove } from "./setup-promotion-helpers.js";

describe("setup promotion helpers", () => {

beforeEach(() => {

});

expect(

shouldMoveSingleAccountChannelKey({

resolveSingleAccountKeysToMove({

channelKey: "demo",

key: "customAuth",

channel: {

customAuth: "secret",

},

}),

).toBe(true);

).toEqual(["customAuth"]);

expect(getBundledChannelPluginMock).toHaveBeenCalledWith("demo");

});

return asPromotionSurface(getBundledChannelPlugin(channelKey)?.setup);

}

/**

* Returns whether one root-level channel key should move into account config.

*/

export function shouldMoveSingleAccountChannelKey(params: {

channelKey: string;

key: string;

}): boolean {

// Common keys move for every channel; channel-owned setup surfaces can add

// plugin-specific keys without teaching core about that channel's schema.

if (isCommonSingleAccountPromotionKey(params.key)) {

return true;

}

const loadedContractKeys = getLoadedChannelSetupPromotionSurface(

params.channelKey,

)?.singleAccountKeysToMove;

if (loadedContractKeys?.includes(params.key)) {

return true;

}

const bundledContractKeys = getBundledChannelSetupPromotionSurface(

params.channelKey,

)?.singleAccountKeysToMove;

if (bundledContractKeys?.includes(params.key)) {

return true;

}

return false;

}

/**

* Resolves all root-level keys eligible for single-account promotion.

*/

import { setActivePluginRegistry } from "../plugins/runtime.js";

import { createChannelTestPluginBase, createTestRegistry } from "../test-utils/channel-plugins.js";

import {

deliveryContextFromRoute,

formatConversationTarget,

normalizeRoutableChannelRoute,

resolveConversationDeliveryTarget,

routeFromBindingRecord,

routeFromConversationRef,

routeFromDeliveryContext,

routeToDeliveryFields,

} from "./route-projection.js";

);

});

it("round-trips delivery context through channel route metadata", () => {

const route = routeFromDeliveryContext({

channel: " Slack ",

to: " channel:C123 ",

accountId: " work ",

threadId: " 177000.123 ",

});

expect(route).toEqual({

channel: "slack",

accountId: "work",

target: { to: "channel:C123" },

thread: { id: "177000.123" },

});

expect(deliveryContextFromRoute(route)).toEqual({

channel: "slack",

to: "channel:C123",

accountId: "work",

threadId: "177000.123",

});

});

it("formats plugin-defined conversation targets via channel messaging hooks", () => {

expect(

formatConversationTarget({ channel: "room-chat", conversationId: "!room:example" }),

});

});

it("narrows only routable routes", () => {

expect(normalizeRoutableChannelRoute({ channel: "slack" })).toBeUndefined();

});

});

} from "../infra/outbound/session-binding-service.js";

import {

normalizeChannelRouteRef,

type ChannelRouteChatType,

type ChannelRouteRef,

} from "../plugin-sdk/channel-route.js";

import {

normalizeConversationTargetParams,

type ConversationTargetParams,

} from "../utils/conversation-target.js";

import {

channelRouteFromDeliveryContext,

deliveryContextFromChannelRoute,

normalizeDeliveryContext,

type DeliveryContext,

} from "../utils/delivery-context.shared.js";

import { getChannelPlugin, normalizeChannelId } from "./plugins/registry.js";

return { to };

}

/** Channel route normalized enough to address an outbound delivery target. */

export type RoutableChannelRouteRef = ChannelRouteRef & {

channel: string;

target: {

to: string;

rawTo?: string;

chatType?: ChannelRouteChatType;

};

};

/** Normalizes a route and rejects routes that cannot address a channel target. */

export function normalizeRoutableChannelRoute(

route?: ChannelRouteRef | null,

): RoutableChannelRouteRef | undefined {

const normalized = normalizeChannelRouteRef({

channel: route?.channel,

accountId: route?.accountId,

to: route?.target?.to,

rawTo: route?.target?.rawTo,

chatType: route?.target?.chatType,

threadId: route?.thread?.id,

threadKind: route?.thread?.kind,

threadSource: route?.thread?.source,

});

if (!normalized?.channel || !normalized.target?.to) {

return undefined;

}

return normalized as RoutableChannelRouteRef;

}

/** Converts legacy delivery context metadata into a channel route. */

export function routeFromDeliveryContext(context?: DeliveryContext): ChannelRouteRef | undefined {

return channelRouteFromDeliveryContext(normalizeDeliveryContext(context));

}

/** Converts a channel route back to legacy delivery context metadata. */

export function deliveryContextFromRoute(route?: ChannelRouteRef): DeliveryContext | undefined {

return deliveryContextFromChannelRoute(route);