@myassis/gateway 1.0.75 → 1.0.77

package/dist/config/index.js

@@ -79,6 +79,20 @@ exports.appConfig = {
     clientUrl: process.env.CLIENT_URL || 'http://localhost:3000',
     nodeEnv: process.env.NODE_ENV || defaultEnv,
     messageKeep: 4,
+    /** 摘要后保留的原始历史消息条数 */
+    historyKeep: parseInt(process.env.HISTORY_KEEP || '4', 10),
+    /** 保留完整输出的最近工具调用轮数 */
+    toolPairKeep: parseInt(process.env.TOOL_PAIR_KEEP || '8', 10),
+    /** 极端裁剪时至少保留的工具调用轮数 */
+    minToolPairKeep: 2,
+    /** 单次请求上下文字符预算（LLMClient 硬上限为 200000，此处留出余量） */
+    contextMaxChars: parseInt(process.env.CONTEXT_MAX_CHARS || '180000', 10),
+    /** 超出 toolPairKeep 的旧工具调用内容截断长度 */
+    oldToolContentLimit: parseInt(process.env.OLD_TOOL_CONTENT_LIMIT || '500', 10),
+    /** 单次请求内最大工具调用轮数 */
+    maxToolRounds: parseInt(process.env.MAX_TOOL_ROUNDS || '100', 10),
+    /** 触发上下文压缩的字符阈值 */
+    summaryTriggerChars: parseInt(process.env.SUMMARY_TRIGGER_CHARS || '60000', 10),
     appName: '我的助手'
 };
 exports.default = exports.appConfig;

package/dist/middleware/auth.js

@@ -9,7 +9,7 @@ exports.requireAuth = void 0;
  * 注：Gateway 不自行验证 JWT 签名，而是比对 authStore 中由 Server 下发并本地持久化的 token。
  * 因此无需也不应持有 JWT_SECRET，避免密钥在末端多处散落。
  */
-const authStore_js_1 = require("@/stores/authStore.js");
+const authStore_js_1 = require("../stores/authStore.js");
 const shared_1 = require("@myassis/shared");
 const logger = (0, shared_1.getLogger)('middleware/auth');
 /**

package/dist/routes/agent.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = require("express");
-const auth_js_1 = require("@/middleware/auth.js");
-const index_js_1 = require("@/api/index.js");
-const index_js_2 = require("@/services/session/index.js");
-const AgentManager_js_1 = require("@/services/agent/AgentManager.js");
-const AgentStore_js_1 = require("@/services/agent/AgentStore.js");
+const auth_js_1 = require("../middleware/auth.js");
+const index_js_1 = require("../api/index.js");
+const index_js_2 = require("../services/session/index.js");
+const AgentManager_js_1 = require("../services/agent/AgentManager.js");
+const AgentStore_js_1 = require("../services/agent/AgentStore.js");
 const shared_1 = require("@myassis/shared");
 const logger = (0, shared_1.getLogger)('AgentRoutes');
-const SessionStore_js_1 = require("@/services/session/SessionStore.js");
+const SessionStore_js_1 = require("../services/session/SessionStore.js");
 const router = (0, express_1.Router)();
 // 所有路由需要认证
 router.use(auth_js_1.requireAuth, (req, _res, next) => {

package/dist/routes/upload.js

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteFile = void 0;
 const express_1 = require("express");
 const multer_1 = __importDefault(require("multer"));
-const index_js_1 = require("@/config/index.js");
-const auth_js_1 = require("@/middleware/auth.js");
-const index_js_2 = require("@/api/index.js");
+const index_js_1 = require("../config/index.js");
+const auth_js_1 = require("../middleware/auth.js");
+const index_js_2 = require("../api/index.js");
 const shared_1 = require("@myassis/shared");
 const logger = (0, shared_1.getLogger)('UploadRoutes');
 const router = (0, express_1.Router)();

package/dist/services/TaskSchedulerService.js

@@ -11,7 +11,7 @@ const WebSocketService_js_1 = require("./WebSocketService.js");
 const index_js_1 = require("./session/index.js");
 const shared_1 = require("@myassis/shared");
 const dataService_js_1 = require("./dataService.js");
-const authStore_js_1 = require("@/stores/authStore.js");
+const authStore_js_1 = require("../stores/authStore.js");
 const logger = (0, shared_1.getLogger)('TaskSchedulerService');
 const EXPIRED_THRESHOLD = 60 * 60 * 1000; // 1小时
 const CHECK_INTERVAL = 60 * 1000; // 1分钟

package/dist/services/TaskService.js

@@ -10,7 +10,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.taskService = void 0;
-const index_js_1 = require("@/stores/index.js");
+const index_js_1 = require("../stores/index.js");
 const index_js_2 = require("../api/index.js");
 const LocalTaskService_js_1 = require("./LocalTaskService.js");
 const shared_1 = require("@myassis/shared");

package/dist/services/agent/AgentManager.js

@@ -7,9 +7,9 @@ exports.initAgentManager = exports.agentManagerMap = exports.AgentManager = void
 const uuid_1 = require("uuid");
 const Agent_js_1 = require("./Agent.js");
 const SessionManager_js_1 = require("../session/SessionManager.js");
-const authStore_js_1 = require("@/stores/authStore.js");
+const authStore_js_1 = require("../../stores/authStore.js");
 const shared_1 = require("@myassis/shared");
-const index_js_1 = __importDefault(require("@/config/index.js"));
+const index_js_1 = __importDefault(require("../../config/index.js"));
 const logger = (0, shared_1.getLogger)('AgentManager');
 /**
  * AgentManager - Business logic layer

package/dist/services/llm/LLMClient.js

@@ -4,10 +4,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getGlobalModelSelector = exports.parseAruments = exports.LLMClient = void 0;
-const index_js_1 = require("@/stores/index.js");
+const index_js_1 = require("../../stores/index.js");
 const shared_1 = require("@myassis/shared");
 const promises_1 = __importDefault(require("fs/promises"));
+const index_js_2 = require("../../config/index.js");
 const logger = (0, shared_1.getLogger)('LLMClient');
+/** 历史工具输出在上下文中的最大保留长度 */
+const HISTORY_TOOL_OUTPUT_LIMIT = index_js_2.appConfig.oldToolContentLimit;
+/** 请求体字符硬上限，超过则视为上下文超限 */
+const HARD_MAX_CHARS = 200000; /**
+ * LLM 调用结果类型
+ */
 function convertBase64ToImage(base64Img) {
     // 去掉data:image/xxx;base64,前缀
     const pureBase64 = base64Img.replace(/^data:image\/\w+;base64,/, '');
@@ -185,7 +192,7 @@ class LLMClient {
                         return [{
                                 role: 'tool',
                                 tool_call_id: m.tool_call_id,
-                                content: m.content.substring(0, 100) + '...（内容过长已截断）',
+                                content: m.content.substring(0, HISTORY_TOOL_OUTPUT_LIMIT) + '...（内容过长已截断）',
                             }];
                     }
                 }
@@ -222,28 +229,39 @@ class LLMClient {
                         tool_calls: []
                     };
                     const tools = [];
-                    for (let i = 0; i < toolCall.toolCalls.length; i++) {
+                    for (let i = 0; i < (toolCall.toolCalls || []).length; i++) {
                         const toolCallItem = toolCall.toolCalls[i];
-                        if (toolCallItem.output != null) {
-                            item.tool_calls.push({
-                                id: toolCallItem.id,
-                                function: {
-                                    name: toolCallItem.toolName,
-                                    arguments: toolCallItem.input
-                                },
-                                type: 'function'
-                            });
-                            tools.push({
-                                role: 'tool',
-                                tool_call_id: toolCallItem.id,
-                                content: toolCallItem.output.substring(0, 100) + '...' + '(内容过长已截断)'
-                            });
-                        }
+                        if (!toolCallItem?.id)
+                            continue;
+                        item.tool_calls.push({
+                            id: toolCallItem.id,
+                            function: {
+                                name: toolCallItem.toolName,
+                                arguments: toolCallItem.input
+                            },
+                            type: 'function'
+                        });
+                        // output 为空（历史裁剪/执行中断）时也必须补齐 tool 消息，
+                        // 否则 assistant.tool_calls 缺少配对结果会被 API 拒绝
+                        const rawOutput = toolCallItem.output == null
+                            ? '(历史记录已省略该结果)'
+                            : String(toolCallItem.output);
+                        tools.push({
+                            role: 'tool',
+                            tool_call_id: toolCallItem.id,
+                            content: rawOutput.length > HISTORY_TOOL_OUTPUT_LIMIT
+                                ? rawOutput.substring(0, HISTORY_TOOL_OUTPUT_LIMIT) + '...(内容过长已截断)'
+                                : rawOutput
+                        });
                     }
                     if (item.tool_calls.length > 0) {
                         items.push(item);
                         items = items.concat(tools);
                     }
+                    else if (item.content || item.reasoning_content) {
+                        // 没有可用的工具调用，但思路内容仍有上下文价值，不应整体丢弃
+                        items.push({ role: 'assistant', content: item.content || item.reasoning_content });
+                    }
                 }
                 if (m.content) {
                     items.push({
@@ -358,9 +376,10 @@ class LLMClient {
         if (this.tools && this.tools.length > 0) {
             body.tools = this.tools;
         }
-        const tokens = JSON.stringify(body).length;
-        logger.debug('tokens', tokens);
-        if (tokens > 200000 && !existAttachments && !existScreenShot) {
+        const bodyChars = JSON.stringify(body).length;
+        logger.debug('context chars', bodyChars);
+        // 附件/截图场景 base64 体积大但不可裁剪，跳过硬上限检查
+        if (bodyChars > HARD_MAX_CHARS && !existAttachments && !existScreenShot) {
             throw Error('exceed max message tokens');
         }
         return {
@@ -591,7 +610,6 @@ class LLMClient {
             'insufficient_quota',
             'rate_limit_exceeded',
             'model_not_found',
-            'context_length_exceeded',
             'Model call failed',
             'No API Key',
             'InvalidEndpointOrModel',

package/dist/services/memory/ContextBuilder.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextTrimLevel = exports.buildContext = exports.estimateTokens = exports.estimateChars = exports.TrimLevel = void 0;
+const shared_1 = require("@myassis/shared");
+const index_js_1 = require("../../config/index.js");
+const logger = (0, shared_1.getLogger)('ContextBuilder');
+/**
+ * 上下文构造与分级裁剪
+ *
+ * 统一负责“发给模型的消息数组”的体积控制，避免裁剪逻辑散落在
+ * Session.streamChat 与 LLMClient.mapMessages 两处且互不可见。
+ *
+ * 关键约束：本模块只对 *投影副本* 做裁剪，绝不修改会话持久化数据。
+ */
+/** 中英混合场景下的粗略 token 估算系数 */
+const CHARS_PER_TOKEN = 1.6;
+/** 裁剪级别，逐级加重 */
+var TrimLevel;
+(function (TrimLevel) {
+    /** 不裁剪 */
+    TrimLevel[TrimLevel["None"] = 0] = "None";
+    /** 截断超出 toolPairKeep 的旧工具输出与参数 */
+    TrimLevel[TrimLevel["OldToolPayload"] = 1] = "OldToolPayload";
+    /** 进一步压缩保留轮数，并降级旧附件为占位符 */
+    TrimLevel[TrimLevel["Aggressive"] = 2] = "Aggressive";
+    /** 丢弃最早的完整工具调用对，只留最近 minToolPairKeep 轮 */
+    TrimLevel[TrimLevel["DropOldPairs"] = 3] = "DropOldPairs";
+})(TrimLevel || (exports.TrimLevel = TrimLevel = {}));
+/** 估算单条消息的字符数（含附件与工具参数） */
+function messageChars(message) {
+    if (!message)
+        return 0;
+    let total = 0;
+    if (typeof message.content === 'string') {
+        total += message.content.length;
+    }
+    else if (Array.isArray(message.content)) {
+        total += JSON.stringify(message.content).length;
+    }
+    if (message.reasoning_content)
+        total += String(message.reasoning_content).length;
+    if (Array.isArray(message.tool_calls))
+        total += JSON.stringify(message.tool_calls).length;
+    if (Array.isArray(message.toolCalls))
+        total += JSON.stringify(message.toolCalls).length;
+    if (Array.isArray(message.attachments)) {
+        for (const att of message.attachments) {
+            total += (att?.url?.length || 0) + (att?.name?.length || 0);
+        }
+    }
+    return total;
+}
+/** 估算整个消息数组的字符数 */
+function estimateChars(messages) {
+    return (messages || []).reduce((sum, m) => sum + messageChars(m), 0);
+}
+exports.estimateChars = estimateChars;
+/** 估算 token 数（粗略） */
+function estimateTokens(messages) {
+    return Math.ceil(estimateChars(messages) / CHARS_PER_TOKEN);
+}
+exports.estimateTokens = estimateTokens;
+/** 按上限截断字符串，保留可读提示 */
+function clip(text, limit) {
+    if (typeof text !== 'string' || text.length <= limit)
+        return text;
+    return text.slice(0, limit) + '...(内容过长已截断)';
+}
+/** 浅拷贝一条消息，保证裁剪不影响原对象 */
+function cloneMessage(message) {
+    const copy = { ...message };
+    if (Array.isArray(message.tool_calls)) {
+        copy.tool_calls = message.tool_calls.map((tc) => ({ ...tc }));
+    }
+    if (Array.isArray(message.attachments)) {
+        copy.attachments = message.attachments.map((att) => ({ ...att }));
+    }
+    return copy;
+}
+/** 判断是否为“助手发起工具调用”的消息 */
+function isToolCallAssistant(message) {
+    return message?.role === 'assistant'
+        && Array.isArray(message.tool_calls)
+        && message.tool_calls.length > 0;
+}
+/**
+ * 将消息数组按“工具调用对”切分。
+ *
+ * 一个 pair = 1 条 assistant(tool_calls) + 其后连续的 tool 结果消息。
+ * 返回的 index 区间为左闭右开。
+ */
+function collectToolPairs(messages, from) {
+    const pairs = [];
+    for (let i = from; i < messages.length; i++) {
+        if (!isToolCallAssistant(messages[i]))
+            continue;
+        let end = i + 1;
+        while (end < messages.length && messages[end].role === 'tool') {
+            end++;
+        }
+        pairs.push({ start: i, end });
+        // 直接跳到该 pair 之后，避免遍历中改动循环变量导致漏检
+        i = end - 1;
+    }
+    return pairs;
+}
+/** 截断一个 pair 内的 content / reasoning_content / tool_calls.arguments */
+function clipPair(messages, pair, limit) {
+    const head = messages[pair.start];
+    head.content = clip(head.content, limit);
+    head.reasoning_content = clip(head.reasoning_content, limit);
+    // 工具参数往往是上下文膨胀的主因（写文件 / patch 类调用）
+    if (Array.isArray(head.tool_calls)) {
+        for (const tc of head.tool_calls) {
+            if (typeof tc.input === 'string')
+                tc.input = clip(tc.input, limit);
+            if (tc.function && typeof tc.function.arguments === 'string') {
+                tc.function.arguments = clip(tc.function.arguments, limit);
+            }
+        }
+    }
+    for (let i = pair.start + 1; i < pair.end; i++) {
+        messages[i].content = clip(messages[i].content, limit);
+    }
+}
+/** 将较早的图片 / 音频附件降级为文本占位符，避免 base64 永久占用上下文 */
+function degradeAttachments(messages, keepLastN) {
+    const withAttachments = [];
+    messages.forEach((m, index) => {
+        if (Array.isArray(m.attachments) && m.attachments.length > 0) {
+            withAttachments.push(index);
+        }
+    });
+    const degradeUntil = withAttachments.length - keepLastN;
+    for (let k = 0; k < degradeUntil; k++) {
+        const message = messages[withAttachments[k]];
+        const placeholders = message.attachments
+            .map((att) => `[${att.type || 'file'}: ${att.name || 'attachment'}]`)
+            .join(' ');
+        message.attachments = [];
+        const base = typeof message.content === 'string' ? message.content : '';
+        message.content = placeholders + (base ? `\n${base}` : '');
+    }
+}
+/**
+ * 按预算对上下文做分级裁剪。
+ *
+ * @param messages   完整消息数组（不会被修改）
+ * @param protectFrom 该下标之前的消息视为“历史/摘要”，工具对裁剪只作用于其后
+ * @param maxChars   字符预算
+ * @param minLevel   最低裁剪级别（用于超限重试时强制加重）
+ */
+function buildContext(messages, protectFrom, maxChars = index_js_1.appConfig.contextMaxChars, minLevel = TrimLevel.OldToolPayload) {
+    let working = messages.map(cloneMessage);
+    let level = TrimLevel.None;
+    const overBudget = () => estimateChars(working) > maxChars;
+    const applyLevel = (target) => {
+        level = target;
+        working = messages.map(cloneMessage);
+        const pairs = collectToolPairs(working, protectFrom);
+        const keep = target >= TrimLevel.Aggressive
+            ? index_js_1.appConfig.minToolPairKeep
+            : index_js_1.appConfig.toolPairKeep;
+        // 1) 截断超出 keep 轮的旧工具调用负载
+        const clipUntil = Math.max(0, pairs.length - keep);
+        for (let i = 0; i < clipUntil; i++) {
+            clipPair(working, pairs[i], index_js_1.appConfig.oldToolContentLimit);
+        }
+        // 2) 降级旧附件
+        if (target >= TrimLevel.Aggressive) {
+            degradeAttachments(working, 1);
+        }
+        // 3) 整对丢弃最早的工具调用（保持 assistant/tool 配对完整，避免协议错误）
+        if (target >= TrimLevel.DropOldPairs && pairs.length > index_js_1.appConfig.minToolPairKeep) {
+            const dropCount = pairs.length - index_js_1.appConfig.minToolPairKeep;
+            const dropIndexes = new Set();
+            for (let i = 0; i < dropCount; i++) {
+                for (let j = pairs[i].start; j < pairs[i].end; j++) {
+                    dropIndexes.add(j);
+                }
+            }
+            const dropped = working.filter((_, index) => !dropIndexes.has(index));
+            // 用一条系统提示替代被丢弃的轮次，避免模型认为自己没做过这些事
+            dropped.splice(protectFrom, 0, {
+                role: 'system',
+                content: `（已省略 ${dropCount} 轮较早的工具调用记录以控制上下文长度）`,
+                attachments: [],
+            });
+            working = dropped;
+        }
+    };
+    for (const target of [minLevel, TrimLevel.Aggressive, TrimLevel.DropOldPairs]) {
+        if (target < level)
+            continue;
+        applyLevel(target);
+        if (!overBudget())
+            break;
+    }
+    const chars = estimateChars(working);
+    if (chars > maxChars) {
+        logger.warn(`上下文仍超出预算: ${chars} > ${maxChars}（已用最高裁剪级别 ${level}）`);
+    }
+    return { messages: working, chars, level, trimmed: level > TrimLevel.None };
+}
+exports.buildContext = buildContext;
+/** 依据当前级别推导下一个更重的裁剪级别，用于超限重试 */
+function nextTrimLevel(level) {
+    if (level < TrimLevel.Aggressive)
+        return TrimLevel.Aggressive;
+    if (level < TrimLevel.DropOldPairs)
+        return TrimLevel.DropOldPairs;
+    return null;
+}
+exports.nextTrimLevel = nextTrimLevel;

package/dist/services/memory/MemoryManager.js

@@ -28,11 +28,13 @@ const shared_1 = require("@myassis/shared");
 const logger = (0, shared_1.getLogger)('MemoryManager');
 const models_js_1 = require("../models.js");
 const dataService_js_1 = require("../dataService.js");
-const index_js_1 = require("@/stores/index.js");
+const index_js_1 = require("../../stores/index.js");
 const LLMClient_js_1 = require("../llm/LLMClient.js");
-const index_js_2 = require("@/config/index.js");
+const index_js_2 = require("../../config/index.js");
+const ContextBuilder_js_1 = require("./ContextBuilder.js");
 const DEFAULT_CONFIG = {
     summaryThreshold: 10,
+    summaryTriggerChars: index_js_2.appConfig.summaryTriggerChars,
     enabled: true,
 };
 /** SSE 辅助方法：res 为 null 时跳过写入（本地执行模式） */
@@ -52,6 +54,7 @@ class MemoryManager {
     config = DEFAULT_CONFIG;
     childAgent;
     res;
+    summaryModels = null;
     constructor(session, signal, childAgent, res = null) {
         this.session = session;
         this.signal = signal;
@@ -68,52 +71,86 @@ class MemoryManager {
             modelName,
         };
     }
+    /**
+     * 是否需要触发压缩：消息条数或字符体积任一超阈值
+     */
+    shouldSummarize(messages) {
+        if (!this.config.enabled)
+            return false;
+        if (messages.length >= this.config.summaryThreshold)
+            return true;
+        // 单条工具结果可能极大，条数少也可能远超上下文预算
+        return (0, ContextBuilder_js_1.estimateChars)(messages) >= this.config.summaryTriggerChars;
+    }
+    /**
+     * 取得“最后一条被摘要消息”的时间戳作为摘要边界。
+     *
+     * 不能用 Date.now()：保留窗口内的消息 createdAt 均小于当前时间，
+     * 下一轮按时间过滤时会既不在摘要中、也不在历史中，造成上下文空洞。
+     */
+    boundaryOf(summarized, fallback) {
+        if (!summarized || summarized.length === 0)
+            return fallback;
+        return summarized[summarized.length - 1].createdAt;
+    }
     async getHistoryMessagesAsync() {
-        // 1. 获取所有消息
-        let messages = this.session.getMessages();
+        const keep = index_js_2.appConfig.historyKeep;
+        // 复制数组：getMessages() 返回的是会话内部的活引用，不可原地修改
+        let messages = [...this.session.getMessages()];
         if (this.childAgent) {
-            messages.splice(-1);
+            // 子 agent 的最后一条消息由调用方单独拼接，此处排除
+            messages = messages.slice(0, -1);
+        }
+        if (!this.shouldSummarize(messages)) {
+            return messages;
         }
-        // 2. 消息少于摘要配置的阈值数，直接返回
-        if (messages.length < this.config.summaryThreshold) {
+        if (messages.length <= keep) {
             return messages;
         }
-        // 3. 检查是否有摘要
         const hasSummary = this.session.lastMessageSummary;
         if (!hasSummary) {
-            // 4A. 首次摘要生成
-            const summary = await this.generateSummaryAsync(messages.slice(0, -index_js_2.appConfig.messageKeep), null);
+            // 首次摘要生成
+            const toSummarize = messages.slice(0, -keep);
+            const summary = await this.generateSummaryAsync(toSummarize, null);
+            if (!summary) {
+                // 摘要失败/被中断：退回原始历史，不写入残缺摘要
+                return messages;
+            }
+            const boundary = this.boundaryOf(toSummarize, Date.now());
             this.session.lastMessageSummary = summary;
-            this.session.lastMessageSummaryAt = Date.now();
+            this.session.lastMessageSummaryAt = boundary;
             this.session.save();
             return [
-                this.toSummaryMessage(summary, this.session.lastMessageSummaryAt, ''),
-                ...messages.slice(-index_js_2.appConfig.messageKeep),
+                this.toSummaryMessage(summary, boundary, ''),
+                ...messages.slice(-keep),
             ];
         }
-        else {
-            // 4B. 增量摘要更新
-            const newMessages = messages.filter((m) => m.createdAt > this.session.lastMessageSummaryAt);
-            if (newMessages.length < this.config.summaryThreshold) {
-                // 新消息少于阈值条：返回摘要 + 从摘要时刻起的所有消息
-                const fromSummary = messages.filter((m) => m.createdAt >= this.session.lastMessageSummaryAt);
-                return [
-                    this.toSummaryMessage(this.session.lastMessageSummary, this.session.lastMessageSummaryAt, ''),
-                    ...fromSummary,
-                ];
-            }
-            else {
-                // 新消息超过阈值条，重新生成摘要
-                const summary = await this.generateSummaryAsync(newMessages.slice(0, -index_js_2.appConfig.messageKeep), this.session.lastMessageSummary);
-                this.session.lastMessageSummary = summary;
-                this.session.lastMessageSummaryAt = Date.now();
-                this.session.save();
-                return [
-                    this.toSummaryMessage(summary, this.session.lastMessageSummaryAt, ''),
-                    ...messages.slice(-index_js_2.appConfig.messageKeep),
-                ];
-            }
+        // 增量摘要：边界之后的消息才是“新消息”
+        const boundaryAt = this.session.lastMessageSummaryAt;
+        const newMessages = messages.filter((m) => m.createdAt > boundaryAt);
+        if (!this.shouldSummarize(newMessages) || newMessages.length <= keep) {
+            return [
+                this.toSummaryMessage(this.session.lastMessageSummary, boundaryAt, ''),
+                ...newMessages,
+            ];
         }
+        // 新消息超过阈值，基于旧摘要增量重算
+        const toSummarize = newMessages.slice(0, -keep);
+        const summary = await this.generateSummaryAsync(toSummarize, this.session.lastMessageSummary);
+        if (!summary) {
+            return [
+                this.toSummaryMessage(this.session.lastMessageSummary, boundaryAt, ''),
+                ...newMessages,
+            ];
+        }
+        const nextBoundary = this.boundaryOf(toSummarize, boundaryAt);
+        this.session.lastMessageSummary = summary;
+        this.session.lastMessageSummaryAt = nextBoundary;
+        this.session.save();
+        return [
+            this.toSummaryMessage(summary, nextBoundary, ''),
+            ...newMessages.slice(-keep),
+        ];
     }
     /**
      * 格式化工具调用内容，提取关键信息供摘要模型理解
@@ -182,38 +219,50 @@ class MemoryManager {
             .filter((m) => m.role === 'user' || m.role === 'assistant')
             .map((m) => this.formatMessage(m))
             .join('\n\n');
-        return `你是一个对话摘要专家。请分析以下对话内容，生成一份结构化的摘要。
-
-重要规则：
-1. 如果对话涉及代码开发/项目工作，必须详细总结项目结构，包括：技术栈、目录结构、关键文件及其职责、模块间关系
-2. 项目结构描述不限字数，务必完整清晰
-3. 保留所有关键决策、修改内容和上下文
-4. 保留错误信息和解决方案，避免重复犯错
-5. 如果有上一轮摘要，合并其中的关键信息
-
-${lastSummary ? '=== 上一轮摘要 ===\n' + lastSummary + '\n\n' : ''}=== 对话内容 ===
-${conversation}
-
-=== 输出格式 ===
-请按以下格式输出（各部分字数不限，以完整准确为优先）：
-
-【摘要】简要概括对话主题和关键进展
-
-【项目结构】（如涉及项目开发）详细描述：
-- 技术栈与框架
-- 目录结构与各目录职责
-- 关键文件及其作用
-- 模块间依赖关系
-- 已完成和待完成的功能
-
-【关键决策】列出重要决策及原因
-
-【要点】列出3-8个关键要点
-
+        return `你是一个对话摘要专家。请分析以下对话内容，生成一份结构化的摘要。
+
+重要规则：
+1. 如果对话涉及代码开发/项目工作，必须详细总结项目结构，包括：技术栈、目录结构、关键文件及其职责、模块间关系
+2. 项目结构描述不限字数，务必完整清晰
+3. 保留所有关键决策、修改内容和上下文
+4. 保留错误信息和解决方案，避免重复犯错
+5. 如果有上一轮摘要，合并其中的关键信息
+
+${lastSummary ? '=== 上一轮摘要 ===\n' + lastSummary + '\n\n' : ''}=== 对话内容 ===
+${conversation}
+
+=== 输出格式 ===
+请按以下格式输出（各部分字数不限，以完整准确为优先）：
+
+【摘要】简要概括对话主题和关键进展
+
+【项目结构】（如涉及项目开发）详细描述：
+- 技术栈与框架
+- 目录结构与各目录职责
+- 关键文件及其作用
+- 模块间依赖关系
+- 已完成和待完成的功能
+
+【关键决策】列出重要决策及原因
+
+【要点】列出3-8个关键要点
+
 【错误与修复】列出遇到的错误及解决方案，标注"⚠️"避免重复`;
     }
+    /**
+     * 获取摘要用的模型列表（避免在分批循环中重复请求）
+     */
+    async getSummaryModels() {
+        if (!this.summaryModels) {
+            const token = index_js_1.authStore.get(this.session.userId).accessToken;
+            this.summaryModels = (await dataService_js_1.modelsService.list(token)).data.map((x) => (0, models_js_1.toModel)(x));
+        }
+        return this.summaryModels;
+    }
     /**
      * 生成对话摘要（支持分层摘要）
+     *
+     * 返回 null 表示摘要失败或被中断，调用方应保留原始历史而非写入残缺摘要。
      */
     async generateSummaryAsync(messages, lastSummary) {
         // 非 childAgent 会话通知 Desktop 显示"上下文压缩中"
@@ -231,20 +280,23 @@ ${conversation}
             return await this.hierarchicalSummary(formattedMessages, lastSummary);
         }
         const summaryPrompt = this.buildSummaryPrompt(messages, lastSummary);
-        const token = index_js_1.authStore.get(this.session.userId).accessToken;
-        const llmClient = new LLMClient_js_1.LLMClient((await dataService_js_1.modelsService.list(token)).data.map((x) => (0, models_js_1.toModel)(x)), [{ role: 'user', content: summaryPrompt }], this.signal, [], 600000);
+        const llmClient = new LLMClient_js_1.LLMClient(await this.getSummaryModels(), [{ role: 'user', content: summaryPrompt }], this.signal, [], 600000);
         if (this.session.useSystemMode) {
             const { getRequestToken, getServerBaseUrl } = await Promise.resolve().then(() => __importStar(require('../../api/index.js')));
             llmClient.setSystemMode(true, this.session.selectModelId, getServerBaseUrl(), getRequestToken());
         }
-        const response = await llmClient.Chat();
-        const content = (response.content || '').trim();
+        let content = '';
+        try {
+            const response = await llmClient.Chat();
+            content = (response.content || '').trim();
+        }
+        catch (error) {
+            logger.warn(`摘要生成失败，保留原始历史: ${error?.message}`);
+            return lastSummary || null;
+        }
         if (!content) {
-            logger.warn('摘要内容为空，保留旧摘要', {
-                lastSummary,
-                responseKeys: Object.keys(response),
-            });
-            return lastSummary || '（摘要生成失败，内容为空）';
+            logger.warn('摘要内容为空，保留旧摘要');
+            return lastSummary || null;
         }
         return content;
     }
@@ -253,42 +305,68 @@ ${conversation}
      */
     async hierarchicalSummary(formattedMessages, lastSummary) {
         const BATCH_SIZE = 15; // 每批消息数
-        const subSummaries = [];
+        const CONCURRENCY = 3; // 子摘要并发上限
+        const batches = [];
         for (let i = 0; i < formattedMessages.length; i += BATCH_SIZE) {
-            if (this.signal.aborted)
-                break;
-            const batch = formattedMessages.slice(i, i + BATCH_SIZE);
+            batches.push(formattedMessages.slice(i, i + BATCH_SIZE));
+        }
+        const models = await this.getSummaryModels();
+        const summarizeBatch = async (batch) => {
             const batchPrompt = `请简洁总结以下对话片段的关键信息，特别关注：项目结构、关键决策、错误及修复。\n\n${batch.join('\n\n')}`;
-            const token = index_js_1.authStore.get(this.session.userId).accessToken;
-            const llmClient = new LLMClient_js_1.LLMClient((await dataService_js_1.modelsService.list(token)).data.map((x) => (0, models_js_1.toModel)(x)), [{ role: 'user', content: batchPrompt }], this.signal, [], 600000);
+            const llmClient = new LLMClient_js_1.LLMClient(models, [{ role: 'user', content: batchPrompt }], this.signal, [], 600000);
             if (this.session.useSystemMode) {
                 const { getRequestToken, getServerBaseUrl } = await Promise.resolve().then(() => __importStar(require('../../api/index.js')));
                 llmClient.setSystemMode(true, this.session.selectModelId, getServerBaseUrl(), getRequestToken());
             }
             const response = await llmClient.Chat();
-            const subContent = (response.content || '').trim();
-            if (subContent) {
-                subSummaries.push(subContent);
+            return (response.content || '').trim();
+        };
+        // 保持批次顺序，同时限制并发
+        const subSummaries = new Array(batches.length).fill('');
+        let aborted = false;
+        for (let i = 0; i < batches.length; i += CONCURRENCY) {
+            if (this.signal.aborted) {
+                aborted = true;
+                break;
             }
+            const slice = batches.slice(i, i + CONCURRENCY);
+            const results = await Promise.allSettled(slice.map((batch) => summarizeBatch(batch)));
+            results.forEach((result, offset) => {
+                if (result.status === 'fulfilled' && result.value) {
+                    subSummaries[i + offset] = result.value;
+                }
+                else if (result.status === 'rejected') {
+                    logger.warn(`子摘要生成失败: ${result.reason?.message}`);
+                }
+            });
+        }
+        // 被中断时不写入残缺摘要，交由调用方回退到原始历史
+        if (aborted || this.signal.aborted) {
+            return lastSummary || null;
         }
-        // 合并所有子摘要
-        if (subSummaries.length === 0) {
-            return lastSummary || '（摘要生成失败）';
+        const valid = subSummaries.filter((x) => !!x);
+        if (valid.length === 0) {
+            return lastSummary || null;
         }
-        if (subSummaries.length === 1) {
-            return subSummaries[0];
+        if (valid.length === 1) {
+            return valid[0];
         }
         // 合并子摘要为最终摘要
-        const mergePrompt = this.buildMergePrompt(subSummaries, lastSummary);
-        const token = index_js_1.authStore.get(this.session.userId).accessToken;
-        const mergeLlmClient = new LLMClient_js_1.LLMClient((await dataService_js_1.modelsService.list(token)).data.map((x) => (0, models_js_1.toModel)(x)), [{ role: 'user', content: mergePrompt }], this.signal, [], 600000);
+        const mergePrompt = this.buildMergePrompt(valid, lastSummary);
+        const mergeLlmClient = new LLMClient_js_1.LLMClient(models, [{ role: 'user', content: mergePrompt }], this.signal, [], 600000);
         if (this.session.useSystemMode) {
             const { getRequestToken, getServerBaseUrl } = await Promise.resolve().then(() => __importStar(require('../../api/index.js')));
             mergeLlmClient.setSystemMode(true, this.session.selectModelId, getServerBaseUrl(), getRequestToken());
         }
-        const mergeResponse = await mergeLlmClient.Chat();
-        const mergedContent = (mergeResponse.content || '').trim();
-        return mergedContent || subSummaries.join('\n\n');
+        try {
+            const mergeResponse = await mergeLlmClient.Chat();
+            const mergedContent = (mergeResponse.content || '').trim();
+            return mergedContent || valid.join('\n\n');
+        }
+        catch (error) {
+            logger.warn(`摘要合并失败，回退为拼接: ${error?.message}`);
+            return valid.join('\n\n');
+        }
     }
     /**
      * 构建合并摘要提示词
@@ -297,31 +375,31 @@ ${conversation}
         const summaries = subSummaries
             .map((s, i) => `--- 片段 ${i + 1} ---\n${s}`)
             .join('\n\n');
-        return `你是一个对话摘要专家。以下是多个对话片段的摘要，请合并为一份完整的结构化摘要。
-
-重要规则：
-1. 合并重复信息，去重项目结构描述
-2. 如果涉及项目开发，务必完整保留项目结构信息（技术栈、目录结构、关键文件、模块关系）
-3. 按时间顺序整理决策和进展
-4. 保留所有错误信息及解决方案
-
-${lastSummary ? '=== 上一轮摘要 ===\n' + lastSummary + '\n\n' : ''}=== 分片段摘要 ===
-${summaries}
-
-=== 输出格式 ===
-【摘要】简要概括对话主题和关键进展
-
-【项目结构】（如涉及项目开发）详细描述：
-- 技术栈与框架
-- 目录结构与各目录职责
-- 关键文件及其作用
-- 模块间依赖关系
-- 已完成和待完成的功能
-
-【关键决策】列出重要决策及原因
-
-【要点】列出3-8个关键要点
-
+        return `你是一个对话摘要专家。以下是多个对话片段的摘要，请合并为一份完整的结构化摘要。
+
+重要规则：
+1. 合并重复信息，去重项目结构描述
+2. 如果涉及项目开发，务必完整保留项目结构信息（技术栈、目录结构、关键文件、模块关系）
+3. 按时间顺序整理决策和进展
+4. 保留所有错误信息及解决方案
+
+${lastSummary ? '=== 上一轮摘要 ===\n' + lastSummary + '\n\n' : ''}=== 分片段摘要 ===
+${summaries}
+
+=== 输出格式 ===
+【摘要】简要概括对话主题和关键进展
+
+【项目结构】（如涉及项目开发）详细描述：
+- 技术栈与框架
+- 目录结构与各目录职责
+- 关键文件及其作用
+- 模块间依赖关系
+- 已完成和待完成的功能
+
+【关键决策】列出重要决策及原因
+
+【要点】列出3-8个关键要点
+
 【错误与修复】列出遇到的错误及解决方案，标注"⚠️"避免重复`;
     }
 }

package/dist/services/session/Session.js

@@ -27,15 +27,16 @@ exports.Session = exports.handleApprovalResponse = exports.registerApprovalWaite
 const uuid_1 = require("uuid");
 const shared_1 = require("@myassis/shared");
 const SessionStore_js_1 = require("./SessionStore.js");
-const AgentStore_js_1 = require("@/services/agent/AgentStore.js");
-const authStore_js_1 = require("@/stores/authStore.js");
-const models_js_1 = require("@/services/models.js");
-const index_js_1 = require("@/services/tools/index.js");
+const AgentStore_js_1 = require("../../services/agent/AgentStore.js");
+const authStore_js_1 = require("../../stores/authStore.js");
+const models_js_1 = require("../../services/models.js");
+const index_js_1 = require("../../services/tools/index.js");
 const systemPrompt_js_1 = require("../systemPrompt.js");
 const LLMClient_js_1 = require("../llm/LLMClient.js");
-const dataService_js_1 = require("@/services/dataService.js");
+const dataService_js_1 = require("../../services/dataService.js");
 const MemoryManager_js_1 = require("../memory/MemoryManager.js");
-const index_js_2 = require("@/config/index.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 logger = (0, shared_1.getLogger)('Session');
 const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
@@ -570,82 +571,62 @@ class Session {
         let modelNames = [];
         //用于后续的消息滑动处理
         const messagesLength = messages.length;
-        const keep = index_js_2.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 toolCalls = [];
         // 获取本地工具定义
         const tools = (0, index_js_1.getToolDefinitions)();
         const models = this.useSystemMode
             ? (await dataService_js_1.modelsService.listSystem()).data.map(x => (0, models_js_1.toSystemModel)(x))
             : (await dataService_js_1.modelsService.list(token)).data.map(x => (0, models_js_1.toModel)(x));
-        // 递归处理函数（支持多轮工具调用）
-        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 = 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++;
-                    }
+        // 工具调用轮次计数，防止无限循环
+        let toolRound = 0;
+        // 当前裁剪级别，遇到上下文超限时逐级加重
+        let trimLevel = ContextBuilder_js_1.TrimLevel.OldToolPayload;
+        /** 判断错误是否为上下文超限 */
+        const isContextOverflow = (error) => {
+            const text = String(error?.message || error);
+            return text.includes('exceed max message tokens')
+                || text.includes('context_length_exceeded');
+        };
+        /**
+         * 调用模型：先按预算裁剪上下文，超限时逐级加重裁剪后重试。
+         *
+         * 裁剪只作用于投影副本，不会修改 messages / this.messages 中的原始数据。
+         */
+        const callModel = async () => {
+            let lastError;
+            while (true) {
+                const built = (0, ContextBuilder_js_1.buildContext)(messages, messagesLength, index_js_2.appConfig.contextMaxChars, trimLevel);
+                if (built.trimmed) {
+                    logger.debug(`上下文裁剪: level=${built.level} chars=${built.chars}`);
                 }
-                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 llmClient = new LLMClient_js_1.LLMClient(models, built.messages, this.abortController.signal, tools);
+                llmClient.setPreferredModel(this.selectModelId);
+                // 系统模式：转发到 Server LLM 代理
+                if (this.useSystemMode) {
+                    const { getRequestToken, getServerBaseUrl } = await Promise.resolve().then(() => __importStar(require('../../api/index.js')));
+                    llmClient.setSystemMode(true, this.selectModelId, getServerBaseUrl(), getRequestToken());
+                }
+                try {
+                    return await llmClient.Chat();
+                }
+                catch (error) {
+                    lastError = error;
+                    if (!isContextOverflow(error))
+                        throw error;
+                    const next = (0, ContextBuilder_js_1.nextTrimLevel)(trimLevel);
+                    if (next === null)
+                        throw error;
+                    logger.warn(`上下文超限，加重裁剪重试: ${trimLevel} -> ${next}`);
+                    trimLevel = next;
                 }
             }
-            // 使用 LLMClient 进行流式调用
+        };
+        // 递归处理函数（支持多轮工具调用）
+        const processModelResponse = async () => {
             if (!this.abortController || !this.abortController.signal || this.abortController.signal.aborted) {
                 throw Error('aborted');
             }
-            const llmClient = new LLMClient_js_1.LLMClient(models, messages, this.abortController.signal, tools);
-            llmClient.setPreferredModel(this.selectModelId);
-            // 系统模式：转发到 Server LLM 代理
-            if (this.useSystemMode) {
-                const { getRequestToken, getServerBaseUrl } = await Promise.resolve().then(() => __importStar(require('../../api/index.js')));
-                llmClient.setSystemMode(true, this.selectModelId, getServerBaseUrl(), getRequestToken());
-            }
-            // 使用 streamChat 调用模型
-            const llmResult = await llmClient.Chat();
+            const llmResult = await callModel();
             // 验证 LLM 结果
             if (!llmResult || !llmResult.modelName) {
                 throw new Error('Invalid LLM result: missing modelName');
@@ -654,6 +635,11 @@ class Session {
             modelNames.push(modelName);
             // ========== 处理工具调用 ==========
             if (llmResult.toolCalls && llmResult.toolCalls.length > 0) {
+                toolRound++;
+                if (toolRound > index_js_2.appConfig.maxToolRounds) {
+                    logger.warn(`工具调用轮次超过上限 ${index_js_2.appConfig.maxToolRounds}，终止本轮`);
+                    throw new Error(`工具调用轮次超过上限（${index_js_2.appConfig.maxToolRounds}），已终止以防无限循环`);
+                }
                 messages.push({
                     role: 'assistant',
                     content: llmResult.content,
@@ -929,7 +915,7 @@ class Session {
                     };
                     messages.push(toolResultMessage);
                 }
-                // 继续递归处理（带上工具结果继续调用模型）
+                // 继续下一轮（带上工具结果继续调用模型）
                 return await processModelResponse();
             }
             else {

package/dist/services/session/SessionManager.js

@@ -5,7 +5,7 @@ const uuid_1 = require("uuid");
 const shared_1 = require("@myassis/shared");
 const logger = (0, shared_1.getLogger)('SessionManager');
 const SessionStore_js_1 = require("./SessionStore.js");
-const authStore_js_1 = require("@/stores/authStore.js");
+const authStore_js_1 = require("../../stores/authStore.js");
 const Session_js_1 = require("./Session.js");
 /**
  * SessionManager - Business logic layer

package/dist/services/systemPrompt.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSystemPromptAsync = exports.LANGUAGES = exports.CHAT_STYLE_TEMPLATES = void 0;
-const index_js_1 = require("@/stores/index.js");
+const index_js_1 = require("../stores/index.js");
 const os_1 = __importDefault(require("os"));
 const dataService_js_1 = require("./dataService.js");
 const shared_1 = require("@myassis/shared");

package/dist/services/tools/model.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.modelTool = void 0;
 const dataService_js_1 = require("../dataService.js");
-const index_js_1 = require("@/stores/index.js");
+const index_js_1 = require("../../stores/index.js");
 exports.modelTool = {
     name: 'model',
     description: '模型管理工具',

package/dist/services/tools/skill.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.skillTool = void 0;
 const dataService_js_1 = require("../dataService.js");
-const index_js_1 = require("@/stores/index.js");
+const index_js_1 = require("../../stores/index.js");
 const shared_1 = require("@myassis/shared");
 const logger = (0, shared_1.getLogger)('skill');
 exports.skillTool = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myassis/gateway",
-  "version": "1.0.75",
+  "version": "1.0.77",
   "description": "我的助手 Gateway Service - 本地 AI 网关服务，支持认证、WebSocket 实时通信和任务调度",
   "main": "dist/index.js",
   "bin": {
@@ -44,7 +44,7 @@
     "@nut-tree/nut-js": "^4.2.0",
     "axios": "^1.15.2",
     "bcryptjs": "^2.4.3",
-    "better-sqlite3": "^11.10.0",
+    "better-sqlite3": "12.9.0",
     "cheerio": "^1.2.0",
     "compression": "^1.7.4",
     "cors": "^2.8.5",