@dofe/infra-clients 0.1.1

package/dist/internal/agentx/agentx-client.service.js

@@ -0,0 +1,912 @@
+"use strict";
+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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentXClient = exports.ImageGenerationResponseSchema = exports.ImageEditRequestSchema = exports.ImageGenerationRequestSchema = void 0;
+const common_1 = require("@nestjs/common");
+const nest_winston_1 = require("nest-winston");
+const winston_1 = require("winston");
+const axios_1 = require("@nestjs/axios");
+const config_1 = require("@nestjs/config");
+const rxjs_1 = require("rxjs");
+const zod_1 = require("zod");
+const infra_common_1 = require("@dofe/infra-common");
+const infra_common_2 = require("@dofe/infra-common");
+const infra_utils_1 = require("@dofe/infra-utils");
+// ============================================================================
+// Types - Image Generation (Zod-first)
+// ============================================================================
+/**
+ * 图像生成请求 Schema
+ */
+exports.ImageGenerationRequestSchema = zod_1.z.object({
+    model: zod_1.z.string().min(1, '模型名称不能为空'),
+    prompt: zod_1.z.string().min(1, '提示词不能为空'),
+    n: zod_1.z.number().int().positive().optional().default(1),
+    response_format: zod_1.z
+        .enum(['url', 'b64_json'])
+        .optional()
+        .default('url'),
+    aspect_ratio: zod_1.z.string().optional(),
+    image_size: zod_1.z.string().optional(),
+});
+/**
+ * 图像编辑请求 Schema
+ */
+exports.ImageEditRequestSchema = exports.ImageGenerationRequestSchema.extend({
+    image: zod_1.z
+        .array(zod_1.z.string().url('图片URL格式不正确'))
+        .min(1, '至少需要一张图片'),
+});
+/**
+ * 图像生成响应 Schema
+ */
+exports.ImageGenerationResponseSchema = zod_1.z.object({
+    data: zod_1.z.array(zod_1.z.object({
+        url: zod_1.z.string().url().optional(),
+        b64_json: zod_1.z.string().optional().nullable(),
+    })),
+    created: zod_1.z.number().int(),
+});
+/**
+ * AgentX Internal Client
+ *
+ * 封装所有与 Python AgentX API 的交互
+ * - 统一的 HTTP 请求处理
+ * - 统一的错误处理和重试机制
+ * - 统一的超时管理
+ * - 统一的 callback URL 管理
+ * - 协同过滤推荐
+ * - 健康检查
+ */
+let AgentXClient = class AgentXClient {
+    logger;
+    httpService;
+    configService;
+    baseUrl = '';
+    internalApiUrl = '';
+    agentxConfig;
+    constructor(logger, httpService, configService) {
+        this.logger = logger;
+        this.httpService = httpService;
+        this.configService = configService;
+    }
+    onModuleInit() {
+        const keysConfig = (0, infra_common_1.getKeysConfig)();
+        this.agentxConfig = keysConfig?.agentx;
+        this.baseUrl = this.agentxConfig?.baseUrl || '';
+        if (!this.baseUrl) {
+            throw new Error('AgentXClient: baseUrl not configured');
+        }
+        // 初始化 internalApiUrl 用于 callback
+        this.internalApiUrl = infra_utils_1.environmentUtil
+            .generateEnvironmentUrls()
+            .internalApi.replace(/\/+$/, ''); // 去除末尾斜杠
+        this.logger.info(`AgentX Client initialized with baseUrl: ${this.baseUrl}`);
+        this.logger.info(`Callback URL: ${this.internalApiUrl}/webhook/python-task`);
+    }
+    /**
+     * 获取包含认证头的请求配置
+     */
+    getAuthHeaders(additionalHeaders = {}) {
+        return {
+            ...additionalHeaders,
+            ...infra_common_2.AgentXConfigHelper.getAuthHeaders(),
+            ...{ 'Content-Type': 'application/json' },
+        };
+    }
+    /**
+     * 创建 Python 任务
+     *
+     * @param request 创建任务请求参数
+     * @returns 任务 ID
+     */
+    async createTask(request) {
+        this.logger.info(`Creating task: ${request.name}`);
+        // 自动添加统一的 callback URL（如果未提供）
+        const callbackUrl = request.callback || `${this.internalApiUrl}/webhook/python-task`;
+        try {
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.post(`${this.baseUrl}/task`, {
+                name: request.name,
+                params: request.params,
+                callback: callbackUrl,
+            }, {
+                headers: this.getAuthHeaders(),
+                timeout: 30000, // 30 秒超时
+            }));
+            const taskId = response.data.id;
+            this.logger.info(`Task created successfully: ${taskId}, callback: ${callbackUrl}`);
+            return taskId;
+        }
+        catch (error) {
+            this.handleError('createTask', error, {
+                taskName: request.name,
+            });
+        }
+    }
+    /**
+     * 查询任务状态
+     *
+     * @param taskId 任务 ID
+     * @returns 任务状态信息
+     */
+    async getTaskStatus(taskId) {
+        this.logger.debug(`Getting task status: ${taskId}`);
+        try {
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.get(`${this.baseUrl}/task/${taskId}`, {
+                headers: this.getAuthHeaders(),
+                timeout: 10000, // 10 秒超时
+            }));
+            return response.data;
+        }
+        catch (error) {
+            this.handleError('getTaskStatus', error, { taskId });
+        }
+    }
+    /**
+     * 取消任务
+     *
+     * @param taskId 任务 ID
+     * @returns 取消结果
+     */
+    async cancelTask(taskId) {
+        this.logger.info(`Cancelling task: ${taskId}`);
+        try {
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.delete(`${this.baseUrl}/task/${taskId}`, {
+                headers: this.getAuthHeaders(),
+                timeout: 10000, // 10 秒超时
+            }));
+            this.logger.info(`Task cancelled successfully: ${taskId}`);
+            return response.data;
+        }
+        catch (error) {
+            this.handleError('cancelTask', error, { taskId });
+        }
+    }
+    /**
+     * 统一错误处理
+     *
+     * @param operation 操作名称
+     * @param error Axios 错误对象
+     * @param context 上下文信息
+     */
+    handleError(operation, error, context) {
+        const errorMessage = this.extractErrorMessage(error);
+        const statusCode = error.response?.status;
+        this.logger.error(`AgentX API Error [${operation}]: ${errorMessage}`, {
+            statusCode,
+            context,
+            responseData: error.response?.data,
+        });
+        // 根据 HTTP 状态码抛出不同的错误
+        if (statusCode === 404) {
+            throw new Error(`Task not found: ${context?.taskId || 'unknown'}`);
+        }
+        else if (statusCode === 400) {
+            throw new Error(`Invalid request: ${errorMessage}`);
+        }
+        else if (statusCode === 500) {
+            throw new Error(`AgentX server error: ${errorMessage}`);
+        }
+        else if (statusCode === 503) {
+            throw new Error(`AgentX service unavailable: ${errorMessage}`);
+        }
+        else if (error.code === 'ECONNREFUSED') {
+            throw new Error(`Cannot connect to AgentX server: ${this.baseUrl}`);
+        }
+        else if (error.code === 'ETIMEDOUT') {
+            throw new Error(`AgentX request timeout: ${operation}`);
+        }
+        else {
+            throw new Error(`AgentX API error: ${errorMessage}`);
+        }
+    }
+    /**
+     * 提取错误消息
+     *
+     * @param error Axios 错误对象
+     * @returns 错误消息
+     */
+    extractErrorMessage(error) {
+        if (error.response?.data) {
+            const data = error.response.data;
+            return data.message || data.error || data.detail || 'Unknown error';
+        }
+        return error.message || 'Unknown error';
+    }
+    /**
+     * 通用 GET 请求
+     */
+    async get(url, config) {
+        try {
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.get(`${this.baseUrl}${url}`, config));
+            return response.data;
+        }
+        catch (error) {
+            this.handleError('get', error, { url });
+        }
+    }
+    /**
+     * 通用 POST 请求
+     */
+    async post(url, data, config) {
+        try {
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.post(`${this.baseUrl}${url}`, data, config));
+            return response.data;
+        }
+        catch (error) {
+            this.handleError('post', error, { url });
+        }
+    }
+    /**
+     * 通用 PUT 请求
+     */
+    async put(url, data, config) {
+        try {
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.put(`${this.baseUrl}${url}`, data, config));
+            return response.data;
+        }
+        catch (error) {
+            this.handleError('put', error, { url });
+        }
+    }
+    /**
+     * 通用 DELETE 请求
+     */
+    async delete(url, config) {
+        try {
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.delete(`${this.baseUrl}${url}`, config));
+            return response.data;
+        }
+        catch (error) {
+            this.handleError('delete', error, { url });
+        }
+    }
+    /**
+     * 检查 AgentX 服务是否可用
+     *
+     * @returns 是否可用
+     */
+    async isHealthy() {
+        try {
+            await (0, rxjs_1.firstValueFrom)(this.httpService.get(`${this.baseUrl}/health`, {
+                timeout: 5000,
+            }));
+            return true;
+        }
+        catch (error) {
+            this.logger.warn('AgentX health check failed', {
+                error: error.message,
+            });
+            return false;
+        }
+    }
+    /**
+     * 健康检查（别名方法，兼容旧代码）
+     */
+    async healthCheck() {
+        return this.isHealthy();
+    }
+    /**
+     * 生成协同过滤推荐
+     *
+     * @param request - 推荐请求参数
+     * @returns 推荐结果
+     * @throws 如果 AgentX 服务不可用或返回错误
+     */
+    async generateCollaborativeRecommendations(request) {
+        const endpoint = '/api/recommendation/collaborative';
+        try {
+            this.logger.info('[AgentX] Generating collaborative recommendations', {
+                teamId: request.team_id,
+                userId: request.user_id,
+                algorithm: request.algorithm || 'hybrid',
+            });
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.post(`${this.baseUrl}${endpoint}`, request, {
+                headers: this.getAuthHeaders(),
+                timeout: 30000,
+            }));
+            this.logger.info('[AgentX] Collaborative recommendations generated', {
+                total: response.data.total,
+                executionTime: response.data.execution_time_ms,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.logger.error('[AgentX] Failed to generate collaborative recommendations', {
+                error: error.message,
+                teamId: request.team_id,
+                userId: request.user_id,
+            });
+            throw new Error(`AgentX collaborative recommendation failed: ${error.message}`);
+        }
+    }
+    /**
+     * 生成产品关键词
+     *
+     * @param request - 关键词生成请求参数
+     * @returns 关键词数组
+     * @throws 如果 AgentX 服务不可用或返回错误
+     */
+    async generateProductKeywords(request) {
+        const endpoint = '/api/ai/keywords';
+        try {
+            this.logger.info('[AgentX] Generating product keywords', {
+                productName: request.productName,
+            });
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.post(`${this.baseUrl}${endpoint}`, {
+                product_name: request.productName,
+                product_selling_points: request.productSellingPoints,
+            }, {
+                headers: this.getAuthHeaders(),
+                timeout: 30000,
+            }));
+            this.logger.info('[AgentX] Product keywords generated', {
+                count: response.data.keywords.length,
+            });
+            return response.data.keywords;
+        }
+        catch (error) {
+            this.logger.error('[AgentX] Failed to generate product keywords', {
+                error: error.message,
+                productName: request.productName,
+            });
+            throw new Error(`AgentX product keywords generation failed: ${error.message}`);
+        }
+    }
+    /**
+     * LLM Chat Completion
+     *
+     * @param request - LLM 请求参数
+     * @returns LLM 响应
+     * @throws 如果 AgentX 服务不可用或返回错误
+     */
+    async chatCompletion(request) {
+        const endpoint = '/ai/v1/chat/completions';
+        try {
+            this.logger.info('[AgentX] Calling LLM chat completion', {
+                model: request.model,
+                messageCount: request.messages.length,
+            });
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.post(`${this.baseUrl}${endpoint}`, request, {
+                headers: this.getAuthHeaders(),
+                timeout: 120000, // 2分钟超时
+            }));
+            this.logger.info('[AgentX] LLM chat completion successful', {
+                model: request.model,
+                finishReason: response.data.choices?.[0]?.finish_reason,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.logger.error('[AgentX] LLM chat completion failed', {
+                error: error.message,
+                model: request.model,
+            });
+            throw new Error(`AgentX LLM chat completion failed: ${error.message}`);
+        }
+    }
+    /**
+     * 生成图像
+     *
+     * @param request - 图像生成请求参数
+     * @returns 图像生成响应
+     * @throws 如果 AgentX 服务不可用或返回错误
+     */
+    async generateImage(request) {
+        const endpoint = '/ai/v1/images/generations';
+        try {
+            // Zod 验证请求参数
+            const validatedRequest = exports.ImageGenerationRequestSchema.parse(request);
+            this.logger.info('[AgentX] Generating image', {
+                model: validatedRequest.model,
+                prompt: validatedRequest.prompt.substring(0, 50),
+            });
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.post(`${this.baseUrl}${endpoint}`, {
+                model: validatedRequest.model,
+                prompt: validatedRequest.prompt,
+                n: validatedRequest.n,
+                response_format: validatedRequest.response_format,
+                aspect_ratio: validatedRequest.aspect_ratio,
+                image_size: validatedRequest.image_size,
+            }, {
+                headers: this.getAuthHeaders(),
+                timeout: 120000, // 2分钟超时
+            }));
+            // Zod 验证响应数据
+            const validatedResponse = exports.ImageGenerationResponseSchema.parse(response.data);
+            this.logger.info('[AgentX] Image generated successfully', {
+                model: validatedRequest.model,
+                imageCount: validatedResponse.data.length,
+            });
+            return validatedResponse;
+        }
+        catch (error) {
+            if (error instanceof zod_1.z.ZodError) {
+                this.logger.error('[AgentX] Image generation validation failed', {
+                    errors: error.issues,
+                });
+                throw new Error(`AgentX image generation validation failed: ${error.issues.map((e) => e.message).join(', ')}`);
+            }
+            this.logger.error('[AgentX] Image generation failed', {
+                error: error.message,
+                model: request.model,
+            });
+            throw new Error(`AgentX image generation failed: ${error.message}`);
+        }
+    }
+    /**
+     * 编辑图像
+     *
+     * @param request - 图像编辑请求参数
+     * @returns 图像生成响应
+     * @throws 如果 AgentX 服务不可用或返回错误
+     */
+    async editImage(request) {
+        const endpoint = '/ai/v1/images/edits';
+        try {
+            // Zod 验证请求参数
+            const validatedRequest = exports.ImageEditRequestSchema.parse(request);
+            this.logger.info('[AgentX] Editing image', {
+                model: validatedRequest.model,
+                prompt: validatedRequest.prompt.substring(0, 50),
+                imageCount: validatedRequest.image.length,
+            });
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.post(`${this.baseUrl}${endpoint}`, {
+                model: validatedRequest.model,
+                image: validatedRequest.image,
+                prompt: validatedRequest.prompt,
+                response_format: validatedRequest.response_format,
+                aspect_ratio: validatedRequest.aspect_ratio,
+                image_size: validatedRequest.image_size,
+            }, {
+                headers: this.getAuthHeaders(),
+                timeout: 120000,
+            }));
+            // Zod 验证响应数据
+            const validatedResponse = exports.ImageGenerationResponseSchema.parse(response.data);
+            this.logger.info('[AgentX] Image edited successfully', {
+                model: validatedRequest.model,
+                imageCount: validatedResponse.data.length,
+            });
+            return validatedResponse;
+        }
+        catch (error) {
+            if (error instanceof zod_1.z.ZodError) {
+                this.logger.error('[AgentX] Image editing validation failed', {
+                    errors: error.issues,
+                });
+                throw new Error(`AgentX image editing validation failed: ${error.issues.map((e) => e.message).join(', ')}`);
+            }
+            this.logger.error('[AgentX] Image editing failed', {
+                error: error.message,
+                model: request.model,
+            });
+            throw new Error(`AgentX image editing failed: ${error.message}`);
+        }
+    }
+    // ============================================================================
+    // Memory Management APIs
+    // ============================================================================
+    /**
+     * 创建对话记忆
+     */
+    async createConversationMemory(request) {
+        const endpoint = '/api/memory/conversations';
+        try {
+            this.logger.info('[AgentX] Creating conversation memory', {
+                teamId: request.team_id,
+                userId: request.user_id,
+                sessionId: request.session_id,
+            });
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.post(`${this.baseUrl}${endpoint}`, request, {
+                headers: this.getAuthHeaders(),
+                timeout: 30000,
+            }));
+            this.logger.info('[AgentX] Conversation memory created', {
+                memoryId: response.data.memory_id,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError('createConversationMemory', error, {
+                teamId: request.team_id,
+                userId: request.user_id,
+            });
+        }
+    }
+    /**
+     * 创建任务记忆
+     */
+    async createTaskMemory(request) {
+        const endpoint = '/api/memory/tasks';
+        try {
+            this.logger.info('[AgentX] Creating task memory', {
+                taskId: request.task_id,
+                taskName: request.task_name,
+            });
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.post(`${this.baseUrl}${endpoint}`, {
+                ...request,
+                task_result: JSON.stringify(request.task_result),
+            }, {
+                headers: this.getAuthHeaders(),
+                timeout: 30000,
+            }));
+            return response.data;
+        }
+        catch (error) {
+            this.handleError('createTaskMemory', error, {
+                taskId: request.task_id,
+            });
+        }
+    }
+    /**
+     * 创建决策记忆
+     */
+    async createDecisionMemory(request) {
+        const endpoint = '/api/memory/decisions';
+        try {
+            this.logger.info('[AgentX] Creating decision memory', {
+                userId: request.user_id,
+                workflowId: request.workflow_id,
+            });
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.post(`${this.baseUrl}${endpoint}`, {
+                ...request,
+                decision_result: JSON.stringify(request.decision_result),
+            }, {
+                headers: this.getAuthHeaders(),
+                timeout: 30000,
+            }));
+            return response.data;
+        }
+        catch (error) {
+            this.handleError('createDecisionMemory', error, {
+                userId: request.user_id,
+            });
+        }
+    }
+    /**
+     * 搜索记忆 (GET)
+     */
+    async searchMemories(params) {
+        const endpoint = '/api/memory/search';
+        try {
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.get(`${this.baseUrl}${endpoint}`, {
+                params,
+                headers: this.getAuthHeaders(),
+                timeout: 30000,
+            }));
+            return response.data;
+        }
+        catch (error) {
+            this.handleError('searchMemories', error, {
+                query: params.q,
+            });
+        }
+    }
+    /**
+     * 搜索记忆 (POST - 复杂查询)
+     */
+    async searchMemoriesPost(data) {
+        const endpoint = '/api/memory/search';
+        try {
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.post(`${this.baseUrl}${endpoint}`, data, {
+                headers: this.getAuthHeaders(),
+                timeout: 30000,
+            }));
+            return response.data;
+        }
+        catch (error) {
+            this.handleError('searchMemoriesPost', error, {
+                query: data.query,
+            });
+        }
+    }
+    /**
+     * 获取记忆详情
+     */
+    async getMemoryById(memoryId) {
+        const endpoint = `/api/memory/${memoryId}`;
+        try {
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.get(`${this.baseUrl}${endpoint}`, {
+                headers: this.getAuthHeaders(),
+                timeout: 10000,
+            }));
+            return response.data;
+        }
+        catch (error) {
+            this.handleError('getMemoryById', error, {
+                memoryId,
+            });
+        }
+    }
+    /**
+     * 删除记忆
+     */
+    async deleteMemory(memoryId) {
+        const endpoint = `/api/memory/${memoryId}`;
+        try {
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.delete(`${this.baseUrl}${endpoint}`, {
+                headers: this.getAuthHeaders(),
+                timeout: 10000,
+            }));
+            return response.data;
+        }
+        catch (error) {
+            this.handleError('deleteMemory', error, {
+                memoryId,
+            });
+        }
+    }
+    /**
+     * 获取记忆列表
+     */
+    async listMemories(params) {
+        const endpoint = '/api/memory/list';
+        try {
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.get(`${this.baseUrl}${endpoint}`, {
+                params,
+                headers: this.getAuthHeaders(),
+                timeout: 30000,
+            }));
+            return response.data;
+        }
+        catch (error) {
+            this.handleError('listMemories', error, {
+                userId: params.user_id,
+            });
+        }
+    }
+    /**
+     * 获取记忆统计
+     */
+    async getMemoryStats(params) {
+        const endpoint = '/api/memory/stats';
+        try {
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.get(`${this.baseUrl}${endpoint}`, {
+                params,
+                headers: this.getAuthHeaders(),
+                timeout: 30000,
+            }));
+            return response.data;
+        }
+        catch (error) {
+            this.handleError('getMemoryStats', error, {
+                userId: params.user_id,
+            });
+        }
+    }
+    /**
+     * 获取会话历史
+     */
+    async getSessionHistory(sessionId) {
+        const endpoint = `/api/memory/sessions/${sessionId}`;
+        try {
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.get(`${this.baseUrl}${endpoint}`, {
+                headers: this.getAuthHeaders(),
+                timeout: 30000,
+            }));
+            return response.data;
+        }
+        catch (error) {
+            this.handleError('getSessionHistory', error, {
+                sessionId,
+            });
+        }
+    }
+    // ============================================================================
+    // Preference Management APIs
+    // ============================================================================
+    /**
+     * 推断用户偏好
+     */
+    async inferPreference(request) {
+        const endpoint = '/preferences/infer';
+        try {
+            this.logger.info('[AgentX] Inferring user preference', {
+                teamId: request.team_id,
+                userId: request.user_id,
+                category: request.category,
+            });
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.post(`${this.baseUrl}${endpoint}`, request, {
+                headers: this.getAuthHeaders(),
+                timeout: 30000,
+            }));
+            return response.data;
+        }
+        catch (error) {
+            this.handleError('inferPreference', error, {
+                teamId: request.team_id,
+                userId: request.user_id,
+            });
+        }
+    }
+    /**
+     * 获取用户偏好
+     */
+    async getUserPreferences(params) {
+        const endpoint = '/preferences';
+        try {
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.get(`${this.baseUrl}${endpoint}`, {
+                params,
+                headers: this.getAuthHeaders(),
+                timeout: 30000,
+            }));
+            return response.data;
+        }
+        catch (error) {
+            this.handleError('getUserPreferences', error, {
+                userId: params.user_id,
+            });
+        }
+    }
+    /**
+     * 更新用户偏好
+     */
+    async updatePreference(preferenceId, data) {
+        const endpoint = `/preferences/${preferenceId}`;
+        try {
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.put(`${this.baseUrl}${endpoint}`, data, {
+                headers: this.getAuthHeaders(),
+                timeout: 30000,
+            }));
+            return response.data;
+        }
+        catch (error) {
+            this.handleError('updatePreference', error, {
+                preferenceId,
+            });
+        }
+    }
+    /**
+     * 删除用户偏好
+     */
+    async deletePreference(preferenceId, params) {
+        const endpoint = `/preferences/${preferenceId}`;
+        try {
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.delete(`${this.baseUrl}${endpoint}`, {
+                params,
+                headers: this.getAuthHeaders(),
+                timeout: 10000,
+            }));
+            return response.data;
+        }
+        catch (error) {
+            this.handleError('deletePreference', error, {
+                preferenceId,
+            });
+        }
+    }
+    /**
+     * 获取偏好统计
+     */
+    async getPreferenceStats(params) {
+        const endpoint = '/preferences/stats';
+        try {
+            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.get(`${this.baseUrl}${endpoint}`, {
+                params,
+                headers: this.getAuthHeaders(),
+                timeout: 30000,
+            }));
+            return response.data;
+        }
+        catch (error) {
+            this.handleError('getPreferenceStats', error, {
+                userId: params.user_id,
+            });
+        }
+    }
+    // ============================================================================
+    // SSE Monitoring
+    // ============================================================================
+    /**
+     * 使用 SSE 监控任务进度
+     * @param taskId 任务ID
+     * @returns Promise that resolves when task completes
+     */
+    async monitorTaskWithSSE(taskId) {
+        return new Promise((resolve, reject) => {
+            let eventSource = null;
+            // 清理函数，确保连接被正确关闭
+            const cleanup = () => {
+                if (eventSource) {
+                    eventSource.close();
+                    eventSource = null;
+                    this.logger.info('SSE connection closed');
+                }
+            };
+            try {
+                const { EventSource } = require('eventsource');
+                eventSource = new EventSource(`${this.baseUrl}/task/${taskId}/sse`);
+                eventSource.onmessage = (event) => {
+                    try {
+                        const data = JSON.parse(event.data);
+                        const progress = data.progress ?? 0;
+                        const currentStep = data.current_step ?? 'Processing';
+                        this.logger.debug(`Task progress: ${progress}% - ${currentStep}`);
+                        if (data.ready) {
+                            cleanup();
+                            if (data.state === 'SUCCESS') {
+                                this.logger.info(`Task ${taskId} completed successfully`);
+                                resolve(data);
+                            }
+                            else {
+                                this.logger.error(`Task ${taskId} failed: ${data.error}`);
+                                reject(new Error(data.error || 'Task failed'));
+                            }
+                        }
+                    }
+                    catch (error) {
+                        this.logger.error('Failed to parse SSE data', error);
+                        cleanup();
+                        reject(new Error('Failed to parse SSE data'));
+                    }
+                };
+                eventSource.onerror = (error) => {
+                    cleanup();
+                    this.logger.warn('SSE connection error, falling back to polling');
+                    // Fallback to polling
+                    this.pollTaskStatus(taskId).then(resolve).catch(reject);
+                };
+                eventSource.onopen = () => {
+                    this.logger.info(`SSE connection established for ${taskId}`);
+                };
+            }
+            catch (error) {
+                this.logger.warn('SSE not available, using polling mode');
+                this.pollTaskStatus(taskId).then(resolve).catch(reject);
+            }
+        });
+    }
+    /**
+     * 轮询任务状态（SSE 失败时的降级方案）
+     */
+    async pollTaskStatus(taskId, timeout = 300000, checkInterval = 3000) {
+        this.logger.info(`Polling task status: ${taskId}`);
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            const result = await this.getTaskStatus(taskId);
+            const state = result.state ?? 'UNKNOWN';
+            const progress = result.progress ?? 0;
+            const currentStep = result.current_step ?? 'Processing';
+            this.logger.debug(`Task progress: ${progress}% - ${currentStep} - ${state}`);
+            if (result.ready) {
+                if (state === 'SUCCESS') {
+                    this.logger.info(`Task ${taskId} completed successfully`);
+                    return result;
+                }
+                else {
+                    const errorMsg = result.error ?? 'Task failed';
+                    throw new Error(`Task failed: ${errorMsg}`);
+                }
+            }
+            await this.sleep(checkInterval);
+        }
+        throw new Error(`Task timeout: ${taskId}`);
+    }
+    /**
+     * 睡眠函数
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+};
+exports.AgentXClient = AgentXClient;
+exports.AgentXClient = AgentXClient = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(nest_winston_1.WINSTON_MODULE_PROVIDER)),
+    __metadata("design:paramtypes", [winston_1.Logger,
+        axios_1.HttpService,
+        config_1.ConfigService])
+], AgentXClient);
+//# sourceMappingURL=agentx-client.service.js.map