@myassis/gateway 1.0.95 → 1.0.97

package/dist/config/index.js

@@ -87,6 +87,12 @@ const defaultServerBaseUrl = resolvedNodeEnv === 'production' ? PROD_SERVER_BASE
 // 环境变量配置
 exports.appConfig = {
     serverBaseUrl: (process.env.SERVER_BASE_URL || defaultServerBaseUrl).replace(/\/+$/, ''),
+    /**
+     * Desktop Web 站点地址。会话结束推送到手机 App 的通知点击后打开该地址。
+     * 可通过 DESKTOP_WEB_URL 覆盖（私有化部署）。
+     */
+    desktopWebUrl: (process.env.DESKTOP_WEB_URL
+        || (resolvedNodeEnv === 'production' ? 'https://web.my-assis.com' : 'http://192.168.1.36:5005')).replace(/\/+$/, ''),
     port: parseInt(process.env.PORT || '3001', 10),
     clientUrl: process.env.CLIENT_URL || 'http://localhost:3000',
     nodeEnv: resolvedNodeEnv,

package/dist/services/SessionNotificationService.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * 会话结束消息通知服务
+ *
+ * Desktop agent 会话结束后，调用 Server 的推送接口向用户手机 App 推送消息。
+ * 点击通知会打开 Desktop Web 站点（由 Server / Gateway 配置决定）。
+ *
+ * 是否真正推送由用户设置 sessionNotificationEnabled 控制（Server 端校验）。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionNotificationService = void 0;
+const index_js_1 = require("../config/index.js");
+const authStore_js_1 = require("../stores/authStore.js");
+const shared_1 = require("@myassis/shared");
+const logger = (0, shared_1.getLogger)('SessionNotificationService');
+class SessionNotificationService {
+    /**
+     * 通知 Server 推送「会话已结束」消息到用户手机 App（fire-and-forget）。
+     */
+    async notifySessionCompleted(userId, payload) {
+        try {
+            const auth = authStore_js_1.authStore.get(userId);
+            const token = auth?.accessToken;
+            if (!token) {
+                logger.debug('未找到用户 accessToken，跳过会话结束推送', { userId });
+                return;
+            }
+            const response = await fetch(`${index_js_1.appConfig.serverBaseUrl}/api/v1/push-tokens/session-completed`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${token}`,
+                },
+                body: JSON.stringify({
+                    title: payload.title,
+                    body: payload.body || '',
+                    sessionId: payload.sessionId,
+                    agentId: payload.agentId,
+                    url: index_js_1.appConfig.desktopWebUrl,
+                }),
+            });
+            if (!response.ok) {
+                const text = await response.text().catch(() => '');
+                logger.warn('会话结束推送接口返回异常', { status: response.status, body: text });
+            }
+        }
+        catch (error) {
+            logger.error('会话结束推送请求失败', { error: error?.message });
+        }
+    }
+}
+exports.sessionNotificationService = new SessionNotificationService();

package/dist/services/session/Session.js

@@ -38,6 +38,7 @@ const MemoryManager_js_1 = require("../memory/MemoryManager.js");
 const index_js_2 = require("../../config/index.js");
 const ContextBuilder_js_1 = require("../memory/ContextBuilder.js");
 const SessionManager_js_1 = require("./SessionManager.js");
+const SessionNotificationService_js_1 = require("../SessionNotificationService.js");
 const logger = (0, shared_1.getLogger)('Session');
 const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 /**
@@ -577,10 +578,14 @@ class Session {
      * 因此当会话已有计划、且连续 roundsSincePlanUpdate 轮工具调用都没有同步进度时，
      * 返回一条提醒文案注入上下文；无需提醒时返回 null。
      */
-    buildPlanReminder(roundsSincePlanUpdate) {
+    buildPlanReminder(roundsSincePlanUpdate, finalizing) {
         // 没有计划或计划已完成，无需提醒
         if (this.plan.length === 0 || this.isPlanCompleted())
             return null;
+        if (finalizing) {
+            // Tools are stripped when finalizing, so skip the reminder instead of telling the model to continue
+            return null;
+        }
         // 允许模型连续做 1 轮工具调用后再要求同步，避免过于频繁地打断
         if (roundsSincePlanUpdate < 2)
             return null;
@@ -928,6 +933,8 @@ class Session {
         let roundsSincePlanUpdate = 0;
         // 计划模式：收尾时提醒模型补完计划的次数，避免反复提醒导致死循环
         let planFinalizeNudges = 0;
+        let pseudoToolCallRetries = 0;
+        let finalizeStatus = 'completed';
         // 当前裁剪级别，遇到上下文超限时逐级加重
         let trimLevel = ContextBuilder_js_1.TrimLevel.OldToolPayload;
         /** 判断错误是否为上下文超限 */
@@ -1070,6 +1077,7 @@ class Session {
                     // 还没入队，插进去会破坏配对，被严格校验的厂商判为非法请求。
                     logger.warn(`工具调用轮次超过上限 ${index_js_2.appConfig.maxToolRounds}，转入收尾`);
                     forceFinalize = true;
+                    finalizeStatus = 'error';
                 }
                 messages.push({
                     role: 'assistant',
@@ -1356,7 +1364,7 @@ class Session {
                 }
                 // 计划模式：模型常常只在开头和结尾调用 updatePlan，中间过程不同步进度。
                 // 这里在已有计划且连续多轮未同步时，主动注入一条提醒，迫使模型推进计划状态。
-                const reminder = this.buildPlanReminder(roundsSincePlanUpdate);
+                const reminder = this.buildPlanReminder(roundsSincePlanUpdate, forceFinalize);
                 if (reminder) {
                     messages.push({
                         role: 'assistant',
@@ -1381,7 +1389,7 @@ class Session {
             else {
                 // ========== 没有工具调用，准备结束本轮 ==========
                 // 计划模式：计划还没收尾时，先提醒模型补完状态（最多提醒一次，避免死循环）
-                if (planFinalizeNudges < 1) {
+                if (!forceFinalize && planFinalizeNudges < 1) {
                     const finalizeReminder = this.buildPlanFinalizeReminder();
                     if (finalizeReminder) {
                         planFinalizeNudges++;
@@ -1398,6 +1406,34 @@ class Session {
                         return await processModelResponse();
                     }
                 }
+                const _rawText = llmResult.content || llmResult.reasoningContent || '';
+                const PSEUDO_TOOL_RE = /<\/?(exec|edit|file|search|fetch|webfetch|screenshot|keyboard|mouse|skill|task|model|sessionsspawn|setsessiontitle|updateplan|tool|tool_call|function)\b|exec\s+command=|\btoolname\b/i;
+                if (_rawText && PSEUDO_TOOL_RE.test(_rawText)) {
+                    if (forceFinalize === false && pseudoToolCallRetries < 1) {
+                        pseudoToolCallRetries = 1;
+                        messages.push({
+                            role: 'user',
+                            content: 'Your previous reply wrote a tool call as text (e.g. an exec tag, exec command=, or a tool_call block). Such text is NOT executed. Call tools only through the function-calling tool_calls field. Never write tool-call tags in prose. If tools are unavailable, reply in plain language about progress and emit no tool-call tags. Retry using the correct format.',
+                            attachments: []
+                        });
+                        return await processModelResponse();
+                    }
+                    const _m = _rawText.match(PSEUDO_TOOL_RE);
+                    const _idx = _m && _m.index ? _m.index : 0;
+                    let _cleaned = _m ? _rawText.slice(0, _idx) : _rawText;
+                    _cleaned = _cleaned.trimEnd();
+                    if (!_cleaned.trim()) {
+                        _cleaned = '[Reached the tool-call limit for this turn. Partial progress is shown above; please continue remaining steps in a new message.]';
+                    }
+                    else {
+                        _cleaned = _cleaned + '\n\n[Reached the tool-call limit; partial progress above. Continue remaining steps in a new message.]';
+                    }
+                    finalizeStatus = 'error';
+                    if (llmResult.content)
+                        llmResult.content = _cleaned;
+                    else
+                        llmResult.reasoningContent = _cleaned;
+                }
                 if (llmResult.content || llmResult.reasoningContent) {
                     // 分段发送内容，每段约50个字符
                     const chunkSize = 1;
@@ -1412,18 +1448,21 @@ class Session {
                     }
                 }
                 if (!childAgent) {
-                    this.addAssistantMessage(llmResult.content || llmResult.reasoningContent, toolCalls, [...new Set(modelNames)].join(','), this.currentMessageId);
+                    const assistantMessage = this.addAssistantMessage(llmResult.content || llmResult.reasoningContent, toolCalls, [...new Set(modelNames)].join(','), this.currentMessageId);
+                    assistantMessage.status = finalizeStatus;
                     // 正文已完整产出，先落库再发 complete：
                     // 客户端收到 complete 后就认为这条消息定稿了，此时库里必须已经有它。
                     await this.saveMessage();
                 }
-                sendSSE(res, { type: 'complete', modelName: [...new Set(modelNames)].join(",") });
+                sendSSE(res, { type: 'complete', modelName: [...new Set(modelNames)].join(","), status: finalizeStatus });
                 sendSSE(res, { type: '[DONE]' });
                 return llmResult.content;
             }
         };
+        let completedContent;
         try {
             const result = await processModelResponse();
+            completedContent = result;
             return { success: true, data: result };
         }
         catch (error) {
@@ -1432,7 +1471,8 @@ class Session {
                 if (toolCalls) {
                     // 用 '' 覆盖会把已经增量保存的正文清空，这里保留已有内容
                     const saved = this.messages.find(m => m.id === this.currentMessageId && m.role === 'assistant');
-                    this.addAssistantMessage(saved?.content || '', toolCalls, [...new Set(modelNames)].join(','), this.currentMessageId);
+                    const assistantMessage = this.addAssistantMessage(saved?.content || '', toolCalls, [...new Set(modelNames)].join(','), this.currentMessageId);
+                    assistantMessage.status = 'error';
                 }
                 if (error.message !== 'aborted') {
                     try {
@@ -1470,6 +1510,10 @@ class Session {
                 // 后台预压缩：本轮已结束，提前生成摘要让下一轮直接命中，降低首字延迟。
                 // 延迟启动是为了给用户的连续追问让路（追问会取消它）。
                 this.schedulePrecompression();
+                // 会话正常结束：按用户设置推送消息到手机 App
+                if (completedContent !== undefined) {
+                    void this.sendSessionCompletedNotification(completedContent);
+                }
             }
         }
     }
@@ -1558,6 +1602,34 @@ class Session {
             logger.error('推送会话停止事件失败:', error);
         }
     }
+    /**
+     * 会话正常结束后，推送消息通知到用户手机 App。
+     * 具体是否推送由 Server 根据用户设置 sessionNotificationEnabled 决定。
+     */
+    sendSessionCompletedNotification(content) {
+        try {
+            let title = this.title;
+            if (this.agentId) {
+                const agent = getAgentStore().findById(this.agentId);
+                if (agent?.name)
+                    title = agent.name;
+            }
+            const snippet = (content || '')
+                .replace(/[\r\n]+/g, ' ')
+                .replace(/[#*`>\[\]]/g, '')
+                .trim()
+                .slice(0, 80);
+            void SessionNotificationService_js_1.sessionNotificationService.notifySessionCompleted(String(this.userId), {
+                title,
+                body: snippet,
+                sessionId: this.id,
+                agentId: this.agentId,
+            });
+        }
+        catch (error) {
+            logger.error('发送会话结束通知失败:', error);
+        }
+    }
     /**
      * 获取 AbortController 用于中断请求
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myassis/gateway",
-  "version": "1.0.95",
+  "version": "1.0.97",
   "description": "我的助手 Gateway Service - 本地 AI 网关服务，支持认证、WebSocket 实时通信和任务调度",
   "main": "dist/index.js",
   "bin": {