@xpert-ai/plugin-community-wechat 0.1.0

package/dist/lib/workflow/wechat-personal-trigger.strategy.js

@@ -0,0 +1,511 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var WechatPersonalTriggerStrategy_1;
+import { Inject, Injectable, Logger } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { HANDOFF_PERMISSION_SERVICE_TOKEN, INTEGRATION_PERMISSION_SERVICE_TOKEN, RequestContext, WorkflowTriggerStrategy } from '@xpert-ai/plugin-sdk';
+import { randomUUID } from 'crypto';
+import { Repository } from 'typeorm';
+import { WECHAT_PERSONAL_ICON, WECHAT_PERSONAL_PROVIDER_KEY } from '../constants.js';
+import { WechatPersonalTriggerBindingEntity } from '../entities/wechat-personal-trigger-binding.entity.js';
+import { WechatPersonalChatDispatchService } from '../handoff/wechat-personal-chat-dispatch.service.js';
+import { WechatPersonalMessage } from '../message.js';
+import { WECHAT_PERSONAL_PLUGIN_CONTEXT } from '../tokens.js';
+import { normalizeGroupTriggerMode, normalizeKeywords } from '../types.js';
+import { WechatPersonalChannelStrategy } from '../wechat-personal-channel.strategy.js';
+import { WECHAT_PERSONAL_TRIGGER_FLUSH_MESSAGE_TYPE } from './wechat-personal-trigger-aggregation.types.js';
+import { WechatPersonalTriggerAggregationService } from './wechat-personal-trigger-aggregation.service.js';
+import { WechatPersonalTrigger } from './wechat-personal-trigger.types.js';
+const DEFAULT_SESSION_TIMEOUT_SECONDS = 3600;
+const DEFAULT_SUMMARY_WINDOW_SECONDS = 0;
+let WechatPersonalTriggerStrategy = WechatPersonalTriggerStrategy_1 = class WechatPersonalTriggerStrategy {
+    constructor(dispatchService, aggregationService, wechatChannel, bindingRepository, pluginContext) {
+        this.dispatchService = dispatchService;
+        this.aggregationService = aggregationService;
+        this.wechatChannel = wechatChannel;
+        this.bindingRepository = bindingRepository;
+        this.pluginContext = pluginContext;
+        this.logger = new Logger(WechatPersonalTriggerStrategy_1.name);
+        this.callbacks = new Map();
+        this.meta = {
+            name: WechatPersonalTrigger,
+            label: {
+                en_US: 'Personal WeChat Trigger',
+                zh_Hans: '个人微信触发器'
+            },
+            icon: {
+                type: 'svg',
+                value: WECHAT_PERSONAL_ICON
+            },
+            configSchema: {
+                type: 'object',
+                properties: {
+                    enabled: {
+                        type: 'boolean',
+                        title: {
+                            en_US: 'Enabled',
+                            zh_Hans: '启用'
+                        },
+                        default: true
+                    },
+                    integrationId: {
+                        type: 'string',
+                        title: {
+                            en_US: 'Personal WeChat Integration',
+                            zh_Hans: '个人微信集成'
+                        },
+                        'x-ui': {
+                            component: 'remoteSelect',
+                            selectUrl: '/api/wechat-personal/integration-select-options'
+                        }
+                    },
+                    sessionTimeoutSeconds: {
+                        type: 'number',
+                        title: {
+                            en_US: 'Session Timeout (seconds)',
+                            zh_Hans: '会话超时时间（秒）'
+                        },
+                        default: DEFAULT_SESSION_TIMEOUT_SECONDS
+                    },
+                    summaryWindowSeconds: {
+                        type: 'number',
+                        title: {
+                            en_US: 'Summary Window (seconds)',
+                            zh_Hans: '汇总时间（秒）'
+                        },
+                        description: {
+                            en_US: 'Messages received in this window are merged before dispatching to the agent.',
+                            zh_Hans: '窗口内收到的连续文本会合并后再发送给 Agent。'
+                        },
+                        default: DEFAULT_SUMMARY_WINDOW_SECONDS
+                    },
+                    groupTriggerMode: {
+                        type: 'string',
+                        title: {
+                            en_US: 'Group Trigger Mode',
+                            zh_Hans: '群聊触发方式'
+                        },
+                        enum: ['mention_or_keywords', 'all', 'mentions', 'keywords', 'off'],
+                        default: 'mention_or_keywords'
+                    },
+                    groupKeywords: {
+                        type: 'array',
+                        title: {
+                            en_US: 'Group Keywords',
+                            zh_Hans: '群聊关键词'
+                        },
+                        items: {
+                            type: 'string'
+                        }
+                    }
+                },
+                required: ['enabled', 'integrationId']
+            }
+        };
+        this.bootstrap = {
+            mode: 'replay_publish',
+            critical: false
+        };
+    }
+    get integrationPermissionService() {
+        if (!this._integrationPermissionService) {
+            this._integrationPermissionService = this.pluginContext.resolve(INTEGRATION_PERMISSION_SERVICE_TOKEN);
+        }
+        return this._integrationPermissionService;
+    }
+    get handoffPermissionService() {
+        if (!this._handoffPermissionService) {
+            this._handoffPermissionService = this.pluginContext.resolve(HANDOFF_PERMISSION_SERVICE_TOKEN);
+        }
+        return this._handoffPermissionService;
+    }
+    async validate(payload) {
+        const { xpertId, node, config } = payload;
+        const items = [];
+        const nodeKey = node?.key;
+        if (!config?.integrationId) {
+            items.push({
+                node: nodeKey,
+                ruleCode: 'TRIGGER_WECHAT_PERSONAL_INTEGRATION_REQUIRED',
+                field: 'integrationId',
+                value: '',
+                message: {
+                    en_US: 'Personal WeChat integration is required',
+                    zh_Hans: '需要选择个人微信集成'
+                },
+                level: 'error'
+            });
+            return items;
+        }
+        try {
+            const integration = await this.integrationPermissionService.read(config.integrationId);
+            if (!integration || integration.provider !== WECHAT_PERSONAL_PROVIDER_KEY) {
+                items.push({
+                    node: nodeKey,
+                    ruleCode: 'TRIGGER_WECHAT_PERSONAL_INTEGRATION_NOT_FOUND',
+                    field: 'integrationId',
+                    value: config.integrationId,
+                    message: {
+                        en_US: `Personal WeChat integration "${config.integrationId}" not found`,
+                        zh_Hans: `个人微信集成 "${config.integrationId}" 不存在`
+                    },
+                    level: 'error'
+                });
+            }
+        }
+        catch (error) {
+            this.logger.warn(`Validate integration "${config.integrationId}" failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (!config.enabled) {
+            return items;
+        }
+        const existingXpertId = await this.getBoundXpertId(config.integrationId);
+        if (existingXpertId && existingXpertId !== xpertId) {
+            items.push({
+                node: nodeKey,
+                ruleCode: 'TRIGGER_WECHAT_PERSONAL_INTEGRATION_CONFLICT',
+                field: 'integrationId',
+                value: config.integrationId,
+                message: {
+                    en_US: `Integration "${config.integrationId}" is already bound to another xpert`,
+                    zh_Hans: `个人微信集成 "${config.integrationId}" 已绑定到其他专家`
+                },
+                level: 'error'
+            });
+        }
+        return items;
+    }
+    async publish(payload, callback) {
+        const { xpertId, config } = payload;
+        if (!config?.enabled || !config.integrationId) {
+            return;
+        }
+        const integrationId = config.integrationId;
+        const existingXpertId = await this.getBoundXpertId(integrationId);
+        if (existingXpertId && existingXpertId !== xpertId) {
+            throw new Error(`Personal WeChat trigger integration "${integrationId}" is already bound to xpert "${existingXpertId}"`);
+        }
+        const context = await this.resolveBindingContext(integrationId);
+        await this.bindingRepository.upsert({
+            integrationId,
+            xpertId,
+            sessionTimeoutSeconds: this.normalizePositiveSeconds(config.sessionTimeoutSeconds, DEFAULT_SESSION_TIMEOUT_SECONDS),
+            summaryWindowSeconds: this.normalizeNonNegativeSeconds(config.summaryWindowSeconds, DEFAULT_SUMMARY_WINDOW_SECONDS),
+            groupTriggerMode: normalizeGroupTriggerMode(config.groupTriggerMode),
+            groupKeywords: normalizeKeywords(config.groupKeywords),
+            tenantId: context.tenantId ?? null,
+            organizationId: context.organizationId ?? null,
+            createdById: context.createdById ?? null,
+            updatedById: context.updatedById ?? null
+        }, ['integrationId']);
+        this.callbacks.set(integrationId, callback);
+    }
+    async stop(payload) {
+        const { xpertId, config } = payload;
+        const integrationId = config?.integrationId;
+        if (integrationId) {
+            this.callbacks.delete(integrationId);
+            await this.removeBindingFromStore(integrationId, xpertId);
+            return;
+        }
+        const scope = this.resolveRequestTenantScope();
+        const persistedBindings = await this.bindingRepository.find({
+            where: this.scopedWhere({ xpertId }, scope)
+        });
+        for (const binding of persistedBindings) {
+            this.callbacks.delete(binding.integrationId);
+        }
+        await this.removeBindingsByXpertId(xpertId);
+    }
+    async getBinding(integrationId, scope) {
+        if (!integrationId) {
+            return null;
+        }
+        const resolvedScope = scope ?? (await this.resolveQueryTenantScope(integrationId));
+        return this.bindingRepository.findOne({
+            where: this.scopedWhere({ integrationId }, resolvedScope)
+        });
+    }
+    async getBoundXpertId(integrationId) {
+        const binding = await this.getBinding(integrationId);
+        return binding?.xpertId ?? null;
+    }
+    async getBindingByXpertId(xpertId) {
+        if (!xpertId) {
+            return null;
+        }
+        const scope = this.resolveRequestTenantScope();
+        return this.bindingRepository.findOne({
+            where: this.scopedWhere({ xpertId }, scope),
+            order: {
+                updatedAt: 'DESC'
+            }
+        });
+    }
+    async getBoundIntegrationId(xpertId) {
+        const binding = await this.getBindingByXpertId(xpertId);
+        return binding?.integrationId ?? null;
+    }
+    async clearBufferedConversation(conversationUserKey) {
+        const aggregateKey = this.normalizeAggregateKey(conversationUserKey);
+        if (!aggregateKey) {
+            return;
+        }
+        await this.aggregationService.clear(aggregateKey);
+    }
+    async handleInboundMessage(params) {
+        const binding = await this.getBinding(params.integrationId, params);
+        if (!binding?.xpertId) {
+            this.logger.debug(`[wechat-personal-trigger] binding miss integrationId=${params.integrationId}`);
+            return false;
+        }
+        const aggregateKey = this.normalizeAggregateKey(params.conversationUserKey);
+        if (!aggregateKey) {
+            this.logger.warn(`[wechat-personal-trigger] aggregation key missing integrationId=${params.integrationId}`);
+            return false;
+        }
+        const summaryWindowSeconds = this.normalizeNonNegativeSeconds(binding.summaryWindowSeconds, DEFAULT_SUMMARY_WINDOW_SECONDS);
+        if (summaryWindowSeconds <= 0) {
+            await this.dispatchInboundMessage({
+                integrationId: params.integrationId,
+                xpertId: binding.xpertId,
+                dispatchMode: 'immediate',
+                dispatchPayload: {
+                    xpertId: binding.xpertId,
+                    input: params.input || '',
+                    wechatMessage: params.wechatMessage,
+                    conversationId: params.conversationId,
+                    conversationUserKey: aggregateKey,
+                    tenantId: params.tenantId,
+                    organizationId: params.organizationId,
+                    executorUserId: params.executorUserId,
+                    endUserId: params.endUserId
+                }
+            });
+            return true;
+        }
+        const currentState = await this.aggregationService.get(aggregateKey);
+        const sameRoutingTarget = currentState?.integrationId === params.integrationId && currentState?.xpertId === binding.xpertId;
+        const nextVersion = (currentState?.version ?? 0) + 1;
+        const aggregateState = {
+            aggregateKey,
+            integrationId: params.integrationId,
+            conversationUserKey: aggregateKey,
+            xpertId: binding.xpertId,
+            version: nextVersion,
+            inputParts: [...(sameRoutingTarget ? currentState?.inputParts ?? [] : []), params.input || ''],
+            lastMessageAt: Date.now(),
+            conversationId: params.conversationId ?? (sameRoutingTarget ? currentState?.conversationId : undefined),
+            tenantId: params.tenantId,
+            organizationId: params.organizationId,
+            executorUserId: params.executorUserId,
+            endUserId: params.endUserId,
+            latestMessage: {
+                integrationId: params.wechatMessage.integrationId,
+                uuid: params.wechatMessage.uuid,
+                ownerWxid: params.wechatMessage.ownerWxid,
+                contactId: params.wechatMessage.contactId,
+                chatType: params.wechatMessage.chatType,
+                senderId: params.wechatMessage.senderId,
+                language: params.wechatMessage.language,
+                messageId: params.wechatMessage.messageId
+            }
+        };
+        const ttlSeconds = Math.max(DEFAULT_SESSION_TIMEOUT_SECONDS, this.normalizePositiveSeconds(binding.sessionTimeoutSeconds, DEFAULT_SESSION_TIMEOUT_SECONDS), summaryWindowSeconds * 3);
+        await this.aggregationService.save(aggregateState, ttlSeconds);
+        await this.handoffPermissionService.enqueue(this.buildFlushMessage(aggregateState), {
+            delayMs: summaryWindowSeconds * 1000
+        });
+        return true;
+    }
+    async flushBufferedConversation(payload) {
+        const aggregateKey = this.normalizeAggregateKey(payload.aggregateKey);
+        if (!aggregateKey) {
+            return false;
+        }
+        const state = await this.aggregationService.get(aggregateKey);
+        if (!state || state.version !== payload.version) {
+            return false;
+        }
+        await this.dispatchInboundMessage({
+            integrationId: state.integrationId,
+            xpertId: state.xpertId,
+            dispatchMode: `buffered version=${state.version}`,
+            dispatchPayload: {
+                xpertId: state.xpertId,
+                input: state.inputParts.join('\n'),
+                wechatMessage: new WechatPersonalMessage({
+                    integrationId: state.latestMessage.integrationId,
+                    uuid: state.latestMessage.uuid,
+                    ownerWxid: state.latestMessage.ownerWxid,
+                    contactId: state.latestMessage.contactId,
+                    chatType: state.latestMessage.chatType,
+                    senderId: state.latestMessage.senderId,
+                    wechatChannel: this.wechatChannel
+                }, {
+                    status: 'thinking',
+                    language: state.latestMessage.language,
+                    messageId: state.latestMessage.messageId
+                }),
+                conversationId: state.conversationId,
+                conversationUserKey: state.conversationUserKey,
+                tenantId: state.tenantId,
+                organizationId: state.organizationId,
+                executorUserId: state.executorUserId,
+                endUserId: state.endUserId
+            }
+        });
+        await this.aggregationService.clear(aggregateKey);
+        return true;
+    }
+    buildFlushMessage(state) {
+        return {
+            id: `wechat-personal-trigger-flush-${randomUUID()}`,
+            type: WECHAT_PERSONAL_TRIGGER_FLUSH_MESSAGE_TYPE,
+            version: 1,
+            tenantId: state.tenantId,
+            sessionKey: state.aggregateKey,
+            businessKey: state.aggregateKey,
+            attempt: 1,
+            maxAttempts: 1,
+            enqueuedAt: Date.now(),
+            traceId: `${state.aggregateKey}:${state.version}`,
+            payload: {
+                aggregateKey: state.aggregateKey,
+                version: state.version
+            },
+            headers: {
+                ...(state.organizationId ? { organizationId: state.organizationId } : {}),
+                ...(state.executorUserId ? { userId: state.executorUserId } : {}),
+                source: 'api',
+                requestedLane: 'main',
+                handoffQueue: 'integration',
+                ...(state.integrationId ? { integrationId: state.integrationId } : {})
+            }
+        };
+    }
+    async dispatchInboundMessage(params) {
+        const callback = this.callbacks.get(params.integrationId);
+        if (!callback) {
+            this.logger.debug(`[wechat-personal-trigger] runtime callback miss, enqueue dispatch integrationId=${params.integrationId} xpertId=${params.xpertId} mode=${params.dispatchMode}`);
+            await this.dispatchService.enqueueDispatch(params.dispatchPayload);
+            return;
+        }
+        const handoffMessage = await this.dispatchService.buildDispatchMessage(params.dispatchPayload);
+        await Promise.resolve(callback({
+            from: WechatPersonalTrigger,
+            xpertId: params.xpertId,
+            handoffMessage
+        }));
+    }
+    async resolveBindingContext(integrationId) {
+        const tenantId = RequestContext.currentTenantId();
+        const organizationId = RequestContext.getOrganizationId();
+        const userId = RequestContext.currentUserId();
+        if (tenantId && organizationId) {
+            return {
+                tenantId,
+                organizationId,
+                createdById: userId,
+                updatedById: userId
+            };
+        }
+        const integration = await this.integrationPermissionService.read(integrationId);
+        return {
+            tenantId: tenantId ?? integration?.tenantId ?? null,
+            organizationId: organizationId ?? integration?.organizationId ?? null,
+            createdById: userId ?? integration?.createdById ?? null,
+            updatedById: userId ?? integration?.updatedById ?? userId ?? null
+        };
+    }
+    normalizeAggregateKey(value) {
+        if (typeof value !== 'string') {
+            return undefined;
+        }
+        const normalized = value.trim();
+        return normalized || undefined;
+    }
+    normalizePositiveSeconds(value, defaultValue) {
+        if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+            return Math.floor(value);
+        }
+        return defaultValue;
+    }
+    normalizeNonNegativeSeconds(value, defaultValue) {
+        if (typeof value === 'number' && Number.isFinite(value) && value >= 0) {
+            return Math.floor(value);
+        }
+        return defaultValue;
+    }
+    async removeBindingFromStore(integrationId, expectedXpertId) {
+        if (!integrationId) {
+            return;
+        }
+        const scope = await this.resolveQueryTenantScope(integrationId);
+        if (expectedXpertId) {
+            await this.bindingRepository.delete(this.scopedWhere({ integrationId, xpertId: expectedXpertId }, scope));
+            return;
+        }
+        await this.bindingRepository.delete(this.scopedWhere({ integrationId }, scope));
+    }
+    async removeBindingsByXpertId(xpertId) {
+        if (!xpertId) {
+            return;
+        }
+        await this.bindingRepository.delete(this.scopedWhere({ xpertId }, this.resolveRequestTenantScope()));
+    }
+    resolveRequestTenantScope() {
+        return {
+            tenantId: RequestContext.currentTenantId() ?? null,
+            organizationId: RequestContext.getOrganizationId() ?? null
+        };
+    }
+    async resolveQueryTenantScope(integrationId, fallback) {
+        const requestScope = this.resolveRequestTenantScope();
+        if (requestScope.tenantId || requestScope.organizationId || fallback?.tenantId || fallback?.organizationId) {
+            return {
+                tenantId: fallback?.tenantId ?? requestScope.tenantId ?? null,
+                organizationId: fallback?.organizationId ?? requestScope.organizationId ?? null
+            };
+        }
+        if (!integrationId) {
+            return requestScope;
+        }
+        const bindingContext = await this.resolveBindingContext(integrationId);
+        return {
+            tenantId: bindingContext.tenantId,
+            organizationId: bindingContext.organizationId
+        };
+    }
+    scopedWhere(where, scope) {
+        const scoped = { ...where };
+        if (scope?.tenantId) {
+            scoped.tenantId = scope.tenantId;
+        }
+        if (scope?.organizationId) {
+            scoped.organizationId = scope.organizationId;
+        }
+        return scoped;
+    }
+};
+WechatPersonalTriggerStrategy = WechatPersonalTriggerStrategy_1 = __decorate([
+    Injectable(),
+    WorkflowTriggerStrategy(WechatPersonalTrigger),
+    __param(3, InjectRepository(WechatPersonalTriggerBindingEntity)),
+    __param(4, Inject(WECHAT_PERSONAL_PLUGIN_CONTEXT)),
+    __metadata("design:paramtypes", [WechatPersonalChatDispatchService,
+        WechatPersonalTriggerAggregationService,
+        WechatPersonalChannelStrategy,
+        Repository, Object])
+], WechatPersonalTriggerStrategy);
+export { WechatPersonalTriggerStrategy };

package/dist/lib/workflow/wechat-personal-trigger.types.d.ts

@@ -0,0 +1,10 @@
+import { WechatPersonalGroupTriggerMode } from '../types.js';
+export declare const WechatPersonalTrigger = "wechat_personal";
+export type TWechatPersonalTriggerConfig = {
+    enabled: boolean;
+    integrationId: string;
+    sessionTimeoutSeconds?: number;
+    summaryWindowSeconds?: number;
+    groupTriggerMode?: WechatPersonalGroupTriggerMode;
+    groupKeywords?: string[] | string;
+};

package/dist/lib/workflow/wechat-personal-trigger.types.js

@@ -0,0 +1,2 @@
+import { WECHAT_PERSONAL_TRIGGER_KEY } from '../constants.js';
+export const WechatPersonalTrigger = WECHAT_PERSONAL_TRIGGER_KEY;

package/dist/xpert-wechat-personal-admin-assistant.yaml

@@ -0,0 +1,103 @@
+team:
+  name: wechat-personal-admin-assistant
+  type: agent
+  title: 个人微信管理员
+  description: 管理组织内 wx2.0 个人微信集成、账号、会话、消息日志和回调配置的 Agent
+  avatar:
+    emoji:
+      id: toolbox
+    background: rgb(220, 252, 231)
+  options:
+    templateKey: wechat-personal-admin-assistant
+    dataXpert:
+      managedBy: data-xpert
+      templateKey: wechat-personal-admin-assistant
+      assistantKind: wechat-personal-admin-assistant
+      businessDomain: wechat-personal
+      wechatPersonalRole: admin
+      requiredPlugin: '@xpert-ai/plugin-community-wechat'
+      requiredPlugins:
+        - '@xpert-ai/plugin-community-wechat'
+      requiredCapabilities:
+        - wechat_personal_bridge
+        - wechat-personal-runtime
+        - wechat-personal-workbench
+  agentConfig:
+    recursionLimit: 10000
+  features:
+    sandbox:
+      enabled: false
+  version: "1"
+  agent:
+    key: Agent_WechatPersonalAdmin
+  copilotModel:
+    referencedId: null
+    modelType: llm
+    model: qwen3.6-plus
+    options:
+      context_size: 1000000
+      temperature: 0.2
+      maxRetries: 4
+      max_tokens: 4096
+      top_p: 0.9
+  knowledgebases: []
+  toolsets: []
+  tags: []
+nodes:
+  - type: agent
+    key: Agent_WechatPersonalAdmin
+    position:
+      x: 820
+      y: 20
+    entity:
+      key: Agent_WechatPersonalAdmin
+      name: wechat-personal-admin-assistant
+      title: 个人微信管理员
+      description: 管理组织内 wx2.0 个人微信集成、账号、会话、消息日志和回调配置的 Agent
+      avatar:
+        emoji:
+          id: toolbox
+        background: rgb(220, 252, 231)
+      prompt: >
+        You are the Personal WeChat administrator assistant for this organization.
+
+        Your job is to help administrators configure and operate wx2.0 personal WeChat integrations:
+        review organization-wide integration status, callback URLs, account callback health, conversation
+        bindings, message logs, dispatch errors, and outbound reply failures. Use the Personal WeChat
+        runtime tools when answering operational questions.
+
+        This assistant is not connected to inbound WeChat messages and must not act like an end-user
+        chat responder. Do not configure a Personal WeChat trigger in this administrator assistant.
+
+        When an operation can affect a specific wx2.0 integration or account, ask for or use an explicit
+        integrationId and uuid before taking action. Never guess an integration from a similar name when
+        multiple integrations exist.
+
+        Do not reveal API tokens, callback secrets, hidden routing details, queue identifiers, or system
+        configuration that is not needed by the administrator. Callback URLs may be shown only as setup
+        instructions for administrators.
+
+        Prefer Chinese for Chinese administrators; otherwise mirror the user's language. Keep answers concise
+        and include concrete next steps when diagnosing failures.
+      collaboratorNames: []
+      toolsetIds: []
+      knowledgebaseIds: []
+    hash: wechat-personal-admin-agent-v1
+  - type: workflow
+    key: Middleware_WechatPersonalRuntime
+    position:
+      x: 1140
+      y: 280
+    entity:
+      type: middleware
+      key: Middleware_WechatPersonalRuntime
+      title: Personal WeChat Runtime Tools
+      provider: WechatPersonalRuntimeMiddleware
+      required: true
+      options: {}
+    hash: wechat-personal-admin-middleware-v1
+connections:
+  - type: workflow
+    key: Agent_WechatPersonalAdmin/Middleware_WechatPersonalRuntime
+    from: Agent_WechatPersonalAdmin
+    to: Middleware_WechatPersonalRuntime