@cicctencent/agent-midway 0.1.1

package/dist/service/agent-task-queue.service.d.ts

@@ -0,0 +1,98 @@
+import { AgentServerService, AgentRunEvent, AgentRunOptions } from './agent-server.service';
+/**
+ * 任务状态
+ */
+export type TaskStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+/**
+ * 任务信息
+ */
+export interface AgentTask {
+    taskId: string;
+    status: TaskStatus;
+    userId: string;
+    threadId?: number;
+    profileId?: number;
+    prompt: string;
+    options?: AgentRunOptions;
+    createdAt: number;
+    startedAt?: number;
+    completedAt?: number;
+    result?: any;
+    error?: string;
+    events: AgentRunEvent[];
+}
+/**
+ * Agent 任务队列服务
+ *
+ * 管理并发 Agent 任务执行：
+ * - 限制同时运行的任务数量
+ * - 支持任务取消
+ * - 支持事件流订阅
+ */
+export declare class AgentTaskQueueService {
+    /** 最大并发数 */
+    private maxConcurrency;
+    /** 任务存储 */
+    private tasks;
+    /** 运行中的任务数量 */
+    private runningCount;
+    /** 任务订阅者 */
+    private subscribers;
+    /** 清理定时器 */
+    private cleanupTimer?;
+    /** 任务 TTL（毫秒） */
+    private taskTTL;
+    init(): Promise<void>;
+    destroy(): Promise<void>;
+    /**
+     * 提交任务
+     */
+    submit(agentServer: AgentServerService, prompt: string, userId: string, options?: AgentRunOptions): Promise<string>;
+    /**
+     * 尝试执行下一个任务
+     */
+    private tryExecuteNext;
+    /**
+     * 执行任务
+     */
+    private executeTask;
+    /**
+     * 订阅任务事件
+     */
+    subscribe(taskId: string, callback: (event: AgentRunEvent) => void): () => void;
+    /**
+     * 通知订阅者
+     */
+    private notifySubscribers;
+    /**
+     * 获取任务状态
+     */
+    getTask(taskId: string): AgentTask | undefined;
+    /**
+     * 获取用户的所有任务
+     */
+    getUserTasks(userId: string): AgentTask[];
+    /**
+     * 取消任务
+     */
+    cancelTask(taskId: string): boolean;
+    /**
+     * 获取队列状态
+     */
+    getStatus(): {
+        total: number;
+        pending: number;
+        running: number;
+        completed: number;
+        failed: number;
+        maxConcurrency: number;
+    };
+    /**
+     * 清理过期任务
+     */
+    private cleanupOldTasks;
+    /**
+     * 等待任务完成
+     */
+    waitForCompletion(taskId: string, timeout?: number): Promise<AgentTask>;
+}

package/dist/service/agent-task-queue.service.js

@@ -0,0 +1,283 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentTaskQueueService = void 0;
+const core_1 = require("@midwayjs/core");
+/**
+ * Agent 任务队列服务
+ *
+ * 管理并发 Agent 任务执行：
+ * - 限制同时运行的任务数量
+ * - 支持任务取消
+ * - 支持事件流订阅
+ */
+let AgentTaskQueueService = class AgentTaskQueueService {
+    constructor() {
+        /** 最大并发数 */
+        this.maxConcurrency = 5;
+        /** 任务存储 */
+        this.tasks = new Map();
+        /** 运行中的任务数量 */
+        this.runningCount = 0;
+        /** 任务订阅者 */
+        this.subscribers = new Map();
+        /** 任务 TTL（毫秒） */
+        this.taskTTL = 30 * 60 * 1000;
+    }
+    async init() {
+        // 启动清理定时器
+        this.cleanupTimer = setInterval(() => {
+            this.cleanupOldTasks();
+        }, 5 * 60 * 1000);
+        console.log(`[AgentTaskQueueService] 初始化完成，最大并发: ${this.maxConcurrency}`);
+    }
+    async destroy() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+        }
+        // 取消所有运行中的任务
+        for (const [_taskId, task] of this.tasks) {
+            if (task.status === 'running') {
+                task.status = 'cancelled';
+            }
+        }
+        console.log('[AgentTaskQueueService] 已销毁');
+    }
+    /**
+     * 提交任务
+     */
+    async submit(agentServer, prompt, userId, options) {
+        const taskId = `task_${Date.now()}_${Math.random()
+            .toString(36)
+            .substr(2, 9)}`;
+        const task = {
+            taskId,
+            status: 'pending',
+            userId,
+            threadId: options?.threadId ? Number(options.threadId) : undefined,
+            profileId: options?.profileId ? Number(options.profileId) : undefined,
+            prompt,
+            options,
+            createdAt: Date.now(),
+            events: [],
+        };
+        this.tasks.set(taskId, task);
+        // 尝试执行
+        this.tryExecuteNext(agentServer);
+        return taskId;
+    }
+    /**
+     * 尝试执行下一个任务
+     */
+    async tryExecuteNext(agentServer) {
+        if (this.runningCount >= this.maxConcurrency) {
+            return;
+        }
+        // 获取下一个待执行任务
+        const pendingTask = Array.from(this.tasks.values())
+            .filter(t => t.status === 'pending')
+            .sort((a, b) => a.createdAt - b.createdAt)[0];
+        if (!pendingTask) {
+            return;
+        }
+        // 执行任务
+        this.executeTask(agentServer, pendingTask);
+    }
+    /**
+     * 执行任务
+     */
+    async executeTask(agentServer, task) {
+        task.status = 'running';
+        task.startedAt = Date.now();
+        this.runningCount++;
+        try {
+            // 运行 Agent
+            for await (const event of agentServer.runAgentStream(task.prompt, task.options)) {
+                // 记录事件
+                task.events.push(event);
+                // 通知订阅者
+                this.notifySubscribers(task.taskId, event);
+            }
+            // 任务完成
+            task.status = 'completed';
+            task.completedAt = Date.now();
+            const lastEvent = task.events[task.events.length - 1];
+            if (lastEvent?.type === 'done') {
+                task.result = lastEvent.data;
+            }
+        }
+        catch (error) {
+            task.status = 'failed';
+            task.completedAt = Date.now();
+            task.error = error.message;
+            // 发送错误事件
+            const errorEvent = {
+                type: 'error',
+                data: { message: error.message },
+                timestamp: Date.now(),
+            };
+            task.events.push(errorEvent);
+            this.notifySubscribers(task.taskId, errorEvent);
+        }
+        finally {
+            this.runningCount--;
+            // 尝试执行下一个任务
+            this.tryExecuteNext(agentServer);
+        }
+    }
+    /**
+     * 订阅任务事件
+     */
+    subscribe(taskId, callback) {
+        if (!this.subscribers.has(taskId)) {
+            this.subscribers.set(taskId, new Set());
+        }
+        this.subscribers.get(taskId).add(callback);
+        // 返回取消订阅函数
+        return () => {
+            this.subscribers.get(taskId)?.delete(callback);
+        };
+    }
+    /**
+     * 通知订阅者
+     */
+    notifySubscribers(taskId, event) {
+        const subs = this.subscribers.get(taskId);
+        if (subs) {
+            for (const callback of subs) {
+                try {
+                    callback(event);
+                }
+                catch (e) {
+                    console.error('[AgentTaskQueueService] 订阅回调错误:', e);
+                }
+            }
+        }
+    }
+    /**
+     * 获取任务状态
+     */
+    getTask(taskId) {
+        return this.tasks.get(taskId);
+    }
+    /**
+     * 获取用户的所有任务
+     */
+    getUserTasks(userId) {
+        return Array.from(this.tasks.values())
+            .filter(t => t.userId === userId)
+            .sort((a, b) => b.createdAt - a.createdAt);
+    }
+    /**
+     * 取消任务
+     */
+    cancelTask(taskId) {
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return false;
+        if (task.status === 'pending') {
+            task.status = 'cancelled';
+            task.completedAt = Date.now();
+            return true;
+        }
+        // 运行中的任务无法取消（需要 Agent 引擎支持）
+        return false;
+    }
+    /**
+     * 获取队列状态
+     */
+    getStatus() {
+        const tasks = Array.from(this.tasks.values());
+        return {
+            total: tasks.length,
+            pending: tasks.filter(t => t.status === 'pending').length,
+            running: tasks.filter(t => t.status === 'running').length,
+            completed: tasks.filter(t => t.status === 'completed').length,
+            failed: tasks.filter(t => t.status === 'failed').length,
+            maxConcurrency: this.maxConcurrency,
+        };
+    }
+    /**
+     * 清理过期任务
+     */
+    cleanupOldTasks() {
+        const now = Date.now();
+        const toRemove = [];
+        for (const [taskId, task] of this.tasks) {
+            // 保留运行中的任务
+            if (task.status === 'running')
+                continue;
+            // 清理超过 TTL 的任务
+            const age = now - (task.completedAt || task.createdAt);
+            if (age > this.taskTTL) {
+                toRemove.push(taskId);
+            }
+        }
+        for (const taskId of toRemove) {
+            this.tasks.delete(taskId);
+            this.subscribers.delete(taskId);
+        }
+        if (toRemove.length > 0) {
+            console.log(`[AgentTaskQueueService] 清理了 ${toRemove.length} 个过期任务`);
+        }
+    }
+    /**
+     * 等待任务完成
+     */
+    async waitForCompletion(taskId, timeout) {
+        return new Promise((resolve, reject) => {
+            const task = this.tasks.get(taskId);
+            if (!task) {
+                reject(new Error('任务不存在'));
+                return;
+            }
+            // 如果已完成，直接返回
+            if (task.status === 'completed' ||
+                task.status === 'failed' ||
+                task.status === 'cancelled') {
+                resolve(task);
+                return;
+            }
+            // 设置超时
+            const timeoutId = timeout
+                ? setTimeout(() => {
+                    reject(new Error('等待超时'));
+                }, timeout)
+                : undefined;
+            // 订阅事件
+            const unsubscribe = this.subscribe(taskId, event => {
+                if (event.type === 'done' || event.type === 'error') {
+                    if (timeoutId)
+                        clearTimeout(timeoutId);
+                    unsubscribe();
+                    resolve(this.tasks.get(taskId));
+                }
+            });
+        });
+    }
+};
+exports.AgentTaskQueueService = AgentTaskQueueService;
+__decorate([
+    (0, core_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], AgentTaskQueueService.prototype, "init", null);
+__decorate([
+    (0, core_1.Destroy)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], AgentTaskQueueService.prototype, "destroy", null);
+exports.AgentTaskQueueService = AgentTaskQueueService = __decorate([
+    (0, core_1.Provide)(),
+    (0, core_1.Scope)(core_1.ScopeEnum.Singleton)
+], AgentTaskQueueService);

package/dist/service/ai-chat.service.d.ts

@@ -0,0 +1,103 @@
+import { BaseService } from '@cicctencent/midwayjs-base';
+import { DataSource, Repository } from 'typeorm';
+import AIChatWorkspaceEntity from '../model/ai-chat-workspace.entity';
+import AIChatThreadEntity from '../model/ai-chat-thread.entity';
+import AIChatMessageEntity from '../model/ai-chat-message.entity';
+/** 搜索结果 */
+export interface SearchResult {
+    threadId: number;
+    threadTitle: string;
+    messageId: number;
+    role: string;
+    content: string;
+    createTime: Date;
+    snippet: string;
+}
+/** 导出格式 */
+export type ExportFormat = 'markdown' | 'json' | 'text';
+export declare class AIChatService extends BaseService {
+    dataSource: DataSource;
+    private wsRepo?;
+    private thRepo?;
+    private msgRepo?;
+    get workspaceModel(): Repository<AIChatWorkspaceEntity>;
+    get threadModel(): Repository<AIChatThreadEntity>;
+    get messageModel(): Repository<AIChatMessageEntity>;
+    getWorkspaces(userId: string, applicationId: number): Promise<AIChatWorkspaceEntity[]>;
+    getWorkspace(id: number, userId: string, applicationId: number): Promise<AIChatWorkspaceEntity>;
+    createWorkspace(userId: string, applicationId: number, data: Partial<AIChatWorkspaceEntity>): Promise<AIChatWorkspaceEntity>;
+    updateWorkspace(id: number, userId: string, applicationId: number, data: Partial<AIChatWorkspaceEntity>): Promise<AIChatWorkspaceEntity>;
+    deleteWorkspace(id: number, userId: string, applicationId: number): Promise<void>;
+    getThreads(workspaceId: number, userId: string, applicationId: number): Promise<AIChatThreadEntity[]>;
+    getThread(id: number, userId: string, applicationId: number): Promise<AIChatThreadEntity>;
+    createThread(userId: string, applicationId: number, data: {
+        workspaceId: number;
+        title?: string;
+    }): Promise<AIChatThreadEntity>;
+    updateThread(id: number, userId: string, applicationId: number, data: Partial<AIChatThreadEntity>): Promise<AIChatThreadEntity>;
+    deleteThread(id: number, userId: string, applicationId: number): Promise<void>;
+    getMessages(threadId: number, userId: string, applicationId: number, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        items: AIChatMessageEntity[];
+        total: number;
+        hasMore: boolean;
+    }>;
+    addMessage(userId: string, applicationId: number, data: {
+        threadId: number;
+        role: string;
+        content: string;
+        type?: string;
+        meta?: any;
+    }): Promise<AIChatMessageEntity>;
+    updateMessage(id: number, userId: string, applicationId: number, data: {
+        content?: string;
+        meta?: any;
+    }): Promise<AIChatMessageEntity>;
+    deleteMessage(id: number, userId: string, applicationId: number): Promise<void>;
+    clearThreadMessages(threadId: number, userId: string, applicationId: number): Promise<void>;
+    /** 初始化默认工作空间（新用户首次使用时，可由业务层覆盖） */
+    ensureDefaultWorkspaces(userId: string, applicationId: number): Promise<void>;
+    /**
+     * 全局搜索对话消息
+     * @param query 搜索关键词
+     * @param options.workspaceId 限定工作空间
+     * @param options.limit 结果上限
+     */
+    searchMessages(query: string, options?: {
+        workspaceId?: number;
+        limit?: number;
+    }): Promise<SearchResult[]>;
+    /**
+     * 导出对话为指定格式
+     * @param threadId 线程 ID
+     * @param format 导出格式：markdown / json / text
+     * @param userId 用户 ID
+     * @param applicationId 应用 ID
+     */
+    exportThread(threadId: number, format: 'markdown' | 'json' | 'text', userId: string, applicationId: number): Promise<string>;
+    private exportAsMarkdown;
+    private exportAsText;
+    /** 单条工具输出截断长度 */
+    private static readonly MAX_TOOL_OUTPUT_LEN;
+    /** 最终 LLM 消息数硬上限 */
+    private static readonly MAX_RESULT_MESSAGES;
+    /**
+     * 判断 assistant 消息是否应排除出历史（精简 token）
+     */
+    private shouldSkipMessage;
+    /**
+     * 从已持久化的消息记录重建 LLM 格式的对话历史（用于 AgentEngine）
+     *
+     * @param threadId 线程 ID
+     * @param userId 用户 ID
+     * @param applicationId 应用 ID
+     * @param limit 最大 DB 消息数，默认 20
+     * @returns Message[] 格式的对话历史
+     */
+    buildThreadHistory(threadId: number, userId: string, applicationId: number, limit?: number): Promise<Array<{
+        role: string;
+        content: string;
+    }>>;
+}