@xpert-ai/plugin-community-wechat 0.1.0

package/dist/lib/wechat-personal.controller.js

@@ -0,0 +1,270 @@
+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); }
+};
+import { BadRequestException, Body, Controller, Get, Header, HttpCode, Inject, Param, Post, Query, Request } from '@nestjs/common';
+import { INTEGRATION_PERMISSION_SERVICE_TOKEN, RequestContext, runWithRequestContext } from '@xpert-ai/plugin-sdk';
+import { Public } from './decorators.js';
+import { WECHAT_PERSONAL_PROVIDER_KEY } from './constants.js';
+import { WECHAT_PERSONAL_PLUGIN_CONTEXT } from './tokens.js';
+import { WechatPersonalConversationService } from './conversation.service.js';
+import { normalizeString } from './types.js';
+import { WechatPersonalChannelStrategy } from './wechat-personal-channel.strategy.js';
+let WechatPersonalController = class WechatPersonalController {
+    constructor(conversation, wechatChannel, pluginContext) {
+        this.conversation = conversation;
+        this.wechatChannel = wechatChannel;
+        this.pluginContext = pluginContext;
+    }
+    get integrationPermissionService() {
+        if (!this._integrationPermissionService) {
+            this._integrationPermissionService = this.pluginContext.resolve(INTEGRATION_PERMISSION_SERVICE_TOKEN);
+        }
+        return this._integrationPermissionService;
+    }
+    async webhook(integrationId, req, body, querySecret) {
+        const integration = await this.readWechatPersonalIntegration(integrationId);
+        this.verifyCallbackSecret(integration, req, querySecret);
+        const payload = this.parseBodyToObject(body);
+        if (!payload) {
+            return 'success';
+        }
+        const event = this.wechatChannel.normalizeWebhookEvent(payload);
+        if (!event) {
+            return 'success';
+        }
+        const ctx = {
+            integration,
+            tenantId: integration.tenantId,
+            organizationId: integration.organizationId
+        };
+        const contextUser = RequestContext.currentUser() ?? req.user ?? {
+            id: `wechat-personal:${integration.id}:anonymous`,
+            tenantId: integration.tenantId,
+            organizationId: integration.organizationId
+        };
+        const requestHeaders = {
+            ['tenant-id']: integration.tenantId,
+            ['organization-id']: integration.organizationId
+        };
+        if (integration.options?.preferLanguage) {
+            requestHeaders.language = integration.options.preferLanguage;
+        }
+        await new Promise((resolve, reject) => {
+            runWithRequestContext({
+                user: contextUser,
+                headers: requestHeaders
+            }, {}, () => {
+                this.conversation.handleInboundEvent(event, ctx).then(() => resolve()).catch(reject);
+            });
+        });
+        return 'success';
+    }
+    async getIntegrationSelectOptions(req, keyword) {
+        const options = await this.fetchProviderSelectOptions(req, WECHAT_PERSONAL_PROVIDER_KEY);
+        const normalizedKeyword = this.toSafeString(keyword).toLowerCase();
+        if (!normalizedKeyword) {
+            return options;
+        }
+        return options.filter((item) => {
+            const label = item.label.toLowerCase();
+            const value = item.value.toLowerCase();
+            const description = this.toSafeString(item.description).toLowerCase();
+            return label.includes(normalizedKeyword) || value.includes(normalizedKeyword) || description.includes(normalizedKeyword);
+        });
+    }
+    async getCallbackConfig(integrationId) {
+        const integration = await this.readWechatPersonalIntegration(integrationId);
+        return this.conversation.buildCallbackConfig(integration.id, integration.options?.callbackSecret);
+    }
+    async registerCallback(integrationId, uuid, body) {
+        const integration = await this.readWechatPersonalIntegration(integrationId);
+        const callbackConfig = this.conversation.buildCallbackConfig(integration.id, integration.options?.callbackSecret);
+        const result = await this.wechatChannel.registerCallback({
+            integrationId: integration.id,
+            uuid,
+            callbackUrl: normalizeString(body?.callbackUrl) || callbackConfig.webhookUrl,
+            enabled: body?.enabled !== false
+        });
+        if (!result.success) {
+            throw new BadRequestException(result.error || 'Register wx2.0 callback failed');
+        }
+        return result;
+    }
+    async sendText(integrationId, body) {
+        const integration = await this.readWechatPersonalIntegration(integrationId);
+        const result = await this.wechatChannel.sendTextByIntegrationId(integration.id, {
+            uuid: body?.uuid,
+            contactId: body?.contactId || body?.contactid,
+            content: body?.text || body?.content || body?.textcontent || '',
+            atUsers: Array.isArray(body?.atUsers) ? body.atUsers : Array.isArray(body?.atusers) ? body.atusers : []
+        });
+        if (!result.success) {
+            throw new BadRequestException(result.error || 'Send wx2.0 text failed');
+        }
+        return result;
+    }
+    async readWechatPersonalIntegration(integrationId) {
+        const integration = await this.integrationPermissionService.read(integrationId, {
+            relations: ['tenant']
+        });
+        if (!integration) {
+            throw new BadRequestException(`Integration ${integrationId} not found. Please save the personal WeChat integration first.`);
+        }
+        if (integration.provider !== WECHAT_PERSONAL_PROVIDER_KEY) {
+            throw new BadRequestException(`Integration ${integrationId} is not provider '${WECHAT_PERSONAL_PROVIDER_KEY}'`);
+        }
+        return integration;
+    }
+    verifyCallbackSecret(integration, req, querySecret) {
+        const expected = this.toSafeString(integration.options?.callbackSecret);
+        if (!expected) {
+            return;
+        }
+        const provided = this.toSafeString(querySecret) ||
+            this.toSafeString(req.headers['x-wechat-callback-secret']) ||
+            this.toSafeString(req.headers['x-xpert-callback-secret']);
+        if (provided !== expected) {
+            throw new BadRequestException('Invalid personal WeChat callback secret');
+        }
+    }
+    async fetchProviderSelectOptions(req, provider) {
+        try {
+            const host = this.toSafeString(req.get('host'));
+            if (!host) {
+                return [];
+            }
+            const protocol = this.toSafeString(req.protocol) || 'http';
+            const url = new URL(`${protocol}://${host}/api/integration/select-options`);
+            url.searchParams.set('provider', provider);
+            const headers = {};
+            const authorization = this.toSafeString(req.headers?.authorization);
+            const organizationId = this.toSafeString(req.headers?.['organization-id']);
+            const tenantId = this.toSafeString(req.headers?.['tenant-id']);
+            const language = this.toSafeString(req.headers?.language);
+            if (authorization) {
+                headers.authorization = authorization;
+            }
+            if (organizationId) {
+                headers['organization-id'] = organizationId;
+            }
+            if (tenantId) {
+                headers['tenant-id'] = tenantId;
+            }
+            if (language) {
+                headers.language = language;
+            }
+            const response = await fetch(url.toString(), {
+                method: 'GET',
+                headers
+            });
+            if (!response.ok) {
+                return [];
+            }
+            const payload = (await response.json().catch(() => null));
+            if (!Array.isArray(payload)) {
+                return [];
+            }
+            return payload
+                .map((item) => (item && typeof item === 'object' ? item : null))
+                .filter((item) => Boolean(item))
+                .map((item) => ({
+                value: this.toSafeString(item.value),
+                label: this.toSafeString(item.label) || this.toSafeString(item.value),
+                description: this.toSafeString(item.description) || undefined,
+                icon: this.toSafeString(item.icon) || undefined
+            }))
+                .filter((item) => Boolean(item.value));
+        }
+        catch {
+            return [];
+        }
+    }
+    parseBodyToObject(body) {
+        if (!body) {
+            return null;
+        }
+        if (typeof body === 'string') {
+            const text = body.trim();
+            if (!text) {
+                return null;
+            }
+            try {
+                return JSON.parse(text);
+            }
+            catch {
+                return null;
+            }
+        }
+        if (typeof body === 'object') {
+            return body;
+        }
+        return null;
+    }
+    toSafeString(value) {
+        if (Array.isArray(value)) {
+            return this.toSafeString(value[0]);
+        }
+        return typeof value === 'string' ? value.trim() : '';
+    }
+};
+__decorate([
+    Public(),
+    Post('webhook/:id'),
+    HttpCode(200),
+    Header('Content-Type', 'text/plain; charset=utf-8'),
+    __param(0, Param('id')),
+    __param(1, Request()),
+    __param(2, Body()),
+    __param(3, Query('secret')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object, String]),
+    __metadata("design:returntype", Promise)
+], WechatPersonalController.prototype, "webhook", null);
+__decorate([
+    Get('integration-select-options'),
+    __param(0, Request()),
+    __param(1, Query('keyword')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], WechatPersonalController.prototype, "getIntegrationSelectOptions", null);
+__decorate([
+    Get(':integrationId/callback-config'),
+    __param(0, Param('integrationId')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], WechatPersonalController.prototype, "getCallbackConfig", null);
+__decorate([
+    Post(':integrationId/accounts/:uuid/register-callback'),
+    __param(0, Param('integrationId')),
+    __param(1, Param('uuid')),
+    __param(2, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], WechatPersonalController.prototype, "registerCallback", null);
+__decorate([
+    Post(':integrationId/send-text'),
+    __param(0, Param('integrationId')),
+    __param(1, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], WechatPersonalController.prototype, "sendText", null);
+WechatPersonalController = __decorate([
+    Controller('wechat-personal'),
+    __param(2, Inject(WECHAT_PERSONAL_PLUGIN_CONTEXT)),
+    __metadata("design:paramtypes", [WechatPersonalConversationService,
+        WechatPersonalChannelStrategy, Object])
+], WechatPersonalController);
+export { WechatPersonalController };

package/dist/lib/wechat-personal.middleware.d.ts

@@ -0,0 +1,20 @@
+import { TAgentMiddlewareMeta } from '@xpert-ai/contracts';
+import { AgentMiddleware, IAgentMiddlewareContext, IAgentMiddlewareStrategy, PromiseOrValue } from '@xpert-ai/plugin-sdk';
+import { WechatPersonalConversationService } from './conversation.service.js';
+import { WechatPersonalChannelStrategy } from './wechat-personal-channel.strategy.js';
+type WechatPersonalRuntimeMiddlewareOptions = {
+    integrationId?: string;
+};
+export declare class WechatPersonalRuntimeMiddleware implements IAgentMiddlewareStrategy<WechatPersonalRuntimeMiddlewareOptions> {
+    private readonly conversationService;
+    private readonly wechatChannel;
+    readonly meta: TAgentMiddlewareMeta;
+    constructor(conversationService: WechatPersonalConversationService, wechatChannel: WechatPersonalChannelStrategy);
+    createMiddleware(options: WechatPersonalRuntimeMiddlewareOptions, context: IAgentMiddlewareContext): PromiseOrValue<AgentMiddleware>;
+    private resolveIntegrationId;
+    private safeJson;
+    private success;
+    private error;
+    private missingIntegrationId;
+}
+export {};

package/dist/lib/wechat-personal.middleware.js

@@ -0,0 +1,267 @@
+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);
+};
+import { Injectable } from '@nestjs/common';
+import { tool } from '@langchain/core/tools';
+import { AgentMiddlewareStrategy } from '@xpert-ai/plugin-sdk';
+import { z } from 'zod/v3';
+import { WECHAT_PERSONAL_FEATURE, WECHAT_PERSONAL_GET_CALLBACK_CONFIG_TOOL_NAME, WECHAT_PERSONAL_GET_RUNTIME_STATUS_TOOL_NAME, WECHAT_PERSONAL_ICON, WECHAT_PERSONAL_LIST_ACCOUNTS_TOOL_NAME, WECHAT_PERSONAL_LIST_CONVERSATIONS_TOOL_NAME, WECHAT_PERSONAL_MIDDLEWARE_NAME, WECHAT_PERSONAL_REGISTER_CALLBACK_TOOL_NAME, WECHAT_PERSONAL_RESET_CONVERSATION_TOOL_NAME, WECHAT_PERSONAL_RUNTIME_FEATURE, WECHAT_PERSONAL_SEARCH_MESSAGE_LOGS_TOOL_NAME, WECHAT_PERSONAL_SET_ACCOUNT_ENABLED_TOOL_NAME, WECHAT_PERSONAL_WORKBENCH_FEATURE } from './constants.js';
+import { normalizeString } from './types.js';
+import { WechatPersonalConversationService } from './conversation.service.js';
+import { WechatPersonalChannelStrategy } from './wechat-personal-channel.strategy.js';
+const integrationField = z.string().optional().describe('Personal WeChat integration id. Defaults to the middleware node option.');
+const runtimeStatusSchema = z.object({
+    integrationId: integrationField
+});
+const callbackConfigSchema = z.object({
+    integrationId: integrationField
+});
+const listAccountsSchema = z.object({
+    integrationId: integrationField,
+    search: z.string().optional().describe('Keyword for uuid, owner wxid, display name, status or last error.'),
+    page: z.number().int().min(1).optional().describe('Page number. Defaults to 1.'),
+    pageSize: z.number().int().min(1).max(100).optional().describe('Page size. Defaults to 50.')
+});
+const listConversationsSchema = z.object({
+    integrationId: integrationField,
+    search: z.string().optional().describe('Keyword for account uuid, contact id, sender id, xpert id or conversation id.'),
+    page: z.number().int().min(1).optional().describe('Page number. Defaults to 1.'),
+    pageSize: z.number().int().min(1).max(100).optional().describe('Page size. Defaults to 50.')
+});
+const searchMessageLogsSchema = z.object({
+    integrationId: integrationField,
+    direction: z.enum(['inbound', 'outbound', 'system']).optional().describe('Message direction filter.'),
+    status: z.enum(['received', 'dispatched', 'sent', 'skipped', 'failed']).optional().describe('Message status filter.'),
+    search: z.string().optional().describe('Keyword for contact, sender, message id, content, error or conversation id.'),
+    page: z.number().int().min(1).optional().describe('Page number. Defaults to 1.'),
+    pageSize: z.number().int().min(1).max(100).optional().describe('Page size. Defaults to 50.')
+});
+const resetConversationSchema = z.object({
+    integrationId: integrationField,
+    bindingId: z.string().min(1).describe('Conversation binding id returned by wechat_personal_list_conversations.')
+});
+const registerCallbackSchema = z.object({
+    integrationId: integrationField,
+    uuid: z.string().min(1).describe('wx2.0 account uuid/key.'),
+    callbackUrl: z.string().optional().describe('Optional callback URL. Defaults to the Xpert webhook URL.'),
+    enabled: z.boolean().optional().describe('Whether the wx2.0 per-account callback should be enabled. Defaults to true.')
+});
+const setAccountEnabledSchema = z.object({
+    integrationId: integrationField,
+    uuid: z.string().min(1).describe('wx2.0 account uuid/key.'),
+    enabled: z.boolean().describe('Whether this account should accept inbound callbacks.')
+});
+let WechatPersonalRuntimeMiddleware = class WechatPersonalRuntimeMiddleware {
+    constructor(conversationService, wechatChannel) {
+        this.conversationService = conversationService;
+        this.wechatChannel = wechatChannel;
+        this.meta = {
+            name: WECHAT_PERSONAL_MIDDLEWARE_NAME,
+            label: {
+                en_US: 'Personal WeChat Runtime',
+                zh_Hans: '个人微信运行时'
+            },
+            description: {
+                en_US: 'Expose Personal WeChat workbench discovery and runtime management tools to an assistant.',
+                zh_Hans: '为助手暴露个人微信工作台发现能力和运行时管理工具。'
+            },
+            icon: {
+                type: 'svg',
+                value: WECHAT_PERSONAL_ICON,
+                color: '#16a34a'
+            },
+            features: [WECHAT_PERSONAL_FEATURE, WECHAT_PERSONAL_RUNTIME_FEATURE, WECHAT_PERSONAL_WORKBENCH_FEATURE],
+            configSchema: {
+                type: 'object',
+                properties: {
+                    integrationId: {
+                        type: 'string',
+                        title: {
+                            en_US: 'Personal WeChat Integration',
+                            zh_Hans: '个人微信集成'
+                        },
+                        'x-ui': {
+                            component: 'remoteSelect',
+                            selectUrl: '/api/wechat-personal/integration-select-options'
+                        }
+                    }
+                },
+                required: []
+            }
+        };
+    }
+    createMiddleware(options, context) {
+        return {
+            name: WECHAT_PERSONAL_MIDDLEWARE_NAME,
+            tools: [
+                tool(async (input) => this.safeJson(async () => {
+                    const integrationId = await this.resolveIntegrationId(input.integrationId, options, context);
+                    return this.success(integrationId
+                        ? 'Personal WeChat runtime status was returned.'
+                        : 'Organization Personal WeChat runtime status was returned.', integrationId
+                        ? await this.conversationService.getRuntimeStatus(integrationId)
+                        : await this.conversationService.getOrganizationRuntimeStatus());
+                }), {
+                    name: WECHAT_PERSONAL_GET_RUNTIME_STATUS_TOOL_NAME,
+                    description: 'Get Personal WeChat runtime status: callback URLs, trigger binding, summary counts, recent accounts and recent errors. Use for setup and operations questions.',
+                    schema: runtimeStatusSchema
+                }),
+                tool(async (input) => this.safeJson(async () => {
+                    const integrationId = await this.resolveIntegrationId(input.integrationId, options, context);
+                    if (!integrationId) {
+                        return this.success('Organization Personal WeChat callback configurations were returned.', (await this.conversationService.getOrganizationWorkbenchData({ pageSize: 1 })).integrations?.map((integration) => ({
+                            id: integration.id,
+                            name: integration.name,
+                            callbackConfig: integration.callbackConfig
+                        })) ?? []);
+                    }
+                    const integration = await this.wechatChannel.readIntegrationById(integrationId);
+                    if (!integration) {
+                        return this.error(`Personal WeChat integration "${integrationId}" was not found.`);
+                    }
+                    return this.success('Personal WeChat callback configuration was returned.', this.conversationService.buildCallbackConfig(integration.id, integration.options?.callbackSecret));
+                }), {
+                    name: WECHAT_PERSONAL_GET_CALLBACK_CONFIG_TOOL_NAME,
+                    description: 'Get the Xpert webhook URL and SetCallback curl template for configuring wx2.0 callbacks.',
+                    schema: callbackConfigSchema
+                }),
+                tool(async (input) => this.safeJson(async () => {
+                    const integrationId = await this.resolveIntegrationId(input.integrationId, options, context);
+                    return this.success(integrationId ? 'Personal WeChat accounts were listed.' : 'Organization Personal WeChat accounts were listed.', integrationId
+                        ? await this.conversationService.listAccounts(integrationId, input)
+                        : await this.conversationService.listOrganizationAccounts(input));
+                }), {
+                    name: WECHAT_PERSONAL_LIST_ACCOUNTS_TOOL_NAME,
+                    description: 'List wx2.0 personal WeChat accounts captured by callbacks, including enabled state, online status and recent errors.',
+                    schema: listAccountsSchema
+                }),
+                tool(async (input) => this.safeJson(async () => {
+                    const integrationId = await this.resolveIntegrationId(input.integrationId, options, context);
+                    return this.success(integrationId
+                        ? 'Personal WeChat conversation bindings were listed.'
+                        : 'Organization Personal WeChat conversation bindings were listed.', integrationId
+                        ? await this.conversationService.listConversations(integrationId, input)
+                        : await this.conversationService.listOrganizationConversations(input));
+                }), {
+                    name: WECHAT_PERSONAL_LIST_CONVERSATIONS_TOOL_NAME,
+                    description: 'List Personal WeChat conversation bindings. Use this to find a binding id before resetting a conversation.',
+                    schema: listConversationsSchema
+                }),
+                tool(async (input) => this.safeJson(async () => {
+                    const integrationId = await this.resolveIntegrationId(input.integrationId, options, context);
+                    return this.success(integrationId
+                        ? 'Personal WeChat message logs were searched.'
+                        : 'Organization Personal WeChat message logs were searched.', integrationId
+                        ? await this.conversationService.searchMessageLogs(integrationId, input)
+                        : await this.conversationService.searchOrganizationMessageLogs(input));
+                }), {
+                    name: WECHAT_PERSONAL_SEARCH_MESSAGE_LOGS_TOOL_NAME,
+                    description: 'Search inbound, outbound and system Personal WeChat message logs for diagnostics and audit questions.',
+                    schema: searchMessageLogsSchema
+                }),
+                tool(async (input) => this.safeJson(async () => {
+                    const integrationId = await this.resolveIntegrationId(input.integrationId, options, context);
+                    if (!integrationId) {
+                        return this.missingIntegrationId();
+                    }
+                    await this.conversationService.restartConversationBinding(integrationId, input.bindingId);
+                    return this.success('Personal WeChat conversation was reset.', {
+                        bindingId: input.bindingId
+                    });
+                }), {
+                    name: WECHAT_PERSONAL_RESET_CONVERSATION_TOOL_NAME,
+                    description: 'Reset one Personal WeChat conversation binding by binding id so the next inbound message starts a fresh Agent conversation.',
+                    schema: resetConversationSchema
+                }),
+                tool(async (input) => this.safeJson(async () => {
+                    const integrationId = await this.resolveIntegrationId(input.integrationId, options, context);
+                    if (!integrationId) {
+                        return this.missingIntegrationId();
+                    }
+                    const integration = await this.wechatChannel.readIntegrationById(integrationId);
+                    if (!integration) {
+                        return this.error(`Personal WeChat integration "${integrationId}" was not found.`);
+                    }
+                    const callbackConfig = this.conversationService.buildCallbackConfig(integration.id, integration.options?.callbackSecret);
+                    const result = await this.wechatChannel.registerCallback({
+                        integrationId: integration.id,
+                        uuid: input.uuid,
+                        callbackUrl: normalizeString(input.callbackUrl) || callbackConfig.webhookUrl,
+                        enabled: input.enabled !== false
+                    });
+                    return result.success
+                        ? this.success('wx2.0 SetCallback registration succeeded.', result)
+                        : this.error(result.error || 'wx2.0 SetCallback registration failed.', result);
+                }), {
+                    name: WECHAT_PERSONAL_REGISTER_CALLBACK_TOOL_NAME,
+                    description: 'Register or update a wx2.0 per-account callback for a known account uuid/key. This is an administrative setup action.',
+                    schema: registerCallbackSchema
+                }),
+                tool(async (input) => this.safeJson(async () => {
+                    const integrationId = await this.resolveIntegrationId(input.integrationId, options, context);
+                    if (!integrationId) {
+                        return this.missingIntegrationId();
+                    }
+                    await this.conversationService.setAccountEnabled(integrationId, input.uuid, input.enabled);
+                    return this.success('Personal WeChat account enabled state was updated.', {
+                        uuid: input.uuid,
+                        enabled: input.enabled
+                    });
+                }), {
+                    name: WECHAT_PERSONAL_SET_ACCOUNT_ENABLED_TOOL_NAME,
+                    description: 'Enable or disable inbound processing for one wx2.0 personal WeChat account already seen by this integration.',
+                    schema: setAccountEnabledSchema
+                })
+            ]
+        };
+    }
+    async resolveIntegrationId(inputIntegrationId, options, context) {
+        const nodeOptions = context.node?.options;
+        const explicitIntegrationId = normalizeString(inputIntegrationId) ||
+            normalizeString(options?.integrationId) ||
+            normalizeString(nodeOptions?.integrationId);
+        if (explicitIntegrationId) {
+            return explicitIntegrationId;
+        }
+        const xpertId = normalizeString(context.xpertId);
+        return xpertId ? this.conversationService.getBoundIntegrationIdForXpert(xpertId) : null;
+    }
+    async safeJson(factory) {
+        try {
+            return JSON.stringify(await factory(), null, 2);
+        }
+        catch (err) {
+            return JSON.stringify(this.error(err instanceof Error ? err.message : String(err)), null, 2);
+        }
+    }
+    success(message, data) {
+        return {
+            success: true,
+            message,
+            data
+        };
+    }
+    error(message, data) {
+        return {
+            success: false,
+            message,
+            data
+        };
+    }
+    missingIntegrationId() {
+        return this.error('Missing Personal WeChat integrationId. Select an integration in the middleware options first.');
+    }
+};
+WechatPersonalRuntimeMiddleware = __decorate([
+    Injectable(),
+    AgentMiddlewareStrategy(WECHAT_PERSONAL_MIDDLEWARE_NAME),
+    __metadata("design:paramtypes", [WechatPersonalConversationService,
+        WechatPersonalChannelStrategy])
+], WechatPersonalRuntimeMiddleware);
+export { WechatPersonalRuntimeMiddleware };

package/dist/lib/wechat-personal.plugin.d.ts

@@ -0,0 +1,2 @@
+export declare class WechatPersonalPlugin {
+}

package/dist/lib/wechat-personal.plugin.js

@@ -0,0 +1,58 @@
+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;
+};
+import { XpertServerPlugin } from '@xpert-ai/plugin-sdk';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { DiscoveryModule } from '@nestjs/core';
+import { WechatPersonalController } from './wechat-personal.controller.js';
+import { WechatPersonalConversationService } from './conversation.service.js';
+import { WechatPersonalClient } from './wechat-personal.client.js';
+import { WechatPersonalChannelStrategy } from './wechat-personal-channel.strategy.js';
+import { WechatPersonalIntegrationStrategy } from './wechat-personal-integration.strategy.js';
+import { WechatPersonalAccountEntity, WechatPersonalConversationBindingEntity, WechatPersonalMessageLogEntity, WechatPersonalTriggerBindingEntity } from './entities/index.js';
+import { WechatPersonalChatCallbackProcessor, WechatPersonalChatDispatchService, WechatPersonalChatRunStateService } from './handoff/index.js';
+import { WechatPersonalTriggerAggregationService, WechatPersonalTriggerFlushProcessor, WechatPersonalTriggerStrategy } from './workflow/index.js';
+import { WechatPersonalViewProvider } from './views/wechat-personal-view.provider.js';
+import { WechatPersonalRuntimeMiddleware } from './wechat-personal.middleware.js';
+const entities = [
+    WechatPersonalTriggerBindingEntity,
+    WechatPersonalConversationBindingEntity,
+    WechatPersonalAccountEntity,
+    WechatPersonalMessageLogEntity
+];
+let WechatPersonalPlugin = class WechatPersonalPlugin {
+};
+WechatPersonalPlugin = __decorate([
+    XpertServerPlugin({
+        imports: [DiscoveryModule, TypeOrmModule.forFeature(entities)],
+        entities,
+        providers: [
+            WechatPersonalClient,
+            WechatPersonalConversationService,
+            WechatPersonalChannelStrategy,
+            WechatPersonalIntegrationStrategy,
+            WechatPersonalTriggerStrategy,
+            WechatPersonalTriggerAggregationService,
+            WechatPersonalTriggerFlushProcessor,
+            WechatPersonalChatDispatchService,
+            WechatPersonalChatRunStateService,
+            WechatPersonalChatCallbackProcessor,
+            WechatPersonalRuntimeMiddleware,
+            WechatPersonalViewProvider
+        ],
+        controllers: [WechatPersonalController],
+        exports: [
+            WechatPersonalClient,
+            WechatPersonalChannelStrategy,
+            WechatPersonalIntegrationStrategy,
+            WechatPersonalTriggerStrategy,
+            WechatPersonalConversationService,
+            WechatPersonalRuntimeMiddleware,
+            WechatPersonalViewProvider
+        ]
+    })
+], WechatPersonalPlugin);
+export { WechatPersonalPlugin };

package/dist/lib/wechat-personal.templates.d.ts

@@ -0,0 +1,2 @@
+import type { XpertTemplateContribution } from '@xpert-ai/plugin-sdk';
+export declare const wechatPersonalTemplates: XpertTemplateContribution[];