createMessageReceiptFromOutboundResults,

defineChannelMessageAdapter,

} from "openclaw/plugin-sdk/channel-outbound";

import { getChatChannelMeta } from "openclaw/plugin-sdk/channel-plugin-common";

import {

DEFAULT_ACCOUNT_ID,

listQaChannelAccountIds,

resolveDefaultQaChannelAccountId,

resolveQaChannelAccount,

} from "./accounts.js";

import { DEFAULT_ACCOUNT_ID } from "./accounts.js";

import { buildQaTarget, normalizeQaTarget, parseQaTarget } from "./bus-client.js";

import { qaChannelMessageActions } from "./channel-actions.js";

import { qaChannelPluginConfigSchema } from "./config-schema.js";

import { createQaChannelPluginBase, QA_CHANNEL_ID, qaChannelRuntimeMeta } from "./channel-base.js";

import { startQaGatewayAccount } from "./gateway.js";

import { sendQaChannelText } from "./outbound.js";

import type { ChannelPlugin } from "./runtime-api.js";

import { applyQaSetup } from "./setup.js";

import { qaChannelStatus } from "./status.js";

import type { CoreConfig, ResolvedQaChannelAccount } from "./types.js";

const CHANNEL_ID = "qa-channel" as const;

const meta = {

...getChatChannelMeta(CHANNEL_ID),

id: CHANNEL_ID,

label: "QA Channel",

selectionLabel: "QA Channel",

docsPath: "/channels/qa-channel",

blurb: "Synthetic QA channel for OpenClaw QA runs.",

};

const qaChannelMessageAdapter = defineChannelMessageAdapter({

id: CHANNEL_ID,

id: QA_CHANNEL_ID,

durableFinal: {

capabilities: {

text: true,

return {

messageId: result.messageId,

receipt: createMessageReceiptFromOutboundResults({

results: [{ channel: CHANNEL_ID, messageId: result.messageId }],

results: [{ channel: QA_CHANNEL_ID, messageId: result.messageId }],

threadId,

replyToId,

kind: "text",

export const qaChannelPlugin: ChannelPlugin<ResolvedQaChannelAccount> = createChatChannelPlugin({

base: {

id: CHANNEL_ID,

meta,

capabilities: {

chatTypes: ["direct", "group"],

},

reload: { configPrefixes: ["channels.qa-channel"] },

configSchema: qaChannelPluginConfigSchema,

setup: {

applyAccountConfig: ({ cfg, accountId, input }) =>

applyQaSetup({

cfg,

accountId,

input: input as Record<string, unknown>,

}),

},

config: {

listAccountIds: (cfg) => listQaChannelAccountIds(cfg as CoreConfig),

resolveAccount: (cfg, accountId) =>

resolveQaChannelAccount({ cfg: cfg as CoreConfig, accountId }),

defaultAccountId: (cfg) => resolveDefaultQaChannelAccountId(cfg as CoreConfig),

isConfigured: (account) => account.configured,

resolveAllowFrom: ({ cfg, accountId }) =>

resolveQaChannelAccount({ cfg: cfg as CoreConfig, accountId }).config.allowFrom,

resolveDefaultTo: ({ cfg, accountId }) =>

resolveQaChannelAccount({ cfg: cfg as CoreConfig, accountId }).config.defaultTo,

},

...createQaChannelPluginBase(qaChannelRuntimeMeta),

messaging: {

normalizeTarget: normalizeQaTarget,

inferTargetChatType: ({ to }) => parseQaTarget(to).chatType,

const baseRoute = buildChannelOutboundSessionRoute({

cfg,

agentId,

channel: CHANNEL_ID,

channel: QA_CHANNEL_ID,

accountId,

peer: {

kind:

id: buildQaTarget(parsed),

},

chatType: parsed.chatType,

from: `qa-channel:${accountId ?? DEFAULT_ACCOUNT_ID}`,

from: `${QA_CHANNEL_ID}:${accountId ?? DEFAULT_ACCOUNT_ID}`,

to: buildQaTarget(parsed),

});

return buildThreadAwareOutboundSessionRoute({

status: qaChannelStatus,

gateway: {

startAccount: async (ctx) => {

await startQaGatewayAccount(CHANNEL_ID, meta.label, ctx);

await startQaGatewayAccount(QA_CHANNEL_ID, qaChannelRuntimeMeta.label, ctx);

},

},

actions: qaChannelMessageActions,

deliveryMode: "direct",

},

attachedResults: {

channel: CHANNEL_ID,

channel: QA_CHANNEL_ID,

sendText: async ({ cfg, to, text, accountId, threadId, replyToId }) =>

await sendQaChannelText({

cfg: cfg as CoreConfig,