@xpert-ai/plugin-community-wechat 0.1.0

package/dist/lib/handoff/wechat-personal-chat-callback.processor.js

@@ -0,0 +1,312 @@
+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 WechatPersonalChatCallbackProcessor_1;
+import { Injectable, Logger } from '@nestjs/common';
+import { HandoffProcessorStrategy } from '@xpert-ai/plugin-sdk';
+import { ChatMessageEventTypeEnum, ChatMessageTypeEnum } from '@xpert-ai/chatkit-types';
+import { WechatPersonalChannelStrategy } from '../wechat-personal-channel.strategy.js';
+import { WechatPersonalConversationService } from '../conversation.service.js';
+import { WECHAT_PERSONAL_CHAT_CALLBACK_MESSAGE_TYPE } from './wechat-personal-chat.types.js';
+import { WechatPersonalChatRunStateService } from './wechat-personal-chat-run-state.service.js';
+function getTextStreamId(content) {
+    if (!content || typeof content !== 'object') {
+        return undefined;
+    }
+    const id = content.id;
+    return typeof id === 'string' && id ? id : undefined;
+}
+function appendPlainText(accumulator, incoming, joinWithoutSeparator) {
+    if (!accumulator) {
+        return incoming;
+    }
+    if (!incoming || /^\s/.test(incoming) || joinWithoutSeparator) {
+        return `${accumulator}${incoming}`;
+    }
+    if (!/[\s\n]$/.test(accumulator)) {
+        return `${accumulator}\n${incoming}`;
+    }
+    return `${accumulator}${incoming}`;
+}
+function filterTextItem(content) {
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (content && typeof content === 'object' && content.type === 'text') {
+        const text = content.text;
+        return typeof text === 'string' ? text : '';
+    }
+    return '';
+}
+function filterText(content) {
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        let result = '';
+        let previousStreamId;
+        for (const item of content) {
+            const nextText = filterTextItem(item);
+            if (!nextText) {
+                continue;
+            }
+            const streamId = getTextStreamId(item);
+            result = appendPlainText(result, nextText, !!previousStreamId && previousStreamId === streamId);
+            previousStreamId = streamId;
+        }
+        return result || null;
+    }
+    return filterTextItem(content) || null;
+}
+let WechatPersonalChatCallbackProcessor = WechatPersonalChatCallbackProcessor_1 = class WechatPersonalChatCallbackProcessor {
+    constructor(wechatChannel, conversationService, runStateService) {
+        this.wechatChannel = wechatChannel;
+        this.conversationService = conversationService;
+        this.runStateService = runStateService;
+        this.logger = new Logger(WechatPersonalChatCallbackProcessor_1.name);
+        this.sourceLocks = new Map();
+    }
+    async process(message, _ctx) {
+        const payload = message.payload;
+        if (!payload?.sourceMessageId) {
+            return {
+                status: 'dead',
+                reason: 'Missing sourceMessageId in WeChat personal callback payload'
+            };
+        }
+        if (!payload?.sequence || payload.sequence <= 0) {
+            return {
+                status: 'dead',
+                reason: 'Missing sequence in WeChat personal callback payload'
+            };
+        }
+        return this.runWithSourceLock(payload.sourceMessageId, async () => {
+            let state = await this.runStateService.get(payload.sourceMessageId);
+            if (!state) {
+                if (!payload.context) {
+                    return {
+                        status: 'dead',
+                        reason: `Run state not found for source message "${payload.sourceMessageId}"`
+                    };
+                }
+                state = this.createRunState(payload.sourceMessageId, payload.context);
+            }
+            state = this.ensureDefaults(state);
+            state.firstCallbackAt ||= Date.now();
+            if (payload.sequence < state.nextSequence) {
+                return { status: 'ok' };
+            }
+            if (!state.pendingEvents[String(payload.sequence)]) {
+                state.pendingEvents[String(payload.sequence)] = payload;
+            }
+            const completed = await this.processPendingEvents(state);
+            if (completed) {
+                await this.runStateService.clear(state.sourceMessageId);
+            }
+            else {
+                await this.runStateService.save(state);
+            }
+            return { status: 'ok' };
+        });
+    }
+    async runWithSourceLock(sourceMessageId, task) {
+        const previous = this.sourceLocks.get(sourceMessageId) ?? Promise.resolve();
+        const current = previous.catch(() => undefined).then(task);
+        this.sourceLocks.set(sourceMessageId, current);
+        try {
+            return await current;
+        }
+        finally {
+            if (this.sourceLocks.get(sourceMessageId) === current) {
+                this.sourceLocks.delete(sourceMessageId);
+            }
+        }
+    }
+    ensureDefaults(state) {
+        if (!state.pendingEvents) {
+            state.pendingEvents = {};
+        }
+        if (!state.nextSequence || state.nextSequence <= 0) {
+            state.nextSequence = 1;
+        }
+        if (typeof state.responseMessageContent !== 'string') {
+            state.responseMessageContent = '';
+        }
+        if (!state.runCreatedAt || state.runCreatedAt <= 0) {
+            state.runCreatedAt = Date.now();
+        }
+        return state;
+    }
+    createRunState(sourceMessageId, context) {
+        return {
+            sourceMessageId,
+            nextSequence: 1,
+            responseMessageContent: '',
+            finalMessageContent: undefined,
+            terminalError: undefined,
+            runCreatedAt: Date.now(),
+            context,
+            pendingEvents: {}
+        };
+    }
+    async processPendingEvents(state) {
+        while (true) {
+            if (!state.pendingEvents[String(state.nextSequence)]) {
+                const nextAvailableSequence = this.resolveNextAvailableSequence(state);
+                if (!nextAvailableSequence) {
+                    return false;
+                }
+                this.logger.warn(`[wechat-personal-callback] missing callback sequence source=${state.sourceMessageId} expected=${state.nextSequence} next=${nextAvailableSequence}; continuing with available event`);
+                state.nextSequence = nextAvailableSequence;
+            }
+            const payload = state.pendingEvents[String(state.nextSequence)];
+            delete state.pendingEvents[String(state.nextSequence)];
+            switch (payload.kind) {
+                case 'stream': {
+                    this.applyStreamEvent(state, payload.event);
+                    break;
+                }
+                case 'complete': {
+                    await this.completeRun(state);
+                    return true;
+                }
+                case 'error': {
+                    await this.failRun(state, payload.error);
+                    return true;
+                }
+                default: {
+                    this.logger.warn(`Unprocessed WeChat personal callback kind "${payload.kind}" in source "${state.sourceMessageId}"`);
+                }
+            }
+            state.nextSequence += 1;
+        }
+    }
+    applyStreamEvent(state, event) {
+        const eventPayload = event?.data;
+        if (!eventPayload) {
+            return;
+        }
+        if (eventPayload.type === ChatMessageTypeEnum.MESSAGE) {
+            const text = filterText(eventPayload.data) ?? '';
+            if (text) {
+                state.responseMessageContent += text;
+            }
+            return;
+        }
+        if (eventPayload.type !== ChatMessageTypeEnum.EVENT) {
+            return;
+        }
+        const conversationId = this.resolveConversationId(eventPayload);
+        if (conversationId) {
+            state.context.conversationId = conversationId;
+        }
+        if (eventPayload.event === ChatMessageEventTypeEnum.ON_MESSAGE_END) {
+            const finalText = this.extractFinalMessageText(eventPayload);
+            if (finalText) {
+                state.finalMessageContent = finalText;
+            }
+        }
+    }
+    async completeRun(state) {
+        const context = state.context;
+        const finalText = this.normalizeFinalText(state.finalMessageContent || state.responseMessageContent);
+        if (context.conversationUserKey && context.xpertId && context.conversationId) {
+            await this.conversationService.setConversation(context.conversationUserKey, context.xpertId, context.conversationId, undefined, context);
+        }
+        if (!finalText) {
+            this.logger.debug(`[wechat-personal-callback] skip empty final text integration=${context.integrationId} contact=${context.contactId}`);
+            return;
+        }
+        const result = await this.wechatChannel.sendTextByIntegrationId(context.integrationId, {
+            uuid: context.uuid,
+            contactId: context.contactId,
+            content: finalText
+        });
+        await this.conversationService.logOutbound({
+            context,
+            content: finalText,
+            status: result.success ? 'sent' : 'failed',
+            messageId: result.messageId,
+            error: result.error
+        });
+        if (!result.success) {
+            throw new Error(result.error || 'Failed to send WeChat personal reply');
+        }
+    }
+    async failRun(state, error) {
+        const context = state.context;
+        const message = error instanceof Error ? error.message : typeof error === 'string' ? error : 'Agent execution failed';
+        await this.conversationService.logOutbound({
+            context,
+            content: '',
+            status: 'failed',
+            error: message
+        });
+        const fallback = this.resolveFallbackText(context.preferLanguage, message);
+        await this.wechatChannel.sendTextByIntegrationId(context.integrationId, {
+            uuid: context.uuid,
+            contactId: context.contactId,
+            content: fallback
+        });
+    }
+    resolveConversationId(eventPayload) {
+        const candidates = [
+            eventPayload?.conversationId,
+            eventPayload?.conversation_id,
+            eventPayload?.data?.conversationId,
+            eventPayload?.data?.conversation_id,
+            eventPayload?.data?.id
+        ];
+        return candidates.find((value) => typeof value === 'string' && value.trim())?.trim();
+    }
+    resolveNextAvailableSequence(state) {
+        const sequences = Object.keys(state.pendingEvents)
+            .map((value) => Number(value))
+            .filter((value) => Number.isInteger(value) && value > state.nextSequence)
+            .sort((a, b) => a - b);
+        return sequences[0];
+    }
+    extractFinalMessageText(eventPayload) {
+        const candidates = [
+            eventPayload?.data?.content,
+            eventPayload?.data?.message?.content,
+            eventPayload?.data?.output,
+            eventPayload?.data?.text
+        ];
+        for (const candidate of candidates) {
+            const text = filterText(candidate);
+            if (text) {
+                return text;
+            }
+        }
+        return null;
+    }
+    normalizeFinalText(value) {
+        return (value || '').replace(/\n{3,}/g, '\n\n').trim();
+    }
+    resolveFallbackText(language, message) {
+        if (language === 'en') {
+            return `Sorry, I failed to generate a reply this time. ${message}`;
+        }
+        return `抱歉，这次回复生成失败了。${message}`;
+    }
+};
+WechatPersonalChatCallbackProcessor = WechatPersonalChatCallbackProcessor_1 = __decorate([
+    Injectable(),
+    HandoffProcessorStrategy(WECHAT_PERSONAL_CHAT_CALLBACK_MESSAGE_TYPE, {
+        types: [WECHAT_PERSONAL_CHAT_CALLBACK_MESSAGE_TYPE],
+        policy: {
+            lane: 'main'
+        }
+    }),
+    __metadata("design:paramtypes", [WechatPersonalChannelStrategy,
+        WechatPersonalConversationService,
+        WechatPersonalChatRunStateService])
+], WechatPersonalChatCallbackProcessor);
+export { WechatPersonalChatCallbackProcessor };

package/dist/lib/handoff/wechat-personal-chat-dispatch.service.d.ts

@@ -0,0 +1,26 @@
+import { AgentChatDispatchPayload, HandoffMessage, type PluginContext } from '@xpert-ai/plugin-sdk';
+import { WechatPersonalMessage } from '../message.js';
+import { WechatPersonalChatRunStateService } from './wechat-personal-chat-run-state.service.js';
+export type WechatPersonalChatDispatchInput = {
+    xpertId: string;
+    input?: string;
+    wechatMessage: WechatPersonalMessage;
+    conversationId?: string;
+    conversationUserKey?: string;
+    tenantId: string;
+    organizationId?: string;
+    executorUserId?: string;
+    endUserId?: string;
+};
+export declare class WechatPersonalChatDispatchService {
+    private readonly runStateService;
+    private readonly pluginContext;
+    private readonly logger;
+    private _handoffPermissionService;
+    constructor(runStateService: WechatPersonalChatRunStateService, pluginContext: PluginContext);
+    private get handoffPermissionService();
+    enqueueDispatch(input: WechatPersonalChatDispatchInput): Promise<WechatPersonalMessage>;
+    buildDispatchMessage(input: WechatPersonalChatDispatchInput): Promise<HandoffMessage<AgentChatDispatchPayload>>;
+    private buildChatRequest;
+    private normalizeString;
+}

package/dist/lib/handoff/wechat-personal-chat-dispatch.service.js

@@ -0,0 +1,187 @@
+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 WechatPersonalChatDispatchService_1;
+import { randomUUID } from 'crypto';
+import { Inject, Injectable, Logger } from '@nestjs/common';
+import { AGENT_CHAT_DISPATCH_MESSAGE_TYPE, HANDOFF_PERMISSION_SERVICE_TOKEN, RequestContext } from '@xpert-ai/plugin-sdk';
+import { WECHAT_PERSONAL_PLUGIN_CONTEXT } from '../tokens.js';
+import { WECHAT_PERSONAL_CHAT_CALLBACK_MESSAGE_TYPE } from './wechat-personal-chat.types.js';
+import { WechatPersonalChatRunStateService } from './wechat-personal-chat-run-state.service.js';
+let WechatPersonalChatDispatchService = WechatPersonalChatDispatchService_1 = class WechatPersonalChatDispatchService {
+    constructor(runStateService, pluginContext) {
+        this.runStateService = runStateService;
+        this.pluginContext = pluginContext;
+        this.logger = new Logger(WechatPersonalChatDispatchService_1.name);
+    }
+    get handoffPermissionService() {
+        if (!this._handoffPermissionService) {
+            this._handoffPermissionService = this.pluginContext.resolve(HANDOFF_PERMISSION_SERVICE_TOKEN);
+        }
+        return this._handoffPermissionService;
+    }
+    async enqueueDispatch(input) {
+        const message = await this.buildDispatchMessage(input);
+        await this.handoffPermissionService.enqueue(message, {
+            delayMs: 0
+        });
+        return input.wechatMessage;
+    }
+    async buildDispatchMessage(input) {
+        const { xpertId, wechatMessage, input: textInput, conversationId, conversationUserKey, tenantId, organizationId, executorUserId, endUserId } = input;
+        const resolvedExecutorUserId = this.normalizeString(executorUserId) ||
+            this.normalizeString(RequestContext.currentUserId()) ||
+            `wechat-personal:${wechatMessage.integrationId}:system`;
+        const runId = `wechat-personal-chat-${randomUUID()}`;
+        const sessionKey = conversationId ||
+            conversationUserKey ||
+            `${wechatMessage.integrationId}:${wechatMessage.uuid}:${wechatMessage.contactId}:${wechatMessage.senderId || ''}`;
+        const language = (wechatMessage.language || RequestContext.getLanguageCode() || 'zh-Hans');
+        const callbackContext = {
+            tenantId,
+            organizationId,
+            userId: resolvedExecutorUserId,
+            xpertId,
+            from: 'wechat_personal',
+            channelType: 'wechat_personal',
+            wechatPersonalConversation: true,
+            wechat_personal_conversation: true,
+            channelSource: 'wechat_personal_webhook',
+            channel_source: 'wechat_personal_webhook',
+            integrationId: wechatMessage.integrationId,
+            uuid: wechatMessage.uuid,
+            ownerWxid: wechatMessage.ownerWxid,
+            contactId: wechatMessage.contactId,
+            contact_id: wechatMessage.contactId,
+            chatId: wechatMessage.contactId,
+            chat_id: wechatMessage.contactId,
+            chatType: wechatMessage.chatType,
+            chat_type: wechatMessage.chatType,
+            senderId: wechatMessage.senderId,
+            sender_id: wechatMessage.senderId,
+            responseStrategy: 'final_text',
+            preferLanguage: language,
+            conversationUserKey: conversationUserKey || undefined,
+            conversationId: conversationId || undefined,
+            message: {
+                id: wechatMessage.id || undefined,
+                messageId: wechatMessage.messageId || undefined,
+                status: wechatMessage.status,
+                language
+            }
+        };
+        await this.runStateService.save({
+            sourceMessageId: runId,
+            nextSequence: 1,
+            responseMessageContent: '',
+            runCreatedAt: Date.now(),
+            context: callbackContext,
+            pendingEvents: {}
+        });
+        this.logger.debug(`[wechat-personal-dispatch] build dispatch runId=${runId} xpertId=${xpertId} sessionKey=${sessionKey} integration=${wechatMessage.integrationId}`);
+        return {
+            id: runId,
+            type: AGENT_CHAT_DISPATCH_MESSAGE_TYPE,
+            version: 1,
+            tenantId,
+            sessionKey,
+            businessKey: sessionKey,
+            attempt: 1,
+            maxAttempts: 1,
+            enqueuedAt: Date.now(),
+            traceId: runId,
+            payload: {
+                request: this.buildChatRequest({
+                    conversationId,
+                    input: textInput
+                }),
+                options: {
+                    xpertId,
+                    from: 'wechat_personal',
+                    fromEndUserId: endUserId || wechatMessage.senderId || resolvedExecutorUserId,
+                    tenantId,
+                    organizationId,
+                    user: {
+                        id: resolvedExecutorUserId,
+                        tenantId
+                    },
+                    language,
+                    channelType: 'wechat_personal',
+                    wechatPersonalConversation: true,
+                    wechat_personal_conversation: true,
+                    channelSource: 'wechat_personal_webhook',
+                    channel_source: 'wechat_personal_webhook',
+                    integrationId: wechatMessage.integrationId,
+                    uuid: wechatMessage.uuid,
+                    ownerWxid: wechatMessage.ownerWxid,
+                    contactId: wechatMessage.contactId,
+                    contact_id: wechatMessage.contactId,
+                    chatId: wechatMessage.contactId,
+                    chat_id: wechatMessage.contactId,
+                    chatType: wechatMessage.chatType,
+                    chat_type: wechatMessage.chatType,
+                    senderId: wechatMessage.senderId,
+                    sender_id: wechatMessage.senderId,
+                    channelUserId: wechatMessage.senderId
+                },
+                callback: {
+                    messageType: WECHAT_PERSONAL_CHAT_CALLBACK_MESSAGE_TYPE,
+                    headers: {
+                        ...(organizationId ? { organizationId } : {}),
+                        ...(resolvedExecutorUserId ? { userId: resolvedExecutorUserId } : {}),
+                        ...(language ? { language } : {}),
+                        ...(conversationId ? { conversationId } : {}),
+                        source: 'api',
+                        handoffQueue: 'integration',
+                        requestedLane: 'main',
+                        ...(wechatMessage.integrationId ? { integrationId: wechatMessage.integrationId } : {})
+                    },
+                    context: callbackContext
+                }
+            },
+            headers: {
+                ...(organizationId ? { organizationId } : {}),
+                ...(resolvedExecutorUserId ? { userId: resolvedExecutorUserId } : {}),
+                ...(language ? { language } : {}),
+                ...(conversationId ? { conversationId } : {}),
+                source: 'api',
+                requestedLane: 'main',
+                handoffQueue: 'realtime',
+                ...(wechatMessage.integrationId ? { integrationId: wechatMessage.integrationId } : {})
+            }
+        };
+    }
+    buildChatRequest(params) {
+        return {
+            action: 'send',
+            ...(params.conversationId ? { conversationId: params.conversationId } : {}),
+            message: {
+                input: {
+                    input: params.input ?? ''
+                }
+            }
+        };
+    }
+    normalizeString(value) {
+        if (typeof value !== 'string') {
+            return undefined;
+        }
+        const text = value.trim();
+        return text || undefined;
+    }
+};
+WechatPersonalChatDispatchService = WechatPersonalChatDispatchService_1 = __decorate([
+    Injectable(),
+    __param(1, Inject(WECHAT_PERSONAL_PLUGIN_CONTEXT)),
+    __metadata("design:paramtypes", [WechatPersonalChatRunStateService, Object])
+], WechatPersonalChatDispatchService);
+export { WechatPersonalChatDispatchService };

package/dist/lib/handoff/wechat-personal-chat-run-state.service.d.ts

@@ -0,0 +1,21 @@
+import { type Cache } from 'cache-manager';
+import { WechatPersonalChatCallbackContext, WechatPersonalChatCallbackPayload } from './wechat-personal-chat.types.js';
+export interface WechatPersonalChatRunState {
+    sourceMessageId: string;
+    nextSequence: number;
+    responseMessageContent: string;
+    finalMessageContent?: string;
+    terminalError?: string;
+    runCreatedAt: number;
+    firstCallbackAt?: number;
+    context: WechatPersonalChatCallbackContext;
+    pendingEvents: Record<string, WechatPersonalChatCallbackPayload>;
+}
+export declare class WechatPersonalChatRunStateService {
+    private readonly cacheManager;
+    constructor(cacheManager: Cache);
+    save(state: WechatPersonalChatRunState, ttlSeconds?: number): Promise<void>;
+    get(sourceMessageId: string): Promise<WechatPersonalChatRunState | null>;
+    clear(sourceMessageId: string): Promise<void>;
+    private buildKey;
+}

package/dist/lib/handoff/wechat-personal-chat-run-state.service.js

@@ -0,0 +1,39 @@
+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 { CACHE_MANAGER } from '@nestjs/cache-manager';
+import { Inject, Injectable } from '@nestjs/common';
+const DEFAULT_RUN_STATE_TTL_SECONDS = 15 * 60;
+let WechatPersonalChatRunStateService = class WechatPersonalChatRunStateService {
+    constructor(cacheManager) {
+        this.cacheManager = cacheManager;
+    }
+    async save(state, ttlSeconds = DEFAULT_RUN_STATE_TTL_SECONDS) {
+        await this.cacheManager.set(this.buildKey(state.sourceMessageId), state, ttlSeconds * 1000);
+    }
+    async get(sourceMessageId) {
+        const state = await this.cacheManager.get(this.buildKey(sourceMessageId));
+        return state ?? null;
+    }
+    async clear(sourceMessageId) {
+        await this.cacheManager.del(this.buildKey(sourceMessageId));
+    }
+    buildKey(sourceMessageId) {
+        return `wechat-personal:handoff:run:${sourceMessageId}`;
+    }
+};
+WechatPersonalChatRunStateService = __decorate([
+    Injectable(),
+    __param(0, Inject(CACHE_MANAGER)),
+    __metadata("design:paramtypes", [Object])
+], WechatPersonalChatRunStateService);
+export { WechatPersonalChatRunStateService };

package/dist/lib/handoff/wechat-personal-chat.types.d.ts

@@ -0,0 +1,69 @@
+import { LanguagesEnum, TChatOptions, TChatRequest } from '@xpert-ai/contracts';
+import { AgentChatCallbackEnvelopePayload } from '@xpert-ai/plugin-sdk';
+export declare const WECHAT_PERSONAL_CHAT_CALLBACK_MESSAGE_TYPE: import("@xpert-ai/plugin-sdk").StructuredHandoffMessageType;
+export interface WechatPersonalChatMessageSnapshot {
+    id?: string;
+    messageId?: string;
+    status?: string;
+    language?: string;
+}
+export interface WechatPersonalChatCallbackContext extends Record<string, unknown> {
+    tenantId: string;
+    organizationId?: string;
+    userId: string;
+    xpertId: string;
+    from?: string;
+    channelType?: string;
+    wechatPersonalConversation?: boolean;
+    wechat_personal_conversation?: boolean;
+    channelSource?: string;
+    channel_source?: string;
+    integrationId: string;
+    uuid: string;
+    ownerWxid?: string;
+    contactId: string;
+    contact_id?: string;
+    chatId: string;
+    chat_id?: string;
+    chatType?: 'private' | 'group';
+    chat_type?: 'private' | 'group';
+    senderId?: string;
+    sender_id?: string;
+    responseStrategy?: 'final_text';
+    preferLanguage?: string;
+    conversationUserKey?: string;
+    conversationId?: string;
+    message: WechatPersonalChatMessageSnapshot;
+}
+export interface WechatPersonalChatCallbackPayload extends AgentChatCallbackEnvelopePayload {
+    context?: WechatPersonalChatCallbackContext;
+}
+export interface WechatPersonalChatHandoffPayload extends Record<string, unknown> {
+    request: TChatRequest;
+    options: TChatOptions & {
+        xpertId: string;
+        from: string;
+        fromEndUserId: string;
+        tenantId: string;
+        organizationId?: string;
+        user?: any;
+        language?: LanguagesEnum;
+        channelType?: string;
+        wechatPersonalConversation?: boolean;
+        wechat_personal_conversation?: boolean;
+        channelSource?: string;
+        channel_source?: string;
+        integrationId?: string;
+        uuid?: string;
+        ownerWxid?: string;
+        contactId?: string;
+        contact_id?: string;
+        chatId?: string;
+        chat_id?: string;
+        chatType?: 'private' | 'group';
+        chat_type?: 'private' | 'group';
+        senderId?: string;
+        sender_id?: string;
+        channelUserId?: string;
+    };
+}

package/dist/lib/handoff/wechat-personal-chat.types.js

@@ -0,0 +1,2 @@
+import { defineChannelMessageType } from '@xpert-ai/plugin-sdk';
+export const WECHAT_PERSONAL_CHAT_CALLBACK_MESSAGE_TYPE = defineChannelMessageType('wechat_personal', 'chat_final_event', 1);