@myassis/gateway 1.0.0

package/dist/services/session/Session.js

@@ -0,0 +1,733 @@
+import { v4 as uuidv4 } from 'uuid';
+import { getLogger } from '@pocketclaw/shared';
+import { SessionStore } from './SessionStore';
+import { AgentStore } from '@/services/agent/AgentStore';
+import { toModel } from '@/services/models';
+import { executeTool, getToolDefinitions } from '@/services/tools';
+import { getSystemPromptAsync } from '../systemPrompt';
+import { LLMClient, parseAruments } from '../llm/LLMClient';
+import { modelsService, settingsService } from '@/services/dataService';
+import { MemoryManager } from '../memory/MemoryManager';
+import { sessionManager } from './SessionManager';
+import { appConfig } from '@/config';
+const logger = getLogger('Session');
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+// AgentStore 单例 - 需要通过 SessionStore 获取数据库实例
+let agentStoreInstance = null;
+function getAgentStore() {
+    if (!agentStoreInstance) {
+        // SessionStore 会在创建时注册到全局
+        const sessionStore = global.__sessionStore;
+        if (!sessionStore) {
+            throw new Error('SessionStore not initialized');
+        }
+        agentStoreInstance = new AgentStore(sessionStore.getDb());
+    }
+    return agentStoreInstance;
+}
+/**
+ * Session - session entity
+ */
+export class Session {
+    id;
+    userId;
+    agentId;
+    title;
+    selectModelId;
+    messages;
+    voiceState;
+    createdAt;
+    updatedAt;
+    lastMessageSummary = null;
+    lastMessageSummaryAt = null;
+    isCurrent;
+    // 用于停止生成
+    isGenerating = false;
+    unreadCount = 0;
+    currentMessageId = null;
+    abortController = null;
+    toolCalls;
+    toInsertMessages;
+    constructor(data) {
+        this.id = data.id;
+        this.userId = data.userId;
+        this.agentId = data.agentId;
+        this.title = data.title || 'New Chat';
+        this.selectModelId = data.selectModelId;
+        this.messages = [];
+        this.voiceState = data.voiceState || { isRecording: false, isPlaying: false };
+        this.lastMessageSummary = data.lastMessageSummary ?? null;
+        this.lastMessageSummaryAt = data.lastMessageSummaryAt ?? null;
+        this.unreadCount = data.unreadCount || 0;
+        this.isCurrent = data.isCurrent ?? false;
+        this.createdAt = data.createdAt || Date.now();
+        this.updatedAt = data.updatedAt || Date.now();
+        this.store = new SessionStore();
+        this.toInsertMessages = [];
+    }
+    store;
+    /**
+     * Get conversation count
+     */
+    getConversationCount() {
+        return this.messages.filter((m) => m.role === 'user' || m.role === 'assistant').length;
+    }
+    // ========== Persistence ==========
+    /**
+     * Save session
+     */
+    save() {
+        const store = this.store;
+        const storeData = this.toStoreData();
+        store.transaction(() => {
+            const exists = store.findSessionById(this.id);
+            if (exists) {
+                store.updateSession(storeData);
+            }
+            else {
+                store.insertSession(storeData);
+            }
+        });
+    }
+    /**
+     * Load messages
+     */
+    loadMessages() {
+        const store = this.store;
+        this.messages = store.findMessagesBySessionId(this.id);
+    }
+    /**
+     * Get context length
+     */
+    getContextLength() {
+        return this.messages.reduce((total, msg) => total + msg.content.length, 0);
+    }
+    // ========== Message Operations ==========
+    /**
+     * Add user message
+     */
+    addUserMessage(content, userMessageId, attachments) {
+        // 将附件统一为 Attachment 对象格式
+        const normalizedAttachments = (attachments || []).map((att) => {
+            if (typeof att === 'string') {
+                // URL 字符串格式，转换为对象
+                const url = att;
+                const name = url.split('/').pop() || 'attachment';
+                const ext = name.split('.').pop()?.toLowerCase() || '';
+                const imageExts = ['jpg', 'jpeg', 'png', 'gif', 'webp', 'bmp', 'svg'];
+                const videoExts = ['mp4', 'avi', 'mov', 'mkv', 'webm'];
+                const audioExts = ['mp3', 'wav', 'ogg', 'flac', 'aac'];
+                let type = 'file';
+                if (imageExts.includes(ext))
+                    type = 'image';
+                else if (videoExts.includes(ext))
+                    type = 'video';
+                else if (audioExts.includes(ext))
+                    type = 'audio';
+                return { type, name, url };
+            }
+            // 已经是对象格式，确保有必要字段
+            return {
+                type: att.type || 'file',
+                name: att.name || 'attachment',
+                url: att.url || att.uri || '',
+                size: att.size,
+                mimeType: att.mimeType,
+            };
+        });
+        const message = {
+            sessionId: this.id,
+            id: userMessageId,
+            role: 'user',
+            content,
+            attachments: normalizedAttachments,
+            status: 'completed',
+            createdAt: Date.now(),
+            modelName: ''
+        };
+        this.messages.push(message);
+        this.toInsertMessages.push(message);
+        return message;
+    }
+    /**
+     * Add assistant message
+     */
+    addAssistantMessage(content, toolCalls, modelName, id) {
+        const message = {
+            sessionId: this.id,
+            id: id ? id : uuidv4(),
+            role: 'assistant',
+            content,
+            toolCalls,
+            createdAt: Date.now(),
+            modelName
+        };
+        this.messages.push(message);
+        this.toInsertMessages.push(message);
+        return message;
+    }
+    /**
+     * Save a single message to store
+     */
+    async saveMessage() {
+        const store = this.store;
+        this.updatedAt = Date.now();
+        try {
+            store.transaction(() => {
+                for (let message of this.toInsertMessages) {
+                    store.insertMessage(this.id, message);
+                }
+                this.toInsertMessages = [];
+                store.updateSession(this.toStoreData());
+            });
+        }
+        catch (error) {
+            logger.error('数据保存错误：', error);
+        }
+    }
+    /**
+     * Update message content
+     */
+    updateMessage(messageId, content, status) {
+        const message = this.messages.find(m => m.id === messageId);
+        if (!message)
+            return;
+        const store = this.store;
+        store.transaction(() => {
+            message.content = content;
+            if (status)
+                message.status = status;
+            this.updatedAt = Date.now();
+            store.updateMessage(this.id, message);
+            store.updateSession(this.toStoreData());
+        });
+    }
+    /**
+     * Delete message
+     */
+    deleteMessage(messageId) {
+        const index = this.messages.findIndex(m => m.id === messageId);
+        if (index === -1)
+            return false;
+        const store = this.store;
+        store.transaction(() => {
+            this.messages.splice(index, 1);
+            this.updatedAt = Date.now();
+            store.deleteMessage(messageId);
+            store.updateSession(this.toStoreData());
+        });
+        return true;
+    }
+    /**
+     * Clear messages
+     */
+    clearMessages() {
+        const store = this.store;
+        store.transaction(() => {
+            this.messages = [];
+            this.updatedAt = Date.now();
+            store.deleteMessagesBySessionId(this.id);
+            store.updateSession(this.toStoreData());
+        });
+    }
+    /**
+     * Update message status
+     */
+    updateMessageStatus(messageId, status) {
+        const message = this.messages.find(m => m.id === messageId);
+        if (!message)
+            return;
+        const store = this.store;
+        store.transaction(() => {
+            message.status = status;
+            this.updatedAt = Date.now();
+            store.updateMessage(this.id, message);
+            store.updateSession(this.toStoreData());
+        });
+    }
+    /**
+     * Update message feedback
+     */
+    updateMessageFeedback(messageId, feedback) {
+        const message = this.messages.find(m => m.id === messageId);
+        if (!message)
+            return;
+        const store = this.store;
+        store.transaction(() => {
+            message.feedback = feedback;
+            this.updatedAt = Date.now();
+            store.updateMessage(this.id, message);
+            store.updateSession(this.toStoreData());
+        });
+    }
+    /**
+     * Get messages
+     */
+    getMessages() {
+        return this.messages;
+    }
+    /**
+     * Get message count
+     */
+    getMessageCount() {
+        return this.messages.length;
+    }
+    /**
+     * Get messages by page (descending order)
+     */
+    getMessagesByPage(page = 1, pageSize = 20) {
+        const sortedMessages = [...this.messages].sort((a, b) => b.createdAt - a.createdAt);
+        const total = sortedMessages.length;
+        const totalPages = Math.ceil(total / pageSize);
+        const startIndex = (page - 1) * pageSize;
+        const endIndex = startIndex + pageSize;
+        const messages = sortedMessages.slice(startIndex, endIndex);
+        return {
+            messages,
+            total,
+            page,
+            pageSize,
+            totalPages,
+            hasMore: page < totalPages,
+        };
+    }
+    // ========== Voice Operations ==========
+    getVoiceState() {
+        return this.voiceState;
+    }
+    updateVoiceState(state) {
+        this.voiceState = { ...this.voiceState, ...state };
+        this.updatedAt = Date.now();
+        this.save();
+    }
+    toggleVoiceRecording() {
+        this.voiceState.isRecording = !this.voiceState.isRecording;
+        if (this.voiceState.isRecording) {
+            this.voiceState.isPlaying = false;
+        }
+        this.updatedAt = Date.now();
+        this.save();
+        return this.voiceState.isRecording;
+    }
+    // ========== Export/Import ==========
+    getSummary() {
+        return {
+            title: this.title,
+            lastMessage: this.lastMessageSummary,
+            lastMessageAt: this.lastMessageSummaryAt,
+        };
+    }
+    exportData() {
+        return {
+            session: {
+                id: this.id,
+                userId: this.userId,
+                agentId: this.agentId,
+                title: this.title,
+                selectModelId: this.selectModelId,
+                voiceState: this.voiceState,
+                createdAt: this.createdAt,
+                updatedAt: this.updatedAt,
+                unreadCount: this.unreadCount,
+                isCurrent: this.isCurrent
+            },
+            messages: this.messages,
+        };
+    }
+    // 未读消息数 +1 并持久化
+    incrementUnreadCount() {
+        this.unreadCount++;
+        this.save();
+    }
+    // 清除未读消息数并持久化
+    clearUnreadCount() {
+        this.unreadCount = 0;
+        this.save();
+    }
+    toStoreData() {
+        return {
+            id: this.id,
+            userId: this.userId,
+            agentId: this.agentId,
+            title: this.title,
+            selectModelId: this.selectModelId || '',
+            voiceState: this.voiceState,
+            createdAt: this.createdAt,
+            updatedAt: this.updatedAt,
+            lastMessageSummary: this.lastMessageSummary,
+            lastMessageSummaryAt: this.lastMessageSummaryAt,
+            unreadCount: this.unreadCount,
+            isCurrent: this.isCurrent
+        };
+    }
+    getStreamDelay(streamSpeed) {
+        if (streamSpeed === 'fast') {
+            return 50;
+        }
+        if (streamSpeed === 'normal') {
+            return 100;
+        }
+        if (streamSpeed === 'slow') {
+            return 200;
+        }
+    }
+    /**
+     * Stream chat response (SSE) - 使用 ModelSelector 根据选择的模型调用
+     * 支持工具调用流程
+     */
+    async streamChat(content, attachments = [], res, userMessageId, assistantMessageId) {
+        // Add user message
+        this.getAbortController();
+        this.isGenerating = true;
+        this.toolCalls = [];
+        const settings = await settingsService.get();
+        const streamDelay = this.getStreamDelay(settings.streamSpeed);
+        this.currentMessageId = assistantMessageId;
+        const memoryManager = new MemoryManager(this, this.abortController.signal);
+        const historyMessages = await memoryManager.getHistoryMessagesAsync();
+        // SSE 辅助方法：res 为 null 时跳过写入（本地执行模式）
+        const sendSSE = (res, data) => {
+            if (!res)
+                return;
+            res.write(`data: ${JSON.stringify(data)}\n\n`);
+            res.flush?.();
+        };
+        // Send message start event
+        sendSSE(res, { type: 'message_start' });
+        // Build messages for API call (保留 tool_call_id 等必要字段)
+        let messages = historyMessages.map(m => {
+            const msg = {
+                role: m.role,
+                content: m.content,
+                attachments: m.attachments,
+                toolCalls: m.toolCalls
+            };
+            // 恢复 reasoning_content
+            if (m.reasoning_content) {
+                msg.reasoning_content = m.reasoning_content;
+            }
+            // 恢复 tool_calls（assistant 消息）
+            if (m.role === 'assistant' && m.tool_calls && m.tool_calls.length > 0) {
+                msg.tool_calls = m.tool_calls;
+            }
+            // 恢复 tool_call_id（tool 消息）
+            if (m.role === 'tool' && m.tool_call_id) {
+                msg.tool_call_id = m.tool_call_id;
+            }
+            return msg;
+        });
+        // 从 Agent 获取系统提示词
+        let systemPrompt = '';
+        let agent = null;
+        if (this.agentId) {
+            agent = getAgentStore().findById(this.agentId);
+            if (agent?.systemPrompt) {
+                systemPrompt = agent.systemPrompt;
+            }
+        }
+        systemPrompt = await getSystemPromptAsync(agent, systemPrompt);
+        if (messages.some(x => x.role === 'system')) {
+            messages = messages.map(m => m.role == 'system' ? { ...m, content: systemPrompt + '\n以下为之前对话内容摘要：\n' + m.content } : m);
+        }
+        else {
+            messages.unshift({ role: 'system', content: systemPrompt, attachments: [] });
+        }
+        //插入用户消息
+        this.addUserMessage(content, userMessageId, attachments);
+        messages.push(this.messages.at(-1));
+        let toolCall = null;
+        let modelNames = [];
+        //用于后续的消息滑动处理
+        const messagesLength = messages.length;
+        const keep = appConfig.messageKeep;
+        //具体调用逻辑函数
+        // 辅助函数：截断消息内容
+        const truncateMessageContent = (message) => {
+            if (message.content && message.content.length > 100) {
+                message.content = message.content.substring(0, 100) + '...(内容过长已截断)';
+            }
+            if (message.reasoning_content && message.reasoning_content.length > 100) {
+                message.reasoning_content = message.reasoning_content.substring(0, 100) + '...(内容过长已截断)';
+            }
+        };
+        // 递归处理函数（支持多轮工具调用）
+        const processModelResponse = async () => {
+            if (!this.abortController || !this.abortController.signal || this.abortController.signal.aborted) {
+                throw Error('aborted');
+            }
+            // 工具调用轮次过多时，成对删除最早的 assistant(tool_calls) + tool(result)
+            // 只保留最近 keep 轮工具调用，防止上下文过长导致模型混乱
+            // 清理旧工具调用：只保留最近 keep 轮的完整上下文
+            {
+                const MAX_TOOL_PAIRS = keep;
+                const allToolCallItems = this.toolCalls.flatMap(x => x.toolCalls);
+                // 1) 清理 this.toolCalls 中超出 keep 的 output（供前端展示用）
+                allToolCallItems.forEach((item, index) => {
+                    if (index < allToolCallItems.length - MAX_TOOL_PAIRS) {
+                        item.output = null;
+                    }
+                });
+                // 2) 从 messages 中成对删除最早的 assistant(tool_calls) + tool(result)
+                let toolPairCount = 0;
+                for (let i = messagesLength; i < messages.length; i++) {
+                    if (messages[i].role === 'assistant' && messages[i].tool_calls) {
+                        toolPairCount++;
+                    }
+                }
+                if (toolPairCount > MAX_TOOL_PAIRS) {
+                    let toRemove = toolPairCount - MAX_TOOL_PAIRS;
+                    // 找到需要截断的工具调用对
+                    for (let i = messagesLength; i < messages.length && toRemove > 0; i++) {
+                        if (messages[i].role === 'assistant' && messages[i].tool_calls) {
+                            // 截断 assistant 消息内容
+                            truncateMessageContent(messages[i]);
+                            while (true) {
+                                // 检查并截断对应的 tool 消息
+                                if (i + 1 < messages.length && messages[i + 1].role === 'tool') {
+                                    truncateMessageContent(messages[i + 1]);
+                                }
+                                else {
+                                    break;
+                                }
+                                i++;
+                            }
+                            toRemove--;
+                        }
+                    }
+                }
+            }
+            // 获取本地工具定义
+            const tools = getToolDefinitions();
+            const models = (await modelsService.list()).data.map(x => toModel(x));
+            // 使用 LLMClient 进行流式调用
+            if (!this.abortController || !this.abortController.signal || this.abortController.signal.aborted) {
+                throw Error('aborted');
+            }
+            const llmClient = new LLMClient(models, messages, this.abortController.signal, tools);
+            llmClient.setPreferredModel(this.selectModelId);
+            // 使用 streamChat 调用模型
+            const llmResult = await llmClient.Chat();
+            // 验证 LLM 结果
+            if (!llmResult || !llmResult.modelName) {
+                throw new Error('Invalid LLM result: missing modelName');
+            }
+            const modelName = llmResult.modelName;
+            modelNames.push(modelName);
+            // ========== 处理工具调用 ==========
+            if (llmResult.toolCalls && llmResult.toolCalls.length > 0) {
+                messages.push({
+                    role: 'assistant',
+                    content: llmResult.content,
+                    reasoning_content: llmResult.reasoningContent,
+                    tool_calls: llmResult.toolCalls
+                });
+                const content = llmResult.content || llmResult.reasoningContent;
+                if (content || toolCall == null) {
+                    const toolCallId = uuidv4();
+                    toolCall = {
+                        id: toolCallId,
+                        content: llmResult.content,
+                        reasoningContent: llmResult.reasoningContent,
+                        toolCalls: []
+                    };
+                    sendSSE(res, {
+                        type: 'tool_call_start',
+                        toolCall: {
+                            id: toolCallId,
+                            content: '',
+                            reasoningContent: '',
+                            toolCalls: []
+                        }
+                    });
+                    //   分段发送内容
+                    if (llmResult.content) {
+                        const chunkSize = 1;
+                        for (let i = 0; i < llmResult.content.length; i += chunkSize) {
+                            const chunk = llmResult.content.slice(i, i + chunkSize);
+                            sendSSE(res, {
+                                type: 'tool_call_start_chunk',
+                                id: toolCallId,
+                                chunk
+                            });
+                            await sleep(streamDelay);
+                        }
+                    }
+                    //   分段发送内容
+                    if (llmResult.reasoningContent) {
+                        const chunkSize = 1;
+                        for (let i = 0; i < llmResult.reasoningContent.length; i += chunkSize) {
+                            const chunk = llmResult.reasoningContent.slice(i, i + chunkSize);
+                            sendSSE(res, {
+                                type: 'tool_call_start_reasoning_chunk',
+                                id: toolCallId,
+                                chunk
+                            });
+                            await sleep(streamDelay);
+                        }
+                    }
+                }
+                // 执行工具调用并收集结果
+                const toolResults = [];
+                for (const pendingToolCall of llmResult.toolCalls) {
+                    // 发送工具开始执行事件
+                    const toolStartEvent = {
+                        type: 'tool_call_execute',
+                        id: pendingToolCall.id,
+                        toolName: pendingToolCall.toolName,
+                        actionName: pendingToolCall.actionName,
+                        input: pendingToolCall.input,
+                        toolCallId: toolCall.id,
+                        modelName
+                    };
+                    sendSSE(res, toolStartEvent);
+                    try {
+                        const result = await executeTool(pendingToolCall.toolName, parseAruments(pendingToolCall.input), this.id, this.currentMessageId);
+                        toolResults.push({
+                            id: pendingToolCall.id,
+                            name: pendingToolCall.toolName,
+                            output: result.output || result.errorMessage,
+                            success: result.success,
+                        });
+                        toolCall.toolCalls.push({
+                            id: pendingToolCall.id,
+                            toolName: pendingToolCall.toolName,
+                            input: pendingToolCall.input,
+                            output: result.output || result.errorMessage,
+                            status: result.success ? 'success' : 'error',
+                            actionName: pendingToolCall.actionName
+                        });
+                        const resultEvent = {
+                            type: 'tool_call_result',
+                            id: pendingToolCall.id,
+                            toolName: pendingToolCall.toolName,
+                            actionName: pendingToolCall.actionName,
+                            output: JSON.stringify(result),
+                            status: result.success ? 'success' : 'error',
+                            toolCallId: toolCall.id,
+                            modelName
+                        };
+                        sendSSE(res, resultEvent);
+                    }
+                    catch (error) {
+                        logger.error(`Tool execution error: ${pendingToolCall.toolName} `, error);
+                        const errorMessage = error.message || 'Execution error';
+                        toolResults.push({
+                            id: pendingToolCall.id,
+                            name: pendingToolCall.toolName,
+                            output: errorMessage,
+                            success: false,
+                        });
+                        toolCall.toolCalls.push({
+                            id: pendingToolCall.id,
+                            toolName: pendingToolCall.toolName,
+                            input: pendingToolCall.input,
+                            status: 'error',
+                            output: errorMessage,
+                            actionName: pendingToolCall.actionName
+                        });
+                        // 发送工具执行失败事件
+                        const errorEvent = {
+                            type: 'tool_call_result',
+                            id: pendingToolCall.id,
+                            toolName: pendingToolCall.toolName,
+                            output: errorMessage,
+                            status: 'error',
+                            toolCallId: toolCall.id,
+                            actionName: pendingToolCall.actionName,
+                            modelName
+                        };
+                        sendSSE(res, errorEvent);
+                    }
+                }
+                this.toolCalls.push(toolCall);
+                // 将工具结果添加到消息历史（格式化为 tool 角色的消息）
+                for (const result of toolResults) {
+                    const toolResultMessage = {
+                        sessionId: this.id,
+                        id: `tool_result_${result.id}_${Date.now()}`,
+                        role: 'tool',
+                        content: JSON.stringify({ success: result.success, output: result.output }),
+                        tool_call_id: result.id,
+                        tool_call_name: result.name,
+                        createdAt: Date.now(),
+                        modelName
+                    };
+                    messages.push(toolResultMessage);
+                }
+                // 继续递归处理（带上工具结果继续调用模型）
+                await processModelResponse();
+            }
+            else {
+                // ========== 没有工具调用，保存消息并结束 ==========
+                if (llmResult.content || llmResult.reasoningContent) {
+                    // 分段发送内容，每段约50个字符
+                    const chunkSize = 1;
+                    const content = llmResult.content || llmResult.reasoningContent;
+                    for (let i = 0; i < content.length; i += chunkSize) {
+                        const chunk = content.slice(i, i + chunkSize);
+                        sendSSE(res, {
+                            type: 'content',
+                            data: chunk
+                        });
+                        await sleep(streamDelay);
+                    }
+                }
+                this.addAssistantMessage(llmResult.content || llmResult.reasoningContent, this.toolCalls, [...new Set(modelNames)].join(','), this.currentMessageId);
+                sendSSE(res, { type: 'complete', modelName: [...new Set(modelNames)].join(",") });
+                sendSSE(res, { type: '[DONE]' });
+            }
+        };
+        try {
+            await processModelResponse();
+        }
+        catch (error) {
+            logger.error('stream chat ', error);
+            if (this.toolCalls) {
+                this.addAssistantMessage('', this.toolCalls, [...new Set(modelNames)].join(','), this.currentMessageId);
+            }
+            if (error.message !== 'aborted') {
+                sendSSE(res, { type: 'error', error: error.message });
+            }
+        }
+        finally {
+            this.isGenerating = false;
+            this.abortController = null;
+            if (res) {
+                res.end();
+            }
+            // 非当前查看的 session，助手回复完成后增加未读计数
+            sessionManager.onMessageComplete(this.id);
+            // 只在非 abort 的情况下保存（abort 由 stopGenerating 负责保存）
+            if (this.currentMessageId !== null) {
+                this.saveMessage();
+            }
+        }
+    }
+    /**
+     * 停止当前正在进行的生成
+     */
+    stopGenerating() {
+        this.isGenerating = false;
+        if (this.abortController) {
+            this.abortController.abort();
+            this.abortController = null;
+        }
+        // stopGenerating 负责保存中断的消息，streamChat 的 finally 不再重复保存
+        if (this.currentMessageId) {
+            if (this.toolCalls && this.toolCalls.length > 0) {
+                this.addAssistantMessage('', this.toolCalls, this.currentMessageId);
+            }
+            this.saveMessage();
+            this.currentMessageId = null;
+        }
+    }
+    /**
+     * 获取 AbortController 用于中断请求
+     */
+    getAbortController() {
+        if (!this.abortController) {
+            this.abortController = new AbortController();
+        }
+        return this.abortController;
+    }
+}