Agent 对话可配置最大工具调用次数 + Token 优化 + 循环检测升级

packages/message/types.ts

@@ -11,6 +11,8 @@ export type TMessagQueueUnit<T = any> = {
 export type TMessageCommAction<T = any> = {
   action: string;
   data?: NonNullable<T>;
+  /** 可选请求关联 ID，用于连接上的请求/响应批次匹配。 */
+  requestId?: string;
   msgQueue?: never;
   code?: never;
 };

src/app/repo/agent_chat.test.ts

@@ -10,6 +10,8 @@ function createMockOPFS() {
         data = content;
       }),
       close: vi.fn(async () => {}),
+      // 真实 OPFS 的 abort() 放弃这次写入的临时副本，不影响 dir 里已提交的旧内容
+      abort: vi.fn(async () => {}),
       getData: () => data,
     };
   }
@@ -250,3 +252,34 @@ describe("AgentChatRepo 附件存储", () => {
     expect(await repo.getAttachment("att-del-2")).toBeNull();
   });
 });
+
+describe("AgentChatRepo.saveMessages 取消安全（finding 4）", () => {
+  let repo: AgentChatRepo;
+
+  beforeEach(() => {
+    createMockOPFS();
+    repo = new AgentChatRepo();
+  });
+
+  it("signal 已 abort 时 saveMessages 应 reject 且不覆盖已持久化的旧消息", async () => {
+    const convId = "conv-cancel";
+    const oldMessage = {
+      id: "msg-old",
+      conversationId: convId,
+      role: "user" as const,
+      content: "原始历史",
+      createtime: Date.now(),
+    };
+    await repo.saveMessages(convId, [oldMessage]);
+
+    const controller = new AbortController();
+    controller.abort();
+    await expect(
+      repo.saveMessages(convId, [{ ...oldMessage, id: "msg-new", content: "摘要覆盖" }], controller.signal)
+    ).rejects.toThrow("Aborted");
+
+    // 旧内容必须完整保留，没有被这次放弃的写入部分覆盖或破坏
+    const stored = await repo.getMessages(convId);
+    expect(stored).toEqual([oldMessage]);
+  });
+});

src/app/repo/agent_chat.ts

@@ -99,10 +99,12 @@ export class AgentChatRepo extends OPFSRepo {
     }
   }
 
-  // 保存整个消息列表（用于批量更新）
-  async saveMessages(conversationId: string, messages: ChatMessage[]): Promise<void> {
+  // 保存整个消息列表（用于批量更新）。
+  // signal 可选：传入时若在写入落定前已 abort，则放弃这次整份覆写而不是让它继续提交
+  // （OPFS createWritable() 本身是事务性的，写入的是临时副本，abort 不会影响已持久化的旧内容，见 finding 4）
+  async saveMessages(conversationId: string, messages: ChatMessage[], signal?: AbortSignal): Promise<void> {
     const messagesDir = await this.getChildDir(MESSAGES_DIR);
-    await this.writeJsonFile(`${conversationId}.json`, messages, messagesDir);
+    await this.writeJsonFile(`${conversationId}.json`, messages, messagesDir, signal);
   }
 
   // ---- 附件存储 ----

src/app/repo/agent_model.ts

@@ -1,4 +1,5 @@
 import type { AgentModelConfig } from "@App/app/service/agent/core/types";
+import { normalizeModelLimits } from "@App/app/service/agent/core/model_context";
 import { Repo, loadCache } from "./repo";
 
 const DEFAULT_MODEL_KEY = "agent_model:__default__";
@@ -21,9 +22,9 @@ export class AgentModelRepo extends Repo<AgentModelConfig> {
     return this.get(id);
   }
 
-  // 保存模型
+  // 保存模型：存储边界统一归一化 maxTokens/contextWindow（见 model_context.ts，finding 10）
   async saveModel(model: AgentModelConfig): Promise<void> {
-    await this._save(model.id, model);
+    await this._save(model.id, normalizeModelLimits(model));
   }
 
   // 删除模型

src/app/repo/opfs_repo.ts

@@ -56,12 +56,31 @@ export class OPFSRepo {
     }
   }
 
-  // 写入 JSON 文件
-  protected async writeJsonFile(filename: string, data: unknown, dir?: FileSystemDirectoryHandle): Promise<void> {
+  // 写入 JSON 文件。
+  // OPFS 的 createWritable() 本身是事务性的：write() 写入的是临时副本，只有 close() 成功
+  // 才会原子替换原文件；调用方持有的旧内容在此之前始终完整可读。
+  // 传入 signal 时，若在"调用 close() 之前"已 abort，则改为 writable.abort() 放弃这次写入。
+  // 诚实说明这里的边界：这只保证 close() 调用前的 abort 一定不会提交；一旦 close() 已经
+  // 发出，FSA 规范不提供可靠的方式中途取消它，abort 恰好落在 close() 进行期间这个极窄窗口
+  // 理论上仍可能提交。调用方（compact_service.ts / chat_service_base.ts）都会在
+  // saveMessages() resolve 之后再次检查 signal，因此即使命中这个窗口，也不会对外报告
+  // 虚假的成功事件（compact_done/done）——唯一的残留风险是磁盘内容被替换但会话已判定为
+  // 取消，这是一个已知的、极窄的边界情况，未做完整的事务回滚（见 finding 2）。
+  protected async writeJsonFile(
+    filename: string,
+    data: unknown,
+    dir?: FileSystemDirectoryHandle,
+    signal?: AbortSignal
+  ): Promise<void> {
+    if (signal?.aborted) throw new Error("Aborted");
     const targetDir = dir || (await this.getDir());
     const fileHandle = await targetDir.getFileHandle(filename, { create: true });
     const writable = await fileHandle.createWritable();
     await writable.write(JSON.stringify(data));
+    if (signal?.aborted) {
+      await writable.abort().catch(() => {});
+      throw new Error("Aborted");
+    }
     await writable.close();
   }
 

src/app/service/agent/core/abort_utils.ts

@@ -0,0 +1,32 @@
+/** Create a standard abort error for tool execution flows. */
+export function createAbortError(message = "Aborted"): Error {
+  return new Error(message);
+}
+
+/** Throw immediately when the signal is already aborted. */
+export function throwIfAborted(signal?: AbortSignal): void {
+  if (signal?.aborted) {
+    throw createAbortError();
+  }
+}
+
+/** Reject as soon as the signal aborts, while leaving the original promise untouched. */
+export function raceWithAbort<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T> {
+  if (!signal) return promise;
+  if (signal.aborted) return Promise.reject(createAbortError());
+
+  return new Promise<T>((resolve, reject) => {
+    const onAbort = () => reject(createAbortError());
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      }
+    );
+  });
+}

src/app/service/agent/core/agent.test.ts

@@ -268,7 +268,7 @@ describe("OpenAI Provider", () => {
 
     it("应正确解析带 usage 的 done 事件", async () => {
       const events = await collectEvents(parseOpenAIStream, [
-        'data: {"choices":[{"delta":{"content":"hi"}}]}\n\n',
+        'data: {"choices":[{"delta":{"content":"hi"},"finish_reason":"stop"}]}\n\n',
         'data: {"usage":{"prompt_tokens":10,"completion_tokens":5}}\n\n',
       ]);
 
@@ -328,18 +328,17 @@ describe("OpenAI Provider", () => {
       }
     });
 
-    it("signal 中断时不应产生错误事件", async () => {
+    it("signal 中断时应 reject 而不是静默完成（否则外层 callLLM 永远挂起）", async () => {
       const abortController = new AbortController();
       abortController.abort();
 
-      const events = await collectEvents(
-        parseOpenAIStream,
-        ['data: {"choices":[{"delta":{"content":"hello"}}]}\n\n'],
-        abortController.signal
-      );
-
-      // signal 已中断，不应处理任何数据
-      expect(events).toHaveLength(0);
+      await expect(
+        collectEvents(
+          parseOpenAIStream,
+          ['data: {"choices":[{"delta":{"content":"hello"}}]}\n\n'],
+          abortController.signal
+        )
+      ).rejects.toThrow("Aborted");
     });
   });
 });
@@ -548,7 +547,7 @@ function buildSSEResponse(sseChunks: string[]): Response {
 // 辅助：构造纯文本 SSE 数据（OpenAI 格式）
 function makeTextSSE(text: string, usage?: { prompt_tokens: number; completion_tokens: number }): string[] {
   const chunks: string[] = [];
-  chunks.push(`data: {"choices":[{"delta":{"content":"${text}"}}]}\n\n`);
+  chunks.push(`data: {"choices":[{"delta":{"content":"${text}"},"finish_reason":"stop"}]}\n\n`);
   if (usage) {
     chunks.push(`data: {"usage":${JSON.stringify(usage)}}\n\n`);
   } else {
@@ -569,7 +568,7 @@ function makeToolCallSSE(
     `data: {"choices":[{"delta":{"tool_calls":[{"id":"${toolId}","function":{"name":"${toolName}","arguments":""}}]}}]}\n\n`
   );
   chunks.push(
-    `data: {"choices":[{"delta":{"tool_calls":[{"function":{"arguments":"${args.replace(/"/g, '\\"')}"}}]}}]}\n\n`
+    `data: {"choices":[{"delta":{"tool_calls":[{"function":{"arguments":"${args.replace(/"/g, '\\"')}"}}]}, "finish_reason":"tool_calls"}]}\n\n`
   );
   if (usage) {
     chunks.push(`data: {"usage":${JSON.stringify(usage)}}\n\n`);
@@ -588,6 +587,7 @@ function createTestService() {
     listConversations: vi.fn().mockResolvedValue([]),
     saveConversation: vi.fn().mockResolvedValue(undefined),
     saveMessages: vi.fn().mockResolvedValue(undefined),
+    updateMessage: vi.fn().mockResolvedValue(undefined),
     getAttachment: vi.fn().mockResolvedValue(null),
     saveAttachment: vi.fn().mockResolvedValue(0),
   });
@@ -699,7 +699,7 @@ describe("callLLMWithToolLoop", () => {
     expect(fetchSpy).toHaveBeenCalledTimes(2);
 
     // 工具应被执行
-    expect(mockExecutor.execute).toHaveBeenCalledWith({ city: "北京" });
+    expect(mockExecutor.execute).toHaveBeenCalledWith({ city: "北京" }, expect.any(AbortSignal));
 
     // messages 应包含 assistant(tool_call) + tool(result) + user 原始消息
     expect(messages.length).toBe(3); // user + assistant(toolCalls) + tool(result)
@@ -845,7 +845,10 @@ describe("callLLMWithToolLoop", () => {
 
     // scriptCallback 应被调用
     expect(scriptCallback).toHaveBeenCalledTimes(1);
-    expect(scriptCallback).toHaveBeenCalledWith([expect.objectContaining({ id: "call_1", name: "script_tool" })]);
+    expect(scriptCallback).toHaveBeenCalledWith(
+      [expect.objectContaining({ id: "call_1", name: "script_tool" })],
+      expect.any(AbortSignal)
+    );
 
     expect(events.find((e) => e.type === "done")).toBeDefined();
   });

src/app/service/agent/core/agent_config.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it, beforeEach } from "vitest";
+import { AgentConfigRepo, DEFAULT_CHAT_MAX_ITERATIONS } from "./agent_config";
+
+describe("AgentConfigRepo", () => {
+  let repo: AgentConfigRepo;
+
+  beforeEach(() => {
+    chrome.storage.local.clear();
+    repo = new AgentConfigRepo();
+  });
+
+  describe("getConfig", () => {
+    it("未保存过配置时应返回默认的 chatMaxIterations", async () => {
+      const config = await repo.getConfig();
+      expect(config.chatMaxIterations).toBe(DEFAULT_CHAT_MAX_ITERATIONS);
+    });
+
+    it("storage 读取异常时应返回默认配置而非抛出异常", async () => {
+      const originalGet = chrome.storage.local.get;
+      chrome.storage.local.get = () => Promise.reject(new Error("storage error"));
+      try {
+        const config = await repo.getConfig();
+        expect(config.chatMaxIterations).toBe(DEFAULT_CHAT_MAX_ITERATIONS);
+      } finally {
+        chrome.storage.local.get = originalGet;
+      }
+    });
+  });
+
+  describe("saveConfig", () => {
+    it("应持久化自定义的 chatMaxIterations 并可被重新读取", async () => {
+      await repo.saveConfig({ chatMaxIterations: 200 });
+      const config = await repo.getConfig();
+      expect(config.chatMaxIterations).toBe(200);
+    });
+
+    it("保存部分字段时应与默认配置合并而非丢失未指定字段", async () => {
+      await repo.saveConfig({ chatMaxIterations: 120 });
+      const config = await repo.getConfig();
+      expect(config).toEqual({ chatMaxIterations: 120 });
+    });
+
+    it("保存值超过上限 1000 时应截断为 1000", async () => {
+      await repo.saveConfig({ chatMaxIterations: 999999 });
+      const config = await repo.getConfig();
+      expect(config.chatMaxIterations).toBe(1000);
+    });
+
+    it("保存 0 或负数时应截断为下限 1", async () => {
+      await repo.saveConfig({ chatMaxIterations: 0 });
+      expect((await repo.getConfig()).chatMaxIterations).toBe(1);
+
+      await repo.saveConfig({ chatMaxIterations: -20 });
+      expect((await repo.getConfig()).chatMaxIterations).toBe(1);
+    });
+
+    it("保存非整数时应四舍五入", async () => {
+      await repo.saveConfig({ chatMaxIterations: 50.6 });
+      const config = await repo.getConfig();
+      expect(config.chatMaxIterations).toBe(51);
+    });
+  });
+
+  describe("边界防护 —— storage 中存在非法值（如损坏数据、devtools 直接写入、旧版本遗留值）", () => {
+    it("getConfig 读取到超出范围或非法的原始值时应归一化而非直接透传", async () => {
+      const cases: Array<[unknown, number]> = [
+        [0, 1],
+        [-5, 1],
+        [999999, 1000],
+        [NaN, DEFAULT_CHAT_MAX_ITERATIONS],
+        ["not-a-number", DEFAULT_CHAT_MAX_ITERATIONS],
+        [null, DEFAULT_CHAT_MAX_ITERATIONS],
+        [12.9, 13],
+      ];
+
+      for (const [stored, expected] of cases) {
+        await chrome.storage.local.set({ agent_general_config: { chatMaxIterations: stored } });
+        const config = await repo.getConfig();
+        expect(config.chatMaxIterations).toBe(expected);
+      }
+    });
+  });
+});

src/app/service/agent/core/agent_config.ts

@@ -0,0 +1,40 @@
+// Agent 通用设置（对话行为相关，非 Skill/Model/Search 等专项配置）
+
+export type AgentGeneralConfig = {
+  chatMaxIterations: number; // UI 对话的 tool calling 最大循环次数
+};
+
+const STORAGE_KEY = "agent_general_config";
+
+export const DEFAULT_CHAT_MAX_ITERATIONS = 50;
+export const MIN_CHAT_MAX_ITERATIONS = 1;
+export const MAX_CHAT_MAX_ITERATIONS = 1000;
+
+const DEFAULT_CONFIG: AgentGeneralConfig = {
+  chatMaxIterations: DEFAULT_CHAT_MAX_ITERATIONS,
+};
+
+// 归一化 chatMaxIterations：非法/非有限值回退默认值，其余四舍五入并截断到 [MIN, MAX]。
+// 由 repo 统一把关，防止损坏的 storage、旧版本遗留值、或绕过 Settings UI 的调用方写入越界值。
+// 同时导出供 ChatService 校验直接传入的 maxIterations（例如显式传入负数等非法值）。
+export function normalizeChatMaxIterations(value: unknown): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_CHAT_MAX_ITERATIONS;
+  return Math.min(MAX_CHAT_MAX_ITERATIONS, Math.max(MIN_CHAT_MAX_ITERATIONS, Math.round(value)));
+}
+
+export class AgentConfigRepo {
+  async getConfig(): Promise<AgentGeneralConfig> {
+    try {
+      const result = await chrome.storage.local.get(STORAGE_KEY);
+      const stored = result[STORAGE_KEY] as Partial<AgentGeneralConfig> | undefined;
+      return { chatMaxIterations: normalizeChatMaxIterations(stored?.chatMaxIterations) };
+    } catch {
+      return DEFAULT_CONFIG;
+    }
+  }
+
+  async saveConfig(config: AgentGeneralConfig): Promise<void> {
+    const normalized: AgentGeneralConfig = { chatMaxIterations: normalizeChatMaxIterations(config.chatMaxIterations) };
+    await chrome.storage.local.set({ [STORAGE_KEY]: normalized });
+  }
+}