gewe-openclaw 2026.3.13 → 2026.3.23

package/src/channel-status.ts

@@ -0,0 +1,186 @@
+import type { ChannelStatusAdapter, ChannelStatusIssue } from "openclaw/plugin-sdk/channel-runtime";
+
+import type { ResolvedGeweAccount } from "./accounts.js";
+import { collectKnownGeweGroupEntries, collectKnownGewePeerEntries } from "./channel-directory.js";
+import { getGeweDirectoryCacheCounts } from "./directory-cache.js";
+import { CHANNEL_CONFIG_KEY } from "./constants.js";
+import { getGeweProfile } from "./group-binding.js";
+import { normalizeGeweBindingConversationId } from "./group-binding.js";
+import { normalizeAccountId, type OpenClawConfig } from "./openclaw-compat.js";
+import { readGeweAllowFromStore } from "./pairing-store.js";
+
+type GeweStatusProbe = {
+  ok: boolean;
+  latencyMs?: number;
+  self?: {
+    wxid: string;
+    nickName?: string;
+  };
+  error?: string;
+};
+
+type BindingLike = {
+  match?: {
+    channel?: string;
+    accountId?: string;
+    peer?: {
+      kind?: string;
+      id?: string;
+    };
+  };
+};
+
+const CHANNEL_ALIASES = new Set(["gewe-openclaw", "gewe", "wechat", "wx"]);
+
+function listConfigBindings(cfg: OpenClawConfig): BindingLike[] {
+  return Array.isArray(cfg.bindings) ? (cfg.bindings as BindingLike[]) : [];
+}
+
+function normalizeBindingChannel(value?: string): string {
+  const trimmed = value?.trim().toLowerCase() ?? "";
+  return CHANNEL_ALIASES.has(trimmed) ? CHANNEL_CONFIG_KEY : trimmed;
+}
+
+function bindingMatchesAccount(bindingAccountId: string | undefined, accountId: string): boolean {
+  const trimmed = bindingAccountId?.trim();
+  if (!trimmed) {
+    return accountId === "default";
+  }
+  if (trimmed === "*") {
+    return true;
+  }
+  return normalizeAccountId(trimmed) === accountId;
+}
+
+function countExplicitBindings(cfg: OpenClawConfig, accountId: string): number {
+  let count = 0;
+  for (const binding of listConfigBindings(cfg)) {
+    if (normalizeBindingChannel(binding.match?.channel) !== CHANNEL_CONFIG_KEY) {
+      continue;
+    }
+    if (!bindingMatchesAccount(binding.match?.accountId, accountId)) {
+      continue;
+    }
+    const normalizedId = normalizeGeweBindingConversationId(binding.match?.peer?.id);
+    if (!normalizedId) {
+      continue;
+    }
+    count += 1;
+  }
+  return count;
+}
+
+function countGroupOverrides(account: ResolvedGeweAccount): number {
+  return Object.entries(account.config.groups ?? {}).filter(
+    ([, group]) => Array.isArray(group?.allowFrom) && group.allowFrom.length > 0,
+  ).length;
+}
+
+export const geweStatus: ChannelStatusAdapter<ResolvedGeweAccount, GeweStatusProbe> = {
+  probeAccount: async ({ account }) => {
+    const startedAt = Date.now();
+    try {
+      const profile = await getGeweProfile({ account });
+      return {
+        ok: true,
+        latencyMs: Date.now() - startedAt,
+        self: {
+          wxid: profile.wxid,
+          nickName: profile.nickName,
+        },
+      };
+    } catch (err) {
+      return {
+        ok: false,
+        latencyMs: Date.now() - startedAt,
+        error: String(err),
+      };
+    }
+  },
+  buildChannelSummary: async ({ snapshot }) => ({
+    configured: snapshot.configured ?? false,
+    tokenSource: snapshot.tokenSource ?? "none",
+    running: snapshot.running ?? false,
+    mode: snapshot.mode ?? null,
+    lastStartAt: snapshot.lastStartAt ?? null,
+    lastStopAt: snapshot.lastStopAt ?? null,
+    lastError: snapshot.lastError ?? null,
+    lastInboundAt: snapshot.lastInboundAt ?? null,
+    lastOutboundAt: snapshot.lastOutboundAt ?? null,
+    apiReachable: snapshot.apiReachable ?? false,
+    apiLatencyMs: snapshot.apiLatencyMs ?? null,
+    self: snapshot.self ?? null,
+    knownPeersCount: snapshot.knownPeersCount ?? 0,
+    knownGroupsCount: snapshot.knownGroupsCount ?? 0,
+    cachedGroupMemberCount: snapshot.cachedGroupMemberCount ?? 0,
+    explicitBindingCount: snapshot.explicitBindingCount ?? 0,
+    groupOverrideCount: snapshot.groupOverrideCount ?? 0,
+    pairingAllowFromCount: snapshot.pairingAllowFromCount ?? 0,
+  }),
+  buildAccountSnapshot: async ({ account, runtime, cfg, probe }) => {
+    const configured = Boolean(account.token?.trim() && account.appId?.trim());
+    const pairingEntries = await readGeweAllowFromStore({
+      accountId: account.accountId,
+    }).catch(() => []);
+    const peerEntries = collectKnownGewePeerEntries({
+      cfg,
+      accountId: account.accountId,
+    });
+    const groupEntries = collectKnownGeweGroupEntries({
+      cfg,
+      accountId: account.accountId,
+    });
+    const cacheCounts = getGeweDirectoryCacheCounts(account.accountId);
+    return {
+      accountId: account.accountId,
+      name: account.name,
+      enabled: account.enabled,
+      configured,
+      tokenSource: account.tokenSource,
+      baseUrl: account.config.apiBaseUrl ? "[set]" : "[missing]",
+      running: runtime?.running ?? false,
+      lastStartAt: runtime?.lastStartAt ?? null,
+      lastStopAt: runtime?.lastStopAt ?? null,
+      lastError: runtime?.lastError ?? null,
+      mode: "webhook",
+      lastInboundAt: runtime?.lastInboundAt ?? null,
+      lastOutboundAt: runtime?.lastOutboundAt ?? null,
+      dmPolicy: account.config.dmPolicy ?? "pairing",
+      groupPolicy: account.config.groupPolicy ?? "allowlist",
+      apiReachable: probe?.ok ?? false,
+      apiLatencyMs: probe?.latencyMs ?? null,
+      self: probe?.self ?? null,
+      knownPeersCount: peerEntries.length,
+      knownGroupsCount: groupEntries.length,
+      cachedGroupMemberCount: cacheCounts.cachedGroupMemberCount,
+      explicitBindingCount: countExplicitBindings(cfg, account.accountId),
+      groupOverrideCount: countGroupOverrides(account),
+      pairingAllowFromCount: pairingEntries.length,
+    };
+  },
+  collectStatusIssues: (accounts) => {
+    const issues: ChannelStatusIssue[] = [];
+    for (const account of accounts) {
+      if (account.configured && account.apiReachable === false) {
+        issues.push({
+          channel: CHANNEL_CONFIG_KEY,
+          accountId: account.accountId,
+          kind: "runtime",
+          message: `GeWe API probe failed for account "${account.accountId}".`,
+          fix: "Check token/appId, API base URL, and GeWe service availability.",
+        });
+      }
+      if (account.groupPolicy === "open" && (account.groupOverrideCount ?? 0) === 0) {
+        issues.push({
+          channel: CHANNEL_CONFIG_KEY,
+          accountId: account.accountId,
+          kind: "config",
+          message:
+            'GeWe groupPolicy="open" is active without any per-group allowFrom override.',
+          fix: `Set channels.${CHANNEL_CONFIG_KEY}.groupAllowFrom or groups.<room>.allowFrom to narrow group access.`,
+        });
+      }
+    }
+    return issues;
+  },
+};

package/src/channel.ts

@@ -3,17 +3,20 @@ import {
   buildChannelConfigSchema,
   DEFAULT_ACCOUNT_ID,
   deleteAccountFromConfigSection,
-  formatPairingApproveHint,
   missingTargetError,
   normalizeAccountId,
   PAIRING_APPROVED_MESSAGE,
   setAccountEnabledInConfigSection,
-  type ChannelPlugin,
   type OpenClawConfig,
   type ChannelSetupInput,
-} from "openclaw/plugin-sdk";
+  type ReplyPayload,
+} from "./openclaw-compat.js";
 
 import { resolveGeweAccount, resolveDefaultGeweAccountId, listGeweAccountIds } from "./accounts.js";
+import { geweMessageActions } from "./channel-actions.js";
+import { geweAllowlist } from "./channel-allowlist.js";
+import { geweDirectory } from "./channel-directory.js";
+import { geweStatus } from "./channel-status.js";
 import { GeweConfigSchema } from "./config-schema.js";
 import {
   CHANNEL_ALIASES,
@@ -29,8 +32,10 @@ import { looksLikeGeweTargetId, normalizeGeweMessagingTarget } from "./normalize
 import { resolveGeweGroupToolPolicy, resolveGeweRequireMention } from "./policy.js";
 import { getGeweRuntime } from "./runtime.js";
 import { sendTextGewe } from "./send.js";
+import { geweSetupWizard } from "./setup-wizard.js";
+import type { GeweChannelPlugin } from "./setup-wizard-types.js";
+import { normalizeGeweBindingConversationId } from "./group-binding.js";
 import type { CoreConfig, ResolvedGeweAccount } from "./types.js";
-import { geweOnboarding } from "./onboarding.js";
 
 const meta = {
   id: CHANNEL_ID,
@@ -53,25 +58,119 @@ type GeweSetupInput = ChannelSetupInput & {
   apiBaseUrl?: string;
 };
 
-export const gewePlugin: ChannelPlugin<ResolvedGeweAccount> = {
-  id: CHANNEL_ID,
-  meta,
-  onboarding: geweOnboarding,
-  pairing: {
-    idLabel: "wechatUserId",
-    normalizeAllowEntry: (entry) => stripChannelPrefix(entry),
-    notifyApproval: async ({ cfg, id }) => {
-      const account = resolveGeweAccount({ cfg: cfg as CoreConfig });
-      if (!account.token || !account.appId) {
-        throw new Error("GeWe token/appId not configured");
-      }
-      await sendTextGewe({
-        account,
-        toWxid: id,
-        content: PAIRING_APPROVED_MESSAGE,
-      });
+const GEWE_QUOTE_PARTIAL_DIRECTIVE_RE = /(?:\r?\n)?\s*\[\[GEWE_QUOTE_PARTIAL:([\s\S]*?)\]\]\s*$/;
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value as Record<string, unknown>;
+}
+
+function withGeweScopedChannelData(
+  payload: ReplyPayload,
+  updater: (scoped: Record<string, unknown>) => Record<string, unknown>,
+): ReplyPayload {
+  const channelData = asRecord(payload.channelData) ?? {};
+  const existingChannelScoped = asRecord(channelData[CHANNEL_ID]);
+  const existingLegacyScoped = asRecord(channelData.gewe);
+  const targetKey = existingChannelScoped ? CHANNEL_ID : existingLegacyScoped ? "gewe" : CHANNEL_ID;
+  const scoped = existingChannelScoped ?? existingLegacyScoped ?? {};
+
+  return {
+    ...payload,
+    channelData: {
+      ...channelData,
+      [targetKey]: updater(scoped),
     },
+  };
+}
+
+function parseGeweQuotePartialDirective(text: string | undefined): {
+  cleanedText: string;
+  partialText: string;
+} | null {
+  if (typeof text !== "string") return null;
+  const match = GEWE_QUOTE_PARTIAL_DIRECTIVE_RE.exec(text);
+  if (!match) return null;
+  const partialText = match[1]?.trim();
+  if (!partialText) return null;
+  const cleanedText = text.slice(0, match.index).replace(/\s+$/, "");
+  return {
+    cleanedText,
+    partialText,
+  };
+}
+
+function resolvePayloadMediaEntries(payload: ReplyPayload): string[] {
+  const mediaUrls = payload.mediaUrls?.map((entry) => entry?.trim()).filter(Boolean);
+  if (mediaUrls?.length) {
+    return mediaUrls;
+  }
+  const mediaUrl = payload.mediaUrl?.trim();
+  return mediaUrl ? [mediaUrl] : [];
+}
+
+function normalizeGeweOutboundPayload(payload: ReplyPayload): ReplyPayload {
+  let normalized = payload;
+
+  const partialDirective = parseGeweQuotePartialDirective(payload.text);
+  if (partialDirective) {
+    normalized = {
+      ...normalized,
+      text: partialDirective.cleanedText,
+    };
+    normalized = withGeweScopedChannelData(normalized, (scoped) => {
+      const quoteReply = asRecord(scoped.quoteReply);
+      const existingPartialText = asRecord(quoteReply?.partialText);
+      if (existingPartialText?.text) {
+        return scoped;
+      }
+      return {
+        ...scoped,
+        quoteReply: {
+          ...(quoteReply ?? {}),
+          partialText: {
+            ...existingPartialText,
+            text: partialDirective.partialText,
+          },
+        },
+      };
+    });
+  }
+
+  if (normalized.audioAsVoice !== true || resolvePayloadMediaEntries(normalized).length !== 1) {
+    return normalized;
+  }
+
+  return withGeweScopedChannelData(normalized, (scoped) => ({
+    ...scoped,
+    audioAsVoice: true,
+  }));
+}
+
+const gewePairing = {
+  idLabel: "wechatUserId",
+  mode: "code" as const,
+  normalizeAllowEntry: (entry: string) => stripChannelPrefix(entry),
+  notifyApproval: async ({ cfg, id }: { cfg: OpenClawConfig; id: string }) => {
+    const account = resolveGeweAccount({ cfg: cfg as CoreConfig });
+    if (!account.token || !account.appId) {
+      throw new Error("GeWe token/appId not configured");
+    }
+    await sendTextGewe({
+      account,
+      toWxid: id,
+      content: PAIRING_APPROVED_MESSAGE,
+    });
   },
+};
+
+export const gewePlugin: GeweChannelPlugin<ResolvedGeweAccount> = {
+  id: CHANNEL_ID,
+  meta,
+  setupWizard: geweSetupWizard,
+  pairing: gewePairing as GeweChannelPlugin<ResolvedGeweAccount>["pairing"],
   capabilities: {
     chatTypes: ["direct", "group"],
     reactions: false,
@@ -120,6 +219,7 @@ export const gewePlugin: ChannelPlugin<ResolvedGeweAccount> = {
         .filter(Boolean)
         .map((entry) => stripChannelPrefix(entry)),
   },
+  allowlist: geweAllowlist,
   security: {
     resolveDmPolicy: ({ cfg, accountId, account }) => {
       const resolvedAccountId = accountId ?? account.accountId ?? DEFAULT_ACCOUNT_ID;
@@ -134,7 +234,7 @@ export const gewePlugin: ChannelPlugin<ResolvedGeweAccount> = {
         allowFrom: account.config.allowFrom ?? [],
         policyPath: `${basePath}dmPolicy`,
         allowFromPath: basePath,
-        approveHint: formatPairingApproveHint(CHANNEL_ID),
+        approveHint: "Issue a pair code with: openclaw pairing code create gewe-openclaw",
         normalizeEntry: (raw) => stripChannelPrefix(raw),
       };
     },
@@ -146,14 +246,34 @@ export const gewePlugin: ChannelPlugin<ResolvedGeweAccount> = {
         account.config.groups && Object.keys(account.config.groups).length > 0;
       if (groupAllowlistConfigured) {
         return [
-          `- GeWe groups: groupPolicy="open" allows any member in allowed groups to trigger (mention-gated). Set channels.${CHANNEL_CONFIG_KEY}.groupPolicy="allowlist" + channels.${CHANNEL_CONFIG_KEY}.groupAllowFrom to restrict senders.`,
+          `- GeWe groups: groupPolicy="open" allows any member in allowed groups to trigger (at-gated by default). Set channels.${CHANNEL_CONFIG_KEY}.groupPolicy="allowlist" + channels.${CHANNEL_CONFIG_KEY}.groupAllowFrom to restrict senders.`,
         ];
       }
       return [
-        `- GeWe groups: groupPolicy="open" with no channels.${CHANNEL_CONFIG_KEY}.groups allowlist; any group can add + ping (mention-gated). Set channels.${CHANNEL_CONFIG_KEY}.groupPolicy="allowlist" + channels.${CHANNEL_CONFIG_KEY}.groupAllowFrom or configure channels.${CHANNEL_CONFIG_KEY}.groups.`,
+        `- GeWe groups: groupPolicy="open" with no channels.${CHANNEL_CONFIG_KEY}.groups allowlist; any group can add + at (at-gated by default). Set channels.${CHANNEL_CONFIG_KEY}.groupPolicy="allowlist" + channels.${CHANNEL_CONFIG_KEY}.groupAllowFrom or configure channels.${CHANNEL_CONFIG_KEY}.groups.`,
       ];
     },
   },
+  bindings: {
+    compileConfiguredBinding: ({ conversationId }) => {
+      const normalized = normalizeGeweBindingConversationId(conversationId);
+      return normalized
+        ? {
+            conversationId: normalized,
+          }
+        : null;
+    },
+    matchInboundConversation: ({ compiledBinding, conversationId }) => {
+      const normalized = normalizeGeweBindingConversationId(conversationId);
+      if (!normalized || normalized !== compiledBinding.conversationId) {
+        return null;
+      }
+      return {
+        conversationId: normalized,
+        matchPriority: 2,
+      };
+    },
+  },
   groups: {
     resolveRequireMention: ({ cfg, groupId, accountId }) => {
       const account = resolveGeweAccount({ cfg: cfg as CoreConfig, accountId });
@@ -168,19 +288,23 @@ export const gewePlugin: ChannelPlugin<ResolvedGeweAccount> = {
     resolveToolPolicy: resolveGeweGroupToolPolicy,
   },
   messaging: {
-    normalizeTarget: normalizeGeweMessagingTarget,
+    normalizeTarget: (raw) => normalizeGeweMessagingTarget(raw) ?? undefined,
     targetResolver: {
       looksLikeId: looksLikeGeweTargetId,
       hint: "<wxid|@chatroom>",
     },
   },
+  directory: geweDirectory,
+  actions: geweMessageActions,
   outbound: {
     deliveryMode: "direct",
+    normalizePayload: ({ payload }) => normalizeGeweOutboundPayload(payload),
     chunker: (text, limit) => {
       const core = getGeweRuntime();
       return core.channel.text.chunkMarkdownText(text, limit);
     },
     chunkerMode: "markdown",
+    textChunkLimit: 4000,
     resolveTarget: ({ to, allowFrom, mode }) => {
       const trimmed = to?.trim() ?? "";
       const allowListRaw = (allowFrom ?? []).map((entry) => String(entry).trim()).filter(Boolean);
@@ -271,36 +395,7 @@ export const gewePlugin: ChannelPlugin<ResolvedGeweAccount> = {
       lastStopAt: null,
       lastError: null,
     },
-    buildChannelSummary: ({ snapshot }) => ({
-      configured: snapshot.configured ?? false,
-      tokenSource: snapshot.tokenSource ?? "none",
-      running: snapshot.running ?? false,
-      mode: snapshot.mode ?? null,
-      lastStartAt: snapshot.lastStartAt ?? null,
-      lastStopAt: snapshot.lastStopAt ?? null,
-      lastError: snapshot.lastError ?? null,
-      lastInboundAt: snapshot.lastInboundAt ?? null,
-      lastOutboundAt: snapshot.lastOutboundAt ?? null,
-    }),
-    buildAccountSnapshot: ({ account, runtime }) => {
-      const configured = Boolean(account.token?.trim() && account.appId?.trim());
-      return {
-        accountId: account.accountId,
-        name: account.name,
-        enabled: account.enabled,
-        configured,
-        tokenSource: account.tokenSource,
-        baseUrl: account.config.apiBaseUrl ? "[set]" : "[missing]",
-        running: runtime?.running ?? false,
-        lastStartAt: runtime?.lastStartAt ?? null,
-        lastStopAt: runtime?.lastStopAt ?? null,
-        lastError: runtime?.lastError ?? null,
-        mode: "webhook",
-        lastInboundAt: runtime?.lastInboundAt ?? null,
-        lastOutboundAt: runtime?.lastOutboundAt ?? null,
-        dmPolicy: account.config.dmPolicy ?? "pairing",
-      };
-    },
+    ...geweStatus,
   },
   gateway: {
     startAccount: async (ctx) => {
@@ -355,7 +450,7 @@ export const gewePlugin: ChannelPlugin<ResolvedGeweAccount> = {
 
         const accounts =
           nextSection.accounts && typeof nextSection.accounts === "object"
-            ? { ...nextSection.accounts }
+            ? ({ ...nextSection.accounts } as Record<string, Record<string, unknown>>)
             : undefined;
         if (accounts && accountId in accounts) {
           const entry = accounts[accountId];
@@ -436,10 +531,12 @@ export const gewePlugin: ChannelPlugin<ResolvedGeweAccount> = {
       const section = (namedConfig.channels?.[CHANNEL_CONFIG_KEY] ?? {}) as Record<
         string,
         unknown
-      >;
+      > & {
+        accounts?: Record<string, Record<string, unknown>>;
+      };
       const useAccountPath = accountId !== DEFAULT_ACCOUNT_ID;
       const base = useAccountPath
-        ? (section.accounts?.[accountId] as Record<string, unknown> | undefined) ?? {}
+        ? section.accounts?.[accountId] ?? {}
         : section;
       const nextEntry = {
         ...base,

package/src/config-edit.ts

@@ -0,0 +1,94 @@
+import { CHANNEL_CONFIG_KEY } from "./constants.js";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId, type OpenClawConfig } from "./openclaw-compat.js";
+
+type ConfigWriteTarget =
+  | { kind: "channel"; scope: { channelId: string } }
+  | { kind: "account"; scope: { channelId: string; accountId: string } };
+
+type GeweWriteSection = {
+  nextCfg: OpenClawConfig;
+  channelSection: Record<string, unknown>;
+  target: Record<string, unknown>;
+  pathPrefix: string;
+  writeTarget: ConfigWriteTarget;
+};
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return undefined;
+  }
+  return value as Record<string, unknown>;
+}
+
+export function cloneOpenClawConfig<T>(value: T): T {
+  return structuredClone(value);
+}
+
+function ensureGeweWriteSectionOnConfig(params: {
+  cfg: OpenClawConfig;
+  accountId?: string | null;
+}): GeweWriteSection {
+  const nextCfg = params.cfg;
+  const channels = ((nextCfg.channels ??= {}) as Record<string, unknown>);
+  const channelSection = ((asRecord(channels[CHANNEL_CONFIG_KEY]) ?? {}) as Record<string, unknown>);
+  channels[CHANNEL_CONFIG_KEY] = channelSection;
+
+  const normalizedAccountId = normalizeAccountId(params.accountId);
+  const hasAccounts =
+    channelSection.accounts && typeof channelSection.accounts === "object" && !Array.isArray(channelSection.accounts);
+  const useAccount = normalizedAccountId !== DEFAULT_ACCOUNT_ID || Boolean(hasAccounts);
+  if (!useAccount) {
+    return {
+      nextCfg,
+      channelSection,
+      target: channelSection,
+      pathPrefix: `channels.${CHANNEL_CONFIG_KEY}`,
+      writeTarget: {
+        kind: "channel",
+        scope: { channelId: CHANNEL_CONFIG_KEY },
+      },
+    };
+  }
+
+  const accounts = ((asRecord(channelSection.accounts) ?? {}) as Record<string, unknown>);
+  channelSection.accounts = accounts;
+  const accountSection = ((asRecord(accounts[normalizedAccountId]) ?? {}) as Record<string, unknown>);
+  accounts[normalizedAccountId] = accountSection;
+  return {
+    nextCfg,
+    channelSection,
+    target: accountSection,
+    pathPrefix: `channels.${CHANNEL_CONFIG_KEY}.accounts.${normalizedAccountId}`,
+    writeTarget: {
+      kind: "account",
+      scope: {
+        channelId: CHANNEL_CONFIG_KEY,
+        accountId: normalizedAccountId,
+      },
+    },
+  };
+}
+
+export function ensureGeweWriteSection(params: {
+  cfg: OpenClawConfig;
+  accountId?: string | null;
+}) {
+  return ensureGeweWriteSectionOnConfig({
+    cfg: cloneOpenClawConfig(params.cfg),
+    accountId: params.accountId,
+  });
+}
+
+export function ensureGeweWriteSectionInPlace(params: {
+  cfg: OpenClawConfig;
+  accountId?: string | null;
+}) {
+  return ensureGeweWriteSectionOnConfig(params);
+}
+
+export function cleanupEmptyObject(parent: Record<string, unknown>, key: string) {
+  const value = asRecord(parent[key]);
+  if (value && Object.keys(value).length === 0) {
+    delete parent[key];
+  }
+}

package/src/config-schema.ts

@@ -6,20 +6,94 @@ import {
   MarkdownConfigSchema,
   ToolPolicySchema,
   requireOpenAllowFrom,
-} from "openclaw/plugin-sdk";
+} from "./openclaw-compat.js";
 import { z } from "zod";
 
+const GeweGroupTriggerSchema = z
+  .object({
+    mode: z.enum(["at", "quote", "at_or_quote", "any_message"]).optional(),
+  })
+  .strict();
+
+const GeweDmTriggerSchema = z
+  .object({
+    mode: z.enum(["any_message", "quote"]).optional(),
+  })
+  .strict();
+
+const GeweGroupReplySchema = z
+  .object({
+    mode: z.enum(["plain", "quote_source", "at_sender", "quote_and_at"]).optional(),
+  })
+  .strict();
+
+const GeweDmReplySchema = z
+  .object({
+    mode: z.enum(["plain", "quote_source"]).optional(),
+  })
+  .strict();
+
+const GeweBindingIdentitySelfSchema = z
+  .object({
+    source: z.enum(["agent_name", "agent_id", "literal"]).optional(),
+    value: z.string().optional(),
+  })
+  .strict()
+  .superRefine((value, ctx) => {
+    if (value.source === "literal" && !value.value?.trim()) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["value"],
+        message: "value is required when source=literal",
+      });
+    }
+  });
+
+const GeweBindingIdentityRemarkSchema = z
+  .object({
+    source: z.enum(["agent_id", "agent_name", "name_and_id", "literal"]).optional(),
+    value: z.string().optional(),
+  })
+  .strict()
+  .superRefine((value, ctx) => {
+    if (value.source === "literal" && !value.value?.trim()) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["value"],
+        message: "value is required when source=literal",
+      });
+    }
+  });
+
+const GeweBindingIdentitySchema = z
+  .object({
+    enabled: z.boolean().optional(),
+    selfNickname: GeweBindingIdentitySelfSchema.optional(),
+    remark: GeweBindingIdentityRemarkSchema.optional(),
+  })
+  .strict();
+
 export const GeweGroupSchema = z
   .object({
     requireMention: z.boolean().optional(),
-    tools: ToolPolicySchema,
+    tools: ToolPolicySchema.optional(),
     skills: z.array(z.string()).optional(),
     enabled: z.boolean().optional(),
     allowFrom: z.array(z.string()).optional(),
     systemPrompt: z.string().optional(),
+    trigger: GeweGroupTriggerSchema.optional(),
+    reply: GeweGroupReplySchema.optional(),
+    bindingIdentity: GeweBindingIdentitySchema.optional(),
   })
   .strict();
 
+export const GeweDmSchema = DmConfigSchema.extend({
+  skills: z.array(z.string()).optional(),
+  systemPrompt: z.string().optional(),
+  trigger: GeweDmTriggerSchema.optional(),
+  reply: GeweDmReplySchema.optional(),
+}).strict();
+
 export const GeweAccountSchemaBase = z
   .object({
     name: z.string().optional(),
@@ -80,9 +154,10 @@ export const GeweAccountSchemaBase = z
     groups: z.record(z.string(), GeweGroupSchema.optional()).optional(),
     historyLimit: z.number().int().min(0).optional(),
     dmHistoryLimit: z.number().int().min(0).optional(),
-    dms: z.record(z.string(), DmConfigSchema.optional()).optional(),
+    dms: z.record(z.string(), GeweDmSchema.optional()).optional(),
     textChunkLimit: z.number().int().positive().optional(),
     chunkMode: z.enum(["length", "newline"]).optional(),
+    autoQuoteReply: z.boolean().optional(),
     blockStreaming: z.boolean().optional(),
     blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
   })