@myassis/gateway 1.0.0 → 1.0.2

package/dist/services/systemPrompt.js

@@ -1,6 +1,7 @@
+import { authStore } from '@/stores';
 import os from 'os';
 import { settingsService, skillsService } from './dataService';
-import { getLogger } from '@pocketclaw/shared';
+import { getLogger } from '@myassis/shared';
 const logger = getLogger('SystemPrompt');
 // 预设的对话风格模板
 export const CHAT_STYLE_TEMPLATES = [
@@ -103,8 +104,9 @@ function getInstalledSkillsPrompt(skills) {
  */
 export async function getSystemPromptAsync(agent, customPrompt) {
     const osInfo = getOSInfo();
-    const settings = (await settingsService.get()).data;
-    const skills = (await skillsService.list()).data;
+    const token = authStore.get(agent.userId).accessToken;
+    const settings = (await settingsService.get(token)).data;
+    const skills = (await skillsService.list(token)).data;
     const skillPrompts = getInstalledSkillsPrompt(skills);
     const chineseLocalName = LANGUAGES.filter(x => x.code === settings.language)[0]?.chineseName ?? '简体中文';
     const date = new Date();
@@ -112,6 +114,7 @@ export async function getSystemPromptAsync(agent, customPrompt) {
   【当前运行环境】：${osInfo}。
   【当前时间】：${date.toLocaleString(settings.language)},weekday:${date.getDay()}。
   【语言】你的回复语言严格遵循用户设备系统语言：${chineseLocalName}，无论用户使用任何语言提问，你都只使用【${chineseLocalName}】进行完整回复，不要混用其他语言。
+  【尽力原则】充分分析用户需求，尽力满足，不要偷懒，不要得过且过，要诚实，不能胡编乱造。
   【工具调用】
   1.逐步思考，分步骤调用工具，工具调用前尽量返回content，明确当前工具调用的目的。
   2.工具调用的参数全部采用JSON语法，调用前先验证JSON语法正确后，再回复，切记未验证JSON语法就直接回复。
@@ -128,7 +131,7 @@ export async function getSystemPromptAsync(agent, customPrompt) {
   【解决问题思路】
   1.首先分析用户需求，根据需求罗列出实施计划。如果对需求不够明确，需要把计划罗列完后，让用户确认后再执行。
   2.按照计划分步执行
-  3.所有步骤完成后，验证结果，比如编写程序，则需要编译修改后的代码是否有问题
+  3.所有步骤完成后，验证结果，比如编写程序，则需要执行类型检查
   4.验证完全通过，总结完成情况，告诉用户
   【代码规范】
   ## 1 面向对象代码设计
@@ -141,6 +144,7 @@ export async function getSystemPromptAsync(agent, customPrompt) {
   ## 3 修改已经存在的代码文件
   1）修改Bug，找到Bug后精确替换，不要调整架构
   2）修改业务功能，删除旧的业务功能，重新添加新的，不要在旧的上面做修改，直接删除旧功能，然后添加新功能
+  【代码提交】务必类型检查通过
   ${skillPrompts}`;
     // 如果有自定义提示词，追加
     if (customPrompt) {

package/dist/services/task/PushTokenStore.js

@@ -2,7 +2,7 @@
  * PushTokenStore - 用户设备推送 Token 存储
  * 使用 SQLite 管理用户的多设备推送 Token
  */
-import { getLogger } from '@pocketclaw/shared';
+import { getLogger } from '@myassis/shared';
 const logger = getLogger('PushTokenStore');
 import { sessionStore } from '../session/SessionStore';
 export class PushTokenStore {
@@ -25,26 +25,8 @@ export class PushTokenStore {
         UNIQUE(user_id, token)
       )
     `);
-        // 确保 device_id 和 device_name 列存在（向后兼容）
-        this.ensureColumns();
         logger.info('Tables initialized');
     }
-    ensureColumns() {
-        const tableInfo = this.db.prepare("PRAGMA table_info(push_tokens)").all();
-        const columnNames = tableInfo.map((col) => col.name);
-        if (!columnNames.includes('device_id')) {
-            this.db.exec("ALTER TABLE push_tokens ADD COLUMN device_id TEXT");
-            logger.info('Added column: device_id');
-        }
-        if (!columnNames.includes('device_name')) {
-            this.db.exec("ALTER TABLE push_tokens ADD COLUMN device_name TEXT");
-            logger.info('Added column: device_name');
-        }
-        if (!columnNames.includes('provider')) {
-            this.db.exec("ALTER TABLE push_tokens ADD COLUMN provider TEXT DEFAULT 'expo'");
-            logger.info('Added column: provider');
-        }
-    }
     /**
      * 添加或更新 Push Token
      */

package/dist/services/task/TaskStore.js

@@ -2,7 +2,7 @@
  * TaskStore - Gateway 任务数据访问层
  * 操作 SQLite 数据库，与 AgentStore/SessionStore 共享同一个数据库实例
  */
-import { getLogger } from '@pocketclaw/shared';
+import { getLogger } from '@myassis/shared';
 import { sessionStore } from '../session/SessionStore';
 const logger = getLogger('TaskStore');
 function rowToTaskData(row) {
@@ -59,27 +59,8 @@ export class TaskStore {
         updated_at INTEGER NOT NULL
       )
     `);
-        // 确保必要列存在（向后兼容）
-        this.ensureColumns();
         logger.info('Tables initialized');
     }
-    ensureColumns() {
-        const tableInfo = this.db.prepare("PRAGMA table_info(tasks)").all();
-        const columnNames = tableInfo.map((col) => col.name);
-        const requiredColumns = [
-            { name: 'platform_apply', sql: 'ALTER TABLE tasks ADD COLUMN platform_apply TEXT' },
-            { name: 'push_token', sql: 'ALTER TABLE tasks ADD COLUMN push_token TEXT' },
-            { name: 'recurrence_rule', sql: 'ALTER TABLE tasks ADD COLUMN recurrence_rule TEXT' },
-            { name: 'interval_value', sql: 'ALTER TABLE tasks ADD COLUMN interval_value INTEGER' },
-            { name: 'interval_unit', sql: 'ALTER TABLE tasks ADD COLUMN interval_unit TEXT' },
-        ];
-        for (const col of requiredColumns) {
-            if (!columnNames.includes(col.name)) {
-                this.db.exec(col.sql);
-                logger.info(`Added column: ${col.name}`);
-            }
-        }
-    }
     // ========== Task Operations ==========
     insert(task) {
         this.db.prepare(`

package/dist/services/tools/edit.js

@@ -1,71 +1,44 @@
 /**
- * 文件编辑工具 - 行范围编辑（Plan A）
+ * 文件编辑工具（内容匹配模式）
  *
  * 设计原则：
- * - LLM 提供行号范围（oldRange），工具负责读取、验证、执行
- * - 每个 edit 只处理一个行范围，多次编辑拆成多个 edit
- * - 验证机制：LLM 可提供 oldContent 供工具比对，不匹配时返回实际内容供修正
- * - 多 edit 时从后往前执行，避免行号偏移
+ * - LLM 提供 oldContent（精确字符串）+ newContent，工具在文件中搜索 oldContent 并替换
+ * - 不依赖行号，避免 LLM 数错行
+ * - oldContent 为必填项，缺失则拒绝执行
+ * - 若 oldContent 在文件中出现多次，默认只替换第一个匹配；设置 replaceAll: true 可替换全部
+ * - 若未设置 replaceAll 且出现多次匹配，返回所有匹配位置（含上下文）供 LLM 修正
+ * - 可选提供 oldRange 作为辅助校验：若提供，工具验证该范围内内容是否与 oldContent 一致
  *
  * 安全机制：
- * - 路径白名单校验，禁止路径穿越
  * - 文件不存在时拒绝操作（不允许静默创建）
  * - 目录不存在时拒绝操作（不允许递归创建目录）
  * - 文件大小限制（默认 10MB）
  * - 编辑操作数量限制（默认 20 个）
- * - 编辑范围重叠检测
  * - 敏感内容脱敏（限制错误返回中的内容长度）
  * - 异步 I/O，不阻塞事件循环
  *
  * LLM 用法：
- *   1. 先用 read 读取文件（拿到行号和内容）
- *   2. 指定 oldRange: { startLine, endLine } + newContent
- *   3. 可选提供 oldContent 让工具验证替换区间的实际内容
- *   4. 验证失败时工具返回实际内容，LLM 据此修正后重试
+ *   1. 先用 read 读取文件内容
+ *   2. 指定 oldContent（精确字符串，必填）+ newContent（替换后的内容）
+ *   3. 可选：replaceAll: true 替换所有匹配；oldRange 辅助校验特定位置
+ *   4. 匹配失败时工具返回实际内容片段，LLM 据此修正后重试
  */
 import fs from 'fs/promises';
 import path from 'path';
-import os from 'os';
-import { getLogger } from '@pocketclaw/shared';
+import { getLogger } from '@myassis/shared';
 const logger = getLogger('edit');
-// ---------- 安全常量 ----------
-/** 允许访问的根目录白名单 */
-const ALLOWED_ROOTS = [
-    os.homedir(),
-    os.tmpdir(),
-    process.env.WORKSPACE_DIR || '',
-    process.env.GATEWAY_DIR || '',
-].filter(Boolean).map(p => path.resolve(p));
+// ---------- 常量 ----------
 /** 最大文件大小（10MB） */
 const MAX_FILE_SIZE = 10 * 1024 * 1024;
 /** 单次最大编辑操作数 */
 const MAX_EDITS = 20;
 /** 错误信息中返回的最大内容长度 */
 const MAX_ERROR_CONTENT_LENGTH = 500;
-// ---------- 安全校验 ----------
+/** 匹配位置上下文展示行数 */
+const CONTEXT_LINES = 3;
+// ---------- 辅助函数 ----------
 /**
- * 路径安全校验：检测路径穿越并验证路径在白名单内
- */
-function isPathAllowed(filePath) {
-    // 标准化路径，解析 .. 等相对路径组件
-    const resolved = path.resolve(filePath);
-    const normalized = path.normalize(filePath);
-    // 检测路径穿越：标准化后仍包含 .. 表示非法穿越
-    if (normalized.includes('..')) {
-        return { allowed: false, reason: `路径包含穿越组件（..）: ${filePath}` };
-    }
-    // 校验路径是否在允许的根目录下
-    const isUnderAllowedRoot = ALLOWED_ROOTS.some(root => resolved.startsWith(root + path.sep) || resolved === root);
-    // if (!isUnderAllowedRoot) {
-    //   return {
-    //     allowed: false,
-    //     reason: `路径不在允许范围内: ${resolved}`,
-    //   };
-    // }
-    return { allowed: true };
-}
-/**
- * 检测敏感文件路径
+ * 检测敏感文件路径（脱敏用，不阻止操作）
  */
 function isSensitivePath(filePath) {
     const lower = filePath.toLowerCase();
@@ -85,47 +58,54 @@ function sanitizeContent(content, filePath) {
     }
     return content;
 }
-// ---------- 核心逻辑 ----------
 /**
- * 读取指定行范围（1-indexed）的原始内容
+ * 在文本中查找所有 oldContent 的起始位置
  */
-function getRangeContent(lines, startLine, endLine) {
-    return lines.slice(startLine - 1, endLine).join('\n');
+function findAllPositions(content, search) {
+    const positions = [];
+    let pos = 0;
+    if (search.length === 0)
+        return positions;
+    while ((pos = content.indexOf(search, pos)) !== -1) {
+        positions.push(pos);
+        pos += Math.max(search.length, 1);
+    }
+    return positions;
 }
 /**
- * 执行单个行范围替换
+ * 将字符偏移量转换为行号（1-indexed）
  */
-function applyRangeEdit(lines, startLine, endLine, newContent) {
-    const before = lines.slice(0, startLine - 1);
-    const after = lines.slice(endLine);
-    const newLines = newContent ? newContent.split('\n') : [];
-    return [...before, ...newLines, ...after];
+function offsetToLine(content, offset) {
+    return content.slice(0, offset).split('\n').length;
 }
 /**
- * 检测编辑范围是否重叠
+ * 生成匹配位置的可读描述（含上下文字符）
  */
-function hasOverlappingRanges(edits) {
-    for (let i = 0; i < edits.length; i++) {
-        for (let j = i + 1; j < edits.length; j++) {
-            const a = edits[i].oldRange;
-            const b = edits[j].oldRange;
-            if (a.startLine <= b.endLine && b.startLine <= a.endLine) {
-                return {
-                    overlap: true,
-                    message: `编辑范围重叠：edits[${i}]（第 ${a.startLine}-${a.endLine} 行）与 edits[${j}]（第 ${b.startLine}-${b.endLine} 行）重叠`,
-                };
-            }
-        }
+function describeMatches(content, positions, search, filePath) {
+    const lines = content.split('\n');
+    const parts = [];
+    for (const pos of positions) {
+        const lineNo = offsetToLine(content, pos);
+        const start = Math.max(0, lineNo - CONTEXT_LINES - 1);
+        const end = Math.min(lines.length, lineNo + CONTEXT_LINES);
+        const context = lines.slice(start, end).map((l, i) => `${start + i + 1} | ${l}`).join('\n');
+        parts.push(`匹配位置（行号约 ${lineNo}）：\n${context}`);
     }
-    return { overlap: false };
+    return `oldContent 在文件中出现 ${positions.length} 次，请明确要替换的目标。` +
+        `可提供 oldRange（起始行号）辅助定位，或设置 replaceAll: true 替换全部。\n\n` +
+        parts.join('\n\n');
 }
 // ---------- 工具定义 ----------
 const editTool = {
     name: 'edit',
-    description: '文件编辑工具（行范围模式）。' +
-        'LLM 先用 read 读取文件获得行号，然后指定 oldRange（起始行、结束行）和 newContent（替换后的内容）。' +
-        '可选提供 oldContent 让工具验证实际内容是否与预期一致。' +
-        '支持一次调用多个 edit（从后往前执行避免行号偏移）。',
+    description: '⚠️ oldContent 为必填项，未提供将拒绝执行。\n\n' +
+        '文件编辑工具（内容匹配模式）。\n' +
+        'LLM 先用 read 读取文件内容，然后指定 oldContent（精确字符串，必填）和 newContent（替换后的内容）。\n' +
+        '工具在文件中搜索 oldContent 并替换，不依赖行号。\n' +
+        '若 oldContent 出现多次，默认只替换第一个匹配；设置 replaceAll: true 可替换全部。\n' +
+        '若未设置 replaceAll 且出现多次匹配，工具返回所有匹配位置供 LLM 选择。\n' +
+        '可选提供 oldRange（起始行号）辅助校验特定位置。\n' +
+        '支持一次调用多个 edit。',
     parameters: {
         type: 'object',
         properties: {
@@ -135,29 +115,32 @@ const editTool = {
                 description: '编辑操作列表',
                 items: {
                     type: 'object',
-                    description: '单个行范围编辑操作',
+                    description: '单个内容匹配编辑操作',
                     properties: {
-                        oldRange: {
-                            type: 'object',
-                            description: '要替换的行范围（1-indexed，包含 startLine 和 endLine）',
-                            properties: {
-                                startLine: { type: 'number', description: '起始行号（1-indexed）' },
-                                endLine: { type: 'number', description: '结束行号（1-indexed，必须 >= startLine）' },
-                            },
-                            required: ['startLine', 'endLine'],
+                        oldContent: {
+                            type: 'string',
+                            description: '【必填】要被替换的原有内容（精确字符串匹配，区分大小写）',
                         },
                         newContent: {
                             type: 'string',
-                            description: '替换后的内容（留空或不填表示删除该行范围）',
+                            description: '【必填】替换后的新内容',
                         },
-                        oldContent: {
-                            type: 'string',
-                            description: '【可选】LLM 认为该范围内原有的内容。工具会比对，不一致时返回实际内容供修正',
+                        replaceAll: {
+                            type: 'boolean',
+                            description: '是否替换所有匹配（默认 false，只替换第一个）。当 oldContent 在文件中出现多次时使用',
+                        },
+                        oldRange: {
+                            type: 'object',
+                            description: '【可选】辅助校验：oldContent 所在的大致行范围，用于验证匹配位置',
+                            properties: {
+                                startLine: { type: 'number', description: '起始行号（1-indexed，可选）' },
+                                endLine: { type: 'number', description: '结束行号（1-indexed，可选）' },
+                            },
                         },
                     },
-                    required: ['oldRange'],
+                    required: ['oldContent', 'newContent'],
                 },
-            }
+            },
         },
         required: ['path', 'edits'],
     },
@@ -170,18 +153,15 @@ const editTool = {
             if (!Array.isArray(edits) || edits.length === 0)
                 return { success: false, errorMessage: 'edits 必须为非空数组' };
             for (let i = 0; i < edits.length; i++) {
-                const { oldRange } = edits[i];
-                if (!oldRange || typeof oldRange.startLine !== 'number' || typeof oldRange.endLine !== 'number')
-                    return { success: false, errorMessage: `edits[${i}]: 必须提供有效的 oldRange（startLine 和 endLine）` };
-                if (oldRange.startLine < 1)
-                    return { success: false, errorMessage: `edits[${i}]: startLine 必须 >= 1` };
-                if (oldRange.endLine < oldRange.startLine)
-                    return { success: false, errorMessage: `edits[${i}]: endLine (${oldRange.endLine}) 必须 >= startLine (${oldRange.startLine})` };
-            }
-            // ---- 路径安全校验 ----
-            const pathCheck = isPathAllowed(filePath);
-            if (!pathCheck.allowed) {
-                return { success: false, errorMessage: pathCheck.reason };
+                if (typeof edits[i].oldContent !== 'string') {
+                    return { success: false, errorMessage: `edits[${i}]: oldContent 为必填项，且必须为字符串` };
+                }
+                if (typeof edits[i].newContent !== 'string') {
+                    return { success: false, errorMessage: `edits[${i}]: newContent 为必填项，且必须为字符串` };
+                }
+                if (edits[i].oldContent.length === 0) {
+                    return { success: false, errorMessage: `edits[${i}]: oldContent 不能为空字符串` };
+                }
             }
             // ---- 文件存在性 & 大小校验 ----
             let original;
@@ -208,61 +188,58 @@ const editTool = {
                     errorMessage: `单次最多 ${MAX_EDITS} 个编辑操作，当前 ${edits.length} 个`,
                 };
             }
-            const origLines = original.split('\n').filter((_, i, arr) => !(i === arr.length - 1 && _ === ''));
-            const totalLines = origLines.length;
-            // ---- 验证每个 edit 的行范围 ----
+            // ---- 执行每个 edit ----
+            let current = original;
+            const results = [];
             for (let i = 0; i < edits.length; i++) {
-                const { oldRange } = edits[i];
-                if (oldRange.startLine > totalLines)
-                    return {
-                        success: false,
-                        errorMessage: `edits[${i}]: startLine=${oldRange.startLine} 超出文件总行数（${totalLines}）。`,
-                    };
-                if (oldRange.endLine > totalLines)
+                const { oldContent, newContent, replaceAll, oldRange } = edits[i];
+                // ---- 若提供了 oldRange，做辅助校验 ----
+                if (oldRange && oldRange.startLine >= 1 && oldRange.endLine >= oldRange.startLine) {
+                    const lines = current.split('\n');
+                    const rangeContent = lines.slice(oldRange.startLine - 1, oldRange.endLine).join('\n');
+                    if (!rangeContent.includes(oldContent)) {
+                        const safeContent = sanitizeContent(rangeContent, filePath);
+                        return {
+                            success: false,
+                            errorMessage: `edits[${i}]: oldRange 指定的行范围内容中未找到 oldContent。` +
+                                `该范围实际内容:\n\`\`\`\n${safeContent}\n\`\`\``,
+                        };
+                    }
+                }
+                // ---- 查找所有匹配位置 ----
+                const positions = findAllPositions(current, oldContent);
+                if (positions.length === 0) {
+                    const safeContent = sanitizeContent(current.slice(0, 2000), filePath);
                     return {
                         success: false,
-                        errorMessage: `edits[${i}]: endLine=${oldRange.endLine} 超出文件总行数（${totalLines}）。`,
+                        errorMessage: `edits[${i}]: oldContent 在文件中未找到匹配。` +
+                            `文件当前内容片段:\n\`\`\`\n${safeContent}\n\`\`\``,
                     };
-            }
-            // ---- 编辑范围重叠检测 ----
-            const overlapCheck = hasOverlappingRanges(edits);
-            if (overlapCheck.overlap) {
-                return { success: false, errorMessage: overlapCheck.message };
-            }
-            // ---- 验证 oldContent（如果有） ----
-            for (let i = 0; i < edits.length; i++) {
-                const { oldRange, oldContent } = edits[i];
-                if (!oldContent)
-                    continue;
-                const actualContent = getRangeContent(origLines, oldRange.startLine, oldRange.endLine);
-                if (actualContent !== oldContent) {
-                    const safeContent = sanitizeContent(actualContent, filePath);
+                }
+                // ---- 多次匹配且未设置 replaceAll → 返回匹配位置 ----
+                if (positions.length > 1 && !replaceAll) {
+                    const description = describeMatches(current, positions, oldContent, filePath);
                     return {
                         success: false,
-                        errorMessage: `edits[${i}]: 提供的 oldContent 与文件第 ${oldRange.startLine}-${oldRange.endLine} 行实际内容不一致。` +
-                            `工具发现的内容:\n\`\`\`\n${safeContent}\n\`\`\``,
+                        errorMessage: `edits[${i}]: oldContent 在文件中出现 ${positions.length} 次，请明确目标。\n${description}`,
                     };
                 }
-            }
-            // ---- 从后往前执行替换（避免行号偏移） ----
-            let currentLines = [...origLines];
-            const sortedEdits = [...edits].sort((a, b) => b.oldRange.endLine - a.oldRange.endLine);
-            // 用 Map 记录 edit -> 原始索引（修复 indexOf 重复问题）
-            const editIndexMap = new Map();
-            edits.forEach((edit, idx) => editIndexMap.set(edit, idx));
-            const results = [];
-            for (const edit of sortedEdits) {
-                const { oldRange, newContent = '' } = edit;
-                const { startLine, endLine } = oldRange;
-                currentLines = applyRangeEdit(currentLines, startLine, endLine, newContent);
+                // ---- 执行替换 ----
+                if (replaceAll) {
+                    current = current.split(oldContent).join(newContent);
+                }
+                else {
+                    const pos = positions[0];
+                    current = current.slice(0, pos) + newContent + current.slice(pos + oldContent.length);
+                }
                 results.push({
-                    editIndex: editIndexMap.get(edit) ?? -1,
-                    startLine,
-                    endLine,
-                    newLines: newContent ? newContent.split('\n').length : 0,
+                    editIndex: i,
+                    matches: positions.length,
+                    replaced: replaceAll ? positions.length : 1,
                 });
             }
-            const modified = currentLines.join('\n');
+            // ---- 恢复行尾格式 ----
+            let modified = current;
             // ---- 内容未变检测 ----
             if (modified === original) {
                 return {
@@ -291,8 +268,7 @@ const editTool = {
                 editCount: edits.length,
                 originalSize: original.length,
                 modifiedSize: modified.length,
-                originalLines: totalLines,
-                modifiedLines: currentLines.length,
+                results,
             });
             return {
                 success: true,
@@ -300,11 +276,9 @@ const editTool = {
                     path: filePath,
                     editCount: edits.length,
                     stats: {
-                        originalLines: totalLines,
-                        modifiedLines: currentLines.length,
-                        linesChanged: currentLines.length - totalLines,
                         originalSize: original.length,
                         modifiedSize: modified.length,
+                        details: results,
                     },
                 }),
             };

package/dist/services/tools/exec.js

@@ -2,7 +2,7 @@ import { exec } from 'child_process';
 import { promisify } from 'util';
 import path from 'path';
 import os from 'os';
-import { getLogger } from '@pocketclaw/shared';
+import { getLogger } from '@myassis/shared';
 const logger = getLogger('exec');
 const execAsync = promisify(exec);
 // 会话级工作目录状态：sessionId -> cwd

package/dist/services/tools/fetch.js

@@ -1,4 +1,4 @@
-import { getLogger } from '@pocketclaw/shared';
+import { getLogger } from '@myassis/shared';
 const logger = getLogger('FetchTool');
 let _undiciCache = null;
 async function loadUndici() {

package/dist/services/tools/file.js

@@ -7,7 +7,7 @@ import path from 'path';
 import os from 'os';
 import { exec } from 'child_process';
 import { promisify } from 'util';
-import { getLogger } from '@pocketclaw/shared';
+import { getLogger } from '@myassis/shared';
 const logger = getLogger('FileTool');
 const execAsync = promisify(exec);
 const DEFAULT_EXCLUDE_DIRS = [
@@ -155,19 +155,14 @@ export const fileTool = {
                     if (offset > totalLines) {
                         return { success: true, output: JSON.stringify({ totalLines, message: `offset (${offset}) 超出文件总行数 (${totalLines})，文件已读完` }) };
                     }
-                    // 显示真实行号（而非 1,2,3...）让 LLM 准确知道位置
-                    const contentLines = allLines.slice(offset - 1, endLine).map((item, index) => `${offset + index} ${item}`);
-                    // 原始内容（无行号前缀），供 LLM 用作 edit 的 oldContent 比对
-                    const rawContent = allLines.slice(offset - 1, endLine).join('\n');
+                    // 直接返回纯内容，供 LLM 做 edit oldContent 比对
+                    const content = allLines.slice(offset - 1, endLine).join('\n');
                     return {
                         success: true,
                         output: JSON.stringify({
                             totalLines,
                             readRange: { startLine: offset, endLine },
-                            // 带行号前缀的显示内容，LLM 可参考行号
-                            content: contentLines.join('\n'),
-                            // 原始内容（无行号），供 oldContent 比对使用
-                            rawContent,
+                            content,
                         }),
                     };
                 }

package/dist/services/tools/index.js

@@ -15,10 +15,11 @@ import { taskTool } from './task';
 import { modelTool } from './model';
 import { editTool } from './edit';
 import { webFetchTool } from './webFetch';
+import { sessionsSpawnTool } from './sessionsSpawn';
 export const tools = [
     searchTool, calculatorTool, screenshotTool, keyboardTool, mouseTool,
     skillTool, execTool, taskTool, modelTool, fetchTool,
-    editTool, webFetchTool, fileTool
+    editTool, webFetchTool, fileTool, sessionsSpawnTool
 ];
 export function getToolByName(name) {
     return tools.find(tool => tool.name === name);
@@ -26,11 +27,11 @@ export function getToolByName(name) {
 /**
  * 执行工具调用，返回 ToolResult（AI 可见格式）
  */
-export async function executeTool(name, args, sessionId, messageId) {
+export async function executeTool(name, args, sessionId, messageId, userId) {
     const tool = getToolByName(name);
     if (!tool)
         throw new Error(`Tool not found: ${name}`);
-    return await tool.handler(args, sessionId, messageId);
+    return await tool.handler(args, sessionId, messageId, userId);
 }
 export function getToolDefinitions() {
     return tools.map(tool => ({

package/dist/services/tools/model.js

@@ -1,4 +1,5 @@
 import { modelsService } from '../dataService';
+import { authStore } from '@/stores';
 export const modelTool = {
     name: 'model',
     description: '模型管理工具',
@@ -21,12 +22,13 @@ export const modelTool = {
         },
         required: ['action'],
     },
-    handler: async (args) => {
+    handler: async (args, sessionId, messageId, userId) => {
         try {
             const { action, modelId, modelName, modelIdName, baseUrl, apiKey, provider = 'doubao', isPrimary = false, supportsToolCall = true } = args;
+            const token = authStore.get(userId).accessToken;
             switch (action) {
                 case 'list': {
-                    const response = await modelsService.list();
+                    const response = await modelsService.list(token);
                     if (!response.success)
                         return { success: false, errorMessage: response.error || '获取列表失败' };
                     const models = response.data || [];
@@ -35,7 +37,7 @@ export const modelTool = {
                 case 'add': {
                     if (!modelName || !baseUrl || !modelIdName)
                         return { success: false, errorMessage: '添加模型需要提供模型名称、模型 ID 和 API 地址' };
-                    const response = await modelsService.create({ modelName, modelId: modelIdName, baseUrl, apiKey, provider, isPrimary, supportsToolCall });
+                    const response = await modelsService.create({ modelName, modelId: modelIdName, baseUrl, apiKey, provider, isPrimary, supportsToolCall }, token);
                     if (!response.success)
                         return { success: false, errorMessage: response.error || '添加失败' };
                     return { success: true, output: JSON.stringify({ model: response.data }) };
@@ -54,7 +56,7 @@ export const modelTool = {
                         updateData.isPrimary = isPrimary;
                     if (supportsToolCall !== undefined)
                         updateData.supportsToolCall = supportsToolCall;
-                    const response = await modelsService.update(modelId, updateData);
+                    const response = await modelsService.update(modelId, updateData, token);
                     if (!response.success)
                         return { success: false, errorMessage: response.error || '更新失败' };
                     return { success: true, output: JSON.stringify({ model: response.data }) };
@@ -62,7 +64,7 @@ export const modelTool = {
                 case 'delete': {
                     if (!modelId)
                         return { success: false, errorMessage: '删除模型需要提供模型 ID' };
-                    const response = await modelsService.delete(modelId);
+                    const response = await modelsService.delete(modelId, token);
                     if (!response.success)
                         return { success: false, errorMessage: response.error || '删除失败' };
                     return { success: true };
@@ -70,7 +72,7 @@ export const modelTool = {
                 case 'setPrimary': {
                     if (!modelId)
                         return { success: false, errorMessage: '设为默认需要提供模型 ID' };
-                    const response = await modelsService.setPrimary(modelId);
+                    const response = await modelsService.setPrimary(modelId, token);
                     if (!response.success)
                         return { success: false, errorMessage: response.error || '设置失败' };
                     return { success: true };