OpenClaw源码剖析 #06 · Channel 系统：多渠道消息接入

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

export type ChannelPlugin<
  ResolvedAccount = any,
  Probe = unknown,
  Audit = unknown,
> = {
  id: ChannelId;
  meta: ChannelMeta;
  capabilities: ChannelCapabilities;
  defaults?: { queue?: { debounceMs?: number } };
  reload?: { configPrefixes: string[]; noopPrefixes?: string[] };

  // Setup Wizard
  setupWizard?: ChannelSetupWizard | ChannelSetupWizardAdapter;

  // Configuration
  config: ChannelConfigAdapter<ResolvedAccount>;
  configSchema?: ChannelConfigSchema;

  // Setup flow
  setup?: ChannelSetupAdapter;

  // Pairing
  pairing?: ChannelPairingAdapter;

  // Security & Groups
  security?: ChannelSecurityAdapter<ResolvedAccount>;
  groups?: ChannelGroupAdapter;
  mentions?: ChannelMentionAdapter;

  // Messaging
  outbound?: ChannelOutboundAdapter;
  status?: ChannelStatusAdapter<ResolvedAccount, Probe, Audit>;
  messaging?: ChannelMessagingAdapter;
  streaming?: ChannelStreamingAdapter;
  threading?: ChannelThreadingAdapter;

  // Lifecycle
  lifecycle?: ChannelLifecycleAdapter;
  heartbeat?: ChannelHeartbeatAdapter;

  // Commands & Tools
  commands?: ChannelCommandAdapter;
  agentTools?: ChannelAgentToolFactory | ChannelAgentTool[];

  // Auth
  auth?: ChannelAuthAdapter;
  approvalCapability?: ChannelApprovalCapability;
  elevated?: ChannelElevatedAdapter;

  // Gateway
  gatewayMethods?: string[];
  gateway?: ChannelGatewayAdapter<ResolvedAccount>;

  // Bindings
  bindings?: ChannelConfiguredBindingProvider;
  conversationBindings?: ChannelConversationBindingSupport;

  // Misc
  secrets?: ChannelSecretsAdapter;
  allowlist?: ChannelAllowlistAdapter;
  doctor?: ChannelDoctorAdapter;
  agentPrompt?: ChannelAgentPromptAdapter;
  directory?: ChannelDirectoryAdapter;
  resolver?: ChannelResolverAdapter;
  actions?: ChannelMessageActionAdapter;
};

1
2
3

// channels/plugins/types.core.ts
export type ChannelId = string;
// e.g. "telegram", "discord", "whatsapp", "slack"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

export type ChannelCapabilities = {
  streaming: boolean;           // 支持流式响应
  markdown: boolean;           // 支持 Markdown
  markdownCode: boolean;       // 支持代码块
  typing: boolean;             // 支持输入状态
  reactions: boolean;          // 支持反应
  multiModal: boolean;          // 支持多模态
  conversationThreading: boolean; // 支持线程
  allowFrom: boolean;           // 支持 allowFrom 过滤
  nativeMentions: boolean;      // 原生提及
  nativeCommand: boolean;       // 原生命令
};

1
2
3
4
5
6
7
8

export type ChannelLifecycleAdapter = {
  start?: (ctx: ChannelLifecycleStartContext) => Promise<void>;
  stop?: (ctx: ChannelLifecycleStopContext) => Promise<void>;
  onInboundContext?: (ctx: ChannelLifecycleInboundContext) => Promise<void>;
  onInboundMessage?: (ctx: ChannelLifecycleInboundMessage) => Promise<boolean>;
  onOutboundMessage?: (ctx: ChannelLifecycleOutboundMessage) => Promise<void>;
  onError?: (ctx: ChannelLifecycleError) => Promise<void>;
};

1
2
3
4
5
6

export type ChannelOutboundAdapter = {
  sendMessage(ctx: ChannelOutboundSendMessageContext): Promise<ChannelOutboundResult>;
  sendReaction?(ctx: ChannelOutboundSendReactionContext): Promise<ChannelOutboundResult>;
  sendTyping?(ctx: ChannelOutboundSendTypingContext): Promise<ChannelOutboundResult>;
  sendDraft?(ctx: ChannelOutboundSendDraftContext): Promise<ChannelOutboundResult>;
};

1
2
3
4
5
6

export type InboundDebouncePolicy = {
  id: string;
  debounceMs?: number;
  maxBatchSize?: number;
  maxWaitMs?: number;
};

1
2
3
4
5
6
7
8
9

export function resolveInboundConversationResolution(params: {
  cfg: OpenClawConfig;
  channel: string;
  accountId?: string;
  to?: string;
  threadId?: string | number;
  groupId?: string;
  isGroup: boolean;
}): InboundConversationResolutionResult | null;

1
2
3
4
5
6

// channels/plugins/config-helpers.ts
export function resolveChannelConfig(params: {
  cfg: OpenClawConfig;
  channelId: string;
  accountId?: string;
}): ResolvedChannelConfig | null;

1
2
3
4
5
6

export type ChannelConfigSchema = {
  type: "object";
  properties: Record<string, JsonSchemaObject>;
  required?: string[];
  additionalProperties?: boolean;
};

1
2
3
4
5
6

export async function writeChannelConfig(params: {
  cfg: OpenClawConfig;
  channelId: string;
  accountId: string;
  updates: Record<string, unknown>;
}): Promise<void>;

1
2
3
4
5
6

export function resolveAllowFrom(params: {
  cfg: OpenClawConfig;
  channelId: string;
  accountId: string;
  senderId: string;
}): AllowFromResult;

1
2
3
4
5

// 每个 Adapter 都是可选的
setup?: ChannelSetupAdapter;      // 可选
pairing?: ChannelPairingAdapter;   // 可选
security?: ChannelSecurityAdapter; // 可选
// ...