expect(response?.[2]?.message).toContain("Use `chat.send`");

});

it("accepts bundled channels before plugin registry normalization for message actions", async () => {

const { respond } = await runMessageActionRequest({

channel: "TELEGRAM",

action: "send",

params: { target: "123", message: "hi" },

idempotencyKey: "idem-telegram-message-action",

});

const call = lastDispatchChannelMessageActionCall();

expect(call?.channel).toBe("telegram");

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

});

it("rejects unknown send channels without delivering", async () => {

mocks.getChannelPlugin.mockReturnValue(undefined);

const { respond } = await runSend({

to: "x",

message: "hi",

channel: "definitely-not-a-real-channel-xyz",

idempotencyKey: "idem-unknown-channel",

});

expect(mocks.deliverOutboundPayloads).not.toHaveBeenCalled();

const response = firstRespondCall(respond);

expect(response?.[0]).toBe(false);

expect(response?.[2]?.message).toContain(

"unsupported channel: definitely-not-a-real-channel-xyz",

);

});

it("auto-picks the single configured channel for send", async () => {

mockDeliverySuccess("m-single-send");

} from "../../../packages/gateway-protocol/src/index.js";

import { resolveSessionAgentId } from "../../agents/agent-scope.js";

import { sendDurableMessageBatch } from "../../channels/message/runtime.js";

import { normalizeMessageChannel } from "../../utils/message-channel.js";

import { dispatchChannelMessageAction } from "../../channels/plugins/message-action-dispatch.js";

import { createOutboundSendDeps } from "../../cli/deps.js";

import {

normalizeSessionKeyPreservingOpaquePeerIds,

parseThreadSessionSuffix,

} from "../../sessions/session-key-utils.js";

import { INTERNAL_MESSAGE_CHANNEL, normalizeMessageChannel } from "../../utils/message-channel.js";

import { ADMIN_SCOPE } from "../operator-scopes.js";

import { resolveGatewayPluginConfig } from "../runtime-plugin-config.js";

import { formatForLog } from "../ws-log.js";

> {

const channelInput = readStringValue(params.requestChannel);

const normalizedChannel = channelInput ? normalizeMessageChannel(channelInput) : undefined;

if (params.rejectWebchatAsInternalOnly && normalizedChannel === INTERNAL_MESSAGE_CHANNEL) {

return {

error: errorShape(

ErrorCodes.INVALID_REQUEST,

"unsupported channel: webchat (internal-only). Use `chat.send` for WebChat UI messages or choose a deliverable channel.",

),

};

}

if (channelInput && !normalizedChannel) {

const normalizedInput = normalizeOptionalLowercaseString(channelInput) ?? "";

if (params.rejectWebchatAsInternalOnly && normalizedInput === "webchat") {

return {

error: errorShape(

ErrorCodes.INVALID_REQUEST,

"unsupported channel: webchat (internal-only). Use `chat.send` for WebChat UI messages or choose a deliverable channel.",

),

};

}

return {

error: errorShape(ErrorCodes.INVALID_REQUEST, params.unsupportedMessage(channelInput)),

};