@ai-setting/roy-agent-core 1.7.70 → 1.7.72

package/dist/shared/@ai-setting/{roy-agent-core-9bshyqjn.js → roy-agent-core-pakhchy7.js}

@@ -1,11 +1,7 @@
 import {
   MemorySessionStore,
   SQLiteSessionStore
-} from "./roy-agent-core-hy3zn2q2.js";
-import {
-  init_loose_json,
-  tryParseJsonFromText
-} from "./roy-agent-core-ze068vc9.js";
+} from "./roy-agent-core-sm0sf6sb.js";
 import {
   init_search_query_parser,
   matchesQuery,
@@ -47,7 +43,8 @@ var SESSION_DEFAULTS = {
   "session.storage.dbPath": undefined,
   "session.checkpoint.enabled": false,
   "session.contextLimit": 1e5,
-  "session.maxSessions": 100
+  "session.maxSessions": 100,
+  "session.compactModel": undefined
 };
 var SESSION_CONFIG_REGISTRATION = {
   name: "session",
@@ -64,56 +61,108 @@ var SESSION_CONFIG_REGISTRATION = {
     { key: "session.storage.dbPath", sources: ["env", "file"] },
     { key: "session.checkpoint.enabled", sources: ["env", "file"] },
     { key: "session.contextLimit", sources: ["env", "file"] },
-    { key: "session.maxSessions", sources: ["env", "file"] }
+    { key: "session.maxSessions", sources: ["env", "file"] },
+    { key: "session.compactModel", sources: ["env", "file"] }
   ]
 };
 
 // src/env/session/session-component.ts
 init_search_query_parser();
-init_loose_json();
 import path from "path";
-import { z } from "zod";
-var logger = createLogger("session");
-function normalizeAgentCheckpoint(data) {
-  return {
-    title: data.title || "Untitled Checkpoint",
-    processKeyPoints: data.processKeyPoints || [],
-    currentState: data.currentState || "",
-    nextSteps: data.nextSteps || [],
-    userIntents: data.userIntents || [],
-    rawResponse: JSON.stringify(data)
-  };
-}
+
+// src/env/session/compact-checkpoint-content.ts
 var DEGRADED_TEXT_SENTINELS = new Set([
-  "[hint extraction failed]"
+  "[hint extraction failed]",
+  "maximum iterations reached",
+  "no usable checkpoint output"
 ]);
-function isUsableCheckpointText(text) {
+var MIN_CONTENT_LENGTH = 20;
+function normalizeCheckpointContent(text) {
   const raw = (text ?? "").trim();
   if (!raw)
-    return false;
-  return !DEGRADED_TEXT_SENTINELS.has(raw.toLowerCase());
+    return;
+  if (DEGRADED_TEXT_SENTINELS.has(raw.toLowerCase()))
+    return;
+  if (raw.length < MIN_CONTENT_LENGTH)
+    return;
+  return raw;
 }
-function buildCheckpointFromFinalText(finalText) {
-  if (!isUsableCheckpointText(finalText))
+function buildCheckpointFromText(text) {
+  const content = normalizeCheckpointContent(text);
+  if (!content)
     return;
-  const raw = finalText.trim();
-  const parsed = tryParseJsonFromText(raw);
-  if (parsed && (parsed.title || parsed.currentState || parsed.processKeyPoints)) {
-    return normalizeAgentCheckpoint(parsed);
-  }
-  const lines = raw.split(`
+  const lines = content.split(`
 `).map((l) => l.trim()).filter(Boolean);
   const heading = lines.find((l) => /^#{1,6}\s+/.test(l)) ?? lines[0] ?? "";
   const title = heading.replace(/^#{1,6}\s+/, "").replace(/^[*_`\s]+|[*_`\s]+$/g, "").slice(0, 80);
   return {
     title: title || "Untitled Checkpoint",
-    processKeyPoints: [],
-    currentState: raw,
-    nextSteps: [],
-    userIntents: [],
-    rawResponse: raw
+    content
+  };
+}
+function isModernCheckpoint(cp) {
+  return typeof cp.content === "string" && (cp.content ?? "").trim().length > 0;
+}
+function adaptLegacyCheckpoint(cp) {
+  if (isModernCheckpoint(cp))
+    return cp;
+  const legacy = cp;
+  const sections = [];
+  const summary = (legacy.summary ?? "").trim();
+  if (summary)
+    sections.push(summary);
+  const points = legacy.processKeyPoints ?? [];
+  if (points.length) {
+    sections.push(points.map((p, i) => `${i + 1}. ${p}`).join(`
+`));
+  }
+  const state = (legacy.currentState ?? "").trim();
+  if (state)
+    sections.push(state);
+  const steps = legacy.nextSteps ?? [];
+  if (steps.length) {
+    sections.push(steps.map((s, i) => `${i + 1}. ${s}`).join(`
+`));
+  }
+  const intents = legacy.userIntents ?? [];
+  if (intents.length) {
+    sections.push(intents.map((u, i) => `${i + 1}. ${u}`).join(`
+`));
+  }
+  let content = sections.join(`
+
+`).trim();
+  if (!content)
+    content = cp.title ?? "";
+  if (!normalizeCheckpointContent(content)) {
+    content = cp.id ? `Checkpoint ${cp.id}` : "";
+  }
+  return {
+    id: cp.id,
+    messageIndex: cp.messageIndex,
+    title: cp.title,
+    content,
+    messageCountBefore: cp.messageCountBefore,
+    createdAt: cp.createdAt,
+    type: cp.type,
+    ...cp.recentMessages ? { recentMessages: cp.recentMessages } : {}
   };
 }
+function createCheckpointContent(checkpoint) {
+  const adapted = adaptLegacyCheckpoint(checkpoint);
+  const lines = [
+    `# Checkpoint: ${checkpoint.title}`,
+    "",
+    adapted.content,
+    "",
+    `${checkpoint.messageCountBefore} messages compacted at ${new Date(checkpoint.createdAt).toISOString()}`
+  ];
+  return lines.join(`
+`);
+}
+
+// src/env/session/session-component.ts
+var logger = createLogger("session");
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -612,6 +661,10 @@ class SessionComponent extends BaseComponent {
     const date = new Date().toISOString().replace("T", " ").substring(0, 19);
     return template.replace("{date}", date);
   }
+  getCompactModel() {
+    const model = this.configComponent?.get("session.compactModel");
+    return typeof model === "string" && model.trim() ? model.trim() : undefined;
+  }
   async generateCompactHint(sessionId) {
     const session = await this.get(sessionId);
     if (!session) {
@@ -626,29 +679,14 @@ class SessionComponent extends BaseComponent {
       return "";
     }
     const agentComponent = this.env.getComponent("agent");
-    let hintData;
-    const submitTool = {
-      name: "workflow_submit_output",
-      description: "Submit the final result. Call this with your guidance_prompt.",
-      parameters: z.object({
-        guidance_prompt: z.string().describe("The compact guidance prompt (3-4 sentences)")
-      }),
-      execute: async (args) => {
-        const parsed = z.object({
-          guidance_prompt: z.string()
-        }).parse(args);
-        hintData = parsed;
-        return { success: true, output: "OK" };
-      }
-    };
-    await agentComponent.run("compact-hint", "Analyze this conversation and generate a compact guidance prompt for checkpoint generation.", {
+    const hintRun = await agentComponent.run("compact-hint", "Analyze this conversation and generate a compact guidance prompt for checkpoint generation.", {
       sessionId,
       persistSession: false,
-      extraTools: [submitTool]
+      model: this.getCompactModel()
     });
-    const hint = hintData?.guidance_prompt || "";
+    const hint = normalizeCheckpointContent(hintRun?.finalText) ?? "";
     if (!hint) {
-      logger.warn("[SessionComponent] Compact hint unavailable (compact-hint did not submit) — returning empty hint", { sessionId });
+      logger.warn("[SessionComponent] Compact hint unavailable (no usable finalText) — returning empty hint", { sessionId });
     }
     logger.info("[SessionComponent] Compact hint generated", {
       sessionId,
@@ -670,53 +708,36 @@ class SessionComponent extends BaseComponent {
     }
     const recentMessages = this.extractRecentMessages(messages, 2);
     await this.executeBeforeHooks("compact", { session, options });
-    let summaryResult;
+    let checkpointText;
     try {
-      const userQuery = options?.scenarioHint ? options.scenarioHint : "Generate a checkpoint from this conversation.";
-      let checkpointData;
-      const submitTool = {
-        name: "workflow_submit_output",
-        description: "Submit the checkpoint result with title, processKeyPoints, currentState, nextSteps, userIntents.",
-        parameters: z.object({
-          title: z.string().describe("Brief checkpoint title (max 30 chars)"),
-          processKeyPoints: z.array(z.string()).describe("Key discoveries or decisions"),
-          currentState: z.string().describe("Current progress and status"),
-          nextSteps: z.array(z.string()).describe("Follow-up items"),
-          userIntents: z.array(z.string()).describe("User's core intents (2-5 items)")
-        }),
-        execute: async (args) => {
-          const parsed = z.object({
-            title: z.string(),
-            processKeyPoints: z.array(z.string()),
-            currentState: z.string(),
-            nextSteps: z.array(z.string()),
-            userIntents: z.array(z.string())
-          }).parse(args);
-          checkpointData = parsed;
-          return { success: true, output: "OK" };
-        }
-      };
+      const userQuery = options?.scenarioHint ? [
+        "Generate a checkpoint from this conversation.",
+        "",
+        "Scenario hint (focus points from phase 1):",
+        options.scenarioHint
+      ].join(`
+`) : "Generate a checkpoint from this conversation.";
       const agentComponent = this.env.getComponent("agent");
       const runResult = await agentComponent.run("compact", userQuery, {
         sessionId,
         persistSession: false,
-        extraTools: [submitTool]
+        model: this.getCompactModel()
       });
-      const data = checkpointData;
-      if (data) {
-        summaryResult = normalizeAgentCheckpoint(data);
+      const fromText = buildCheckpointFromText(runResult?.finalText);
+      const fromHint = fromText ? undefined : buildCheckpointFromText(options?.scenarioHint);
+      const built = fromText ?? fromHint;
+      if (!built) {
+        throw new Error(`compact agent returned no usable checkpoint output ` + `(no usable finalText or scenarioHint); ` + `refusing to archive ${messages.length} messages for session ${sessionId}`);
+      }
+      if (fromText) {
+        logger.info("[SessionComponent] compact agent produced natural-language checkpoint", {
+          sessionId,
+          contentLength: built.content.length
+        });
       } else {
-        const fallback = buildCheckpointFromFinalText(runResult?.finalText) ?? buildCheckpointFromFinalText(options?.scenarioHint);
-        if (!fallback) {
-          throw new Error(`compact agent returned no usable checkpoint output ` + `(no workflow_submit_output call, no usable finalText or scenarioHint); ` + `refusing to archive ${messages.length} messages for session ${sessionId}`);
-        }
-        if (runResult?.finalText?.trim()) {
-          logger.warn(`[SessionComponent] compact agent did not call workflow_submit_output; ` + `falling back to its finalText for the checkpoint (session=${sessionId}, ` + `finalTextLength=${runResult.finalText.length})`);
-        } else {
-          logger.warn(`[SessionComponent] compact agent produced neither a tool call nor text; ` + `falling back to scenarioHint for the checkpoint (session=${sessionId})`);
-        }
-        summaryResult = fallback;
+        logger.warn(`[SessionComponent] compact agent produced no usable text; ` + `falling back to scenarioHint for the checkpoint (session=${sessionId})`);
       }
+      checkpointText = built;
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       logger.error(`[SessionComponent] Compact agent failed: ${errorMessage}`);
@@ -726,16 +747,8 @@ class SessionComponent extends BaseComponent {
     const checkpoint = {
       id: checkpointId,
       messageIndex: startIndex,
-      title: summaryResult.title,
-      summary: [
-        `Process: ${summaryResult.processKeyPoints.join("; ")}`,
-        `State: ${summaryResult.currentState}`
-      ].join(`
-`),
-      processKeyPoints: summaryResult.processKeyPoints,
-      currentState: summaryResult.currentState,
-      nextSteps: summaryResult.nextSteps,
-      userIntents: summaryResult.userIntents,
+      title: checkpointText.title,
+      content: checkpointText.content,
       messageCountBefore: messages.length,
       createdAt: Date.now(),
       type: "compact",
@@ -833,10 +846,68 @@ class SessionComponent extends BaseComponent {
     };
   }
   async getCheckpoints(sessionId) {
-    return await this.store.getCheckpoints(sessionId);
+    const checkpoints = await this.store.getCheckpoints(sessionId);
+    return checkpoints.map((cp) => adaptLegacyCheckpoint(cp));
   }
   async getCheckpoint(sessionId, checkpointId) {
-    return await this.store.getCheckpoint(sessionId, checkpointId);
+    const cp = await this.store.getCheckpoint(sessionId, checkpointId);
+    return cp ? adaptLegacyCheckpoint(cp) : undefined;
+  }
+  async readStoredCheckpointsRaw(sessionId) {
+    return await this.store.getCheckpoints(sessionId);
+  }
+  async adaptStoredCheckpoints(sessionId, options) {
+    const apply = options?.apply === true;
+    const raw = await this.store.getCheckpoints(sessionId);
+    const report = {
+      sessionId,
+      total: raw.length,
+      legacy: 0,
+      modern: 0,
+      applied: 0,
+      samples: []
+    };
+    const adapted = [];
+    for (const cp of raw) {
+      const o = cp;
+      const hasContent = typeof o.content === "string" && o.content.trim().length > 0;
+      if (hasContent) {
+        report.modern++;
+        adapted.push(cp);
+        continue;
+      }
+      report.legacy++;
+      const fixed = adaptLegacyCheckpoint(cp);
+      adapted.push(fixed);
+      if (report.samples.length < 3) {
+        report.samples.push({
+          id: cp.id,
+          title: cp.title,
+          contentLength: fixed.content.length,
+          contentPreview: fixed.content.slice(0, 200)
+        });
+      }
+    }
+    if (apply && report.legacy > 0) {
+      await this.writeCheckpointsBack(sessionId, adapted);
+      report.applied = report.legacy;
+    }
+    logger.info("[SessionComponent] adaptStoredCheckpoints", {
+      sessionId,
+      total: report.total,
+      legacy: report.legacy,
+      modern: report.modern,
+      applied: report.applied,
+      dryRun: !apply
+    });
+    return report;
+  }
+  async writeCheckpointsBack(sessionId, checkpoints) {
+    const store = this.store;
+    if (typeof store.replaceCheckpointDetails !== "function") {
+      throw new Error("adaptStoredCheckpoints: current store does not support replaceCheckpointDetails " + "(only SQLiteSessionStore does); refusing to write partial data");
+    }
+    await store.replaceCheckpointDetails(sessionId, checkpoints);
   }
   async deleteCheckpoint(sessionId, checkpointId) {
     await this.executeBeforeHooks("deleteCheckpoint", { sessionId, checkpointId });
@@ -870,7 +941,7 @@ class SessionComponent extends BaseComponent {
     } else {
       const latestCheckpointId = session.metadata?.checkpoints?.latestCheckpointId;
       if (latestCheckpointId) {
-        startCheckpoint = await this.store.getCheckpoint(sessionId, latestCheckpointId);
+        startCheckpoint = await this.getCheckpoint(sessionId, latestCheckpointId);
         if (startCheckpoint) {
           const MAX_SAFE_MESSAGES = Number.MAX_SAFE_INTEGER;
           contextMessages = await this.store.getMessages(sessionId, startCheckpoint.messageIndex, MAX_SAFE_MESSAGES, { includeArchived: false });
@@ -898,7 +969,7 @@ class SessionComponent extends BaseComponent {
     if (options?.messageLimit) {
       contextMessages = contextMessages.slice(-options.messageLimit);
     }
-    const checkpoints = contextMessages.filter((m) => m.metadata?.isCheckpoint).map((m) => m.metadata.checkpointMeta);
+    const checkpoints = contextMessages.filter((m) => m.metadata?.isCheckpoint && m.metadata?.checkpointMeta).map((m) => adaptLegacyCheckpoint(m.metadata.checkpointMeta));
     const estimatedTokens = contextMessages.reduce((sum, m) => sum + m.content.length * 0.25, 0);
     return {
       session,
@@ -997,28 +1068,11 @@ class SessionComponent extends BaseComponent {
     const latestId = session.metadata?.checkpoints?.latestCheckpointId;
     if (!latestId)
       return;
-    return session.metadata?.checkpointDetails?.[latestId];
+    const raw = session.metadata?.checkpointDetails?.[latestId];
+    return raw ? adaptLegacyCheckpoint(raw) : undefined;
   }
   createCheckpointMessage(checkpoint) {
-    const lines = [
-      `# Checkpoint: ${checkpoint.title}`,
-      "",
-      "## Process Key Points",
-      ...checkpoint.processKeyPoints.map((p, i) => `${i + 1}. ${p}`),
-      "",
-      "## Current State",
-      checkpoint.currentState,
-      ""
-    ];
-    if (checkpoint.nextSteps?.length) {
-      lines.push("## Next Steps");
-      checkpoint.nextSteps.forEach((s, i) => lines.push(`${i + 1}. ${s}`));
-      lines.push("");
-    }
-    lines.push("## Messages Compacted");
-    lines.push(`${checkpoint.messageCountBefore} messages compacted at ${new Date(checkpoint.createdAt).toISOString()}`);
-    const content = lines.join(`
-`);
+    const content = createCheckpointContent(checkpoint);
     return {
       role: "user",
       content,
@@ -1027,9 +1081,6 @@ class SessionComponent extends BaseComponent {
         checkpointId: checkpoint.id,
         content,
         title: checkpoint.title,
-        processKeyPoints: checkpoint.processKeyPoints,
-        currentState: checkpoint.currentState,
-        nextSteps: checkpoint.nextSteps,
         messageCountBefore: checkpoint.messageCountBefore,
         createdAt: checkpoint.createdAt
       }],

package/dist/shared/@ai-setting/{roy-agent-core-02j24hrg.js → roy-agent-core-rxb00gjm.js}

@@ -241,7 +241,7 @@ var LLMConfigSchema = z.object({
   defaultModel: z.string().optional(),
   providers: z.record(z.string(), ProviderConfigSchema),
   defaultProvider: z.string(),
-  temperature: z.number().min(0).max(2).default(0.7),
+  temperature: z.number().min(0).max(2).optional(),
   maxTokens: z.number().int().positive().optional(),
   topP: z.number().min(0).max(1).optional(),
   stream: z.boolean().default(true),
@@ -627,6 +627,58 @@ import { randomUUID } from "crypto";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
+
+// src/env/llm/temperature-policy.ts
+var FIXED_TEMPERATURE_ENDPOINTS = [
+  {
+    id: "kimi-for-coding",
+    baseURLIncludes: "api.kimi.com/coding",
+    providerIds: ["kimi-coding"],
+    temperature: 1,
+    reason: "Kimi For Coding 端点（api.kimi.com/coding）对所有它服务的模型都只接受 temperature=1 或不传；" + "发 0.7 会 400 invalid temperature（Task #4946 实测 6 个模型全覆盖）"
+  }
+];
+function findFixedTemperatureRule(input) {
+  const { providerId, baseURL } = input;
+  if (baseURL) {
+    const normalized = baseURL.toLowerCase();
+    for (const rule of FIXED_TEMPERATURE_ENDPOINTS) {
+      if (normalized.includes(rule.baseURLIncludes.toLowerCase()))
+        return rule;
+    }
+    return;
+  }
+  if (providerId) {
+    for (const rule of FIXED_TEMPERATURE_ENDPOINTS) {
+      if (rule.providerIds?.includes(providerId))
+        return rule;
+    }
+  }
+  return;
+}
+var DEFAULT_TEMPERATURE = 0.7;
+function toNumberOrUndefined(value) {
+  if (typeof value === "number")
+    return Number.isFinite(value) ? value : undefined;
+  if (typeof value === "string" && value.trim() !== "") {
+    const n = Number(value);
+    return Number.isFinite(n) ? n : undefined;
+  }
+  return;
+}
+function resolveTemperature(input) {
+  const base = toNumberOrUndefined(input.requestTemperature) ?? toNumberOrUndefined(input.globalTemperature) ?? toNumberOrUndefined(input.providerTemperature) ?? DEFAULT_TEMPERATURE;
+  const rule = findFixedTemperatureRule({
+    providerId: input.providerId,
+    baseURL: input.baseURL
+  });
+  if (rule) {
+    return { temperature: rule.temperature, clampedBy: rule };
+  }
+  return { temperature: base };
+}
+
+// src/env/llm/llm.ts
 var logger = createLogger("llm");
 function normalizeUsage(usage) {
   if (!usage)
@@ -886,7 +938,7 @@ class LLMComponent extends BaseComponent {
   resolveRequest(request) {
     const defaultModel = this.getLLMConfig("llm.defaultModel", "gpt-4o");
     const defaultProvider = this.getLLMConfig("llm.defaultProvider", "openai");
-    const defaultTemperature = this.getLLMConfig("llm.temperature", 0.7);
+    const configuredGlobalTemperature = this.getLLMConfig("llm.temperature");
     const defaultMaxTokens = this.getLLMConfig("llm.maxTokens", 4096);
     const defaultTopP = this.getLLMConfig("llm.topP", 1);
     const rawModel = request.model || defaultModel;
@@ -915,6 +967,21 @@ class LLMComponent extends BaseComponent {
     const capabilities = provider?.capabilities;
     const thinkingInText = capabilities?.thinkingInText;
     const effectiveThinkingInText = thinkingInText !== undefined ? thinkingInText : undefined;
+    const temperatureResolution = resolveTemperature({
+      requestTemperature: request.temperature,
+      globalTemperature: configuredGlobalTemperature,
+      providerTemperature: provider?.temperature,
+      providerId,
+      baseURL: provider?.baseURL
+    });
+    if (temperatureResolution.clampedBy) {
+      logger.debug(`[LLMComponent] temperature 被端点硬约束钳制：${providerId} → ${temperatureResolution.temperature}`, {
+        provider: providerId,
+        requested: request.temperature ?? configuredGlobalTemperature ?? provider?.temperature,
+        forced: temperatureResolution.clampedBy.temperature,
+        reason: temperatureResolution.clampedBy.reason
+      });
+    }
     return {
       providerId,
       model,
@@ -934,7 +1001,7 @@ class LLMComponent extends BaseComponent {
         } : {}
       },
       messages,
-      temperature: request.temperature ?? defaultTemperature,
+      temperature: temperatureResolution.temperature,
       maxTokens: request.maxTokens ?? defaultMaxTokens,
       topP: request.topP ?? defaultTopP,
       abortSignal: request.abortSignal

package/dist/shared/@ai-setting/{roy-agent-core-8cx7cfdg.js → roy-agent-core-skyc30qx.js}

@@ -1,9 +1,8 @@
 import {
   AgentComponentAdapter,
   init_agent_component_adapter
-} from "./roy-agent-core-002g6nfk.js";
+} from "./roy-agent-core-attpry6g.js";
 import"./roy-agent-core-1db4vpc6.js";
-import"./roy-agent-core-ze068vc9.js";
 import"./roy-agent-core-e25xkv53.js";
 import"./roy-agent-core-cpcd24n2.js";
 import"./roy-agent-core-qqaak24r.js";

package/dist/shared/@ai-setting/{roy-agent-core-hy3zn2q2.js → roy-agent-core-sm0sf6sb.js}

@@ -1042,6 +1042,26 @@ class SQLiteSessionStore extends BaseSessionStore {
       return [];
     return Object.values(checkpointDetails);
   }
+  async replaceCheckpointDetails(sessionId, checkpoints) {
+    await this.initialize();
+    const session = await this.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const meta = session.metadata || {};
+    const details = meta.checkpointDetails || {};
+    for (const cp of checkpoints) {
+      details[cp.id] = cp;
+    }
+    meta.checkpointDetails = details;
+    session.metadata = meta;
+    session.updatedAt = Date.now();
+    this.db.prepare("UPDATE session SET metadata = ?, updated_at = ? WHERE id = ?").run(JSON.stringify(session.metadata), session.updatedAt, sessionId);
+    this.checkpointsCache.set(sessionId, Object.values(details));
+    this.sessionsCache.set(sessionId, session);
+    logger.info(`[SQLiteSessionStore] replaceCheckpointDetails: wrote ${checkpoints.length} checkpoint(s) for ${sessionId}`);
+    return true;
+  }
   async getCheckpoint(sessionId, checkpointId) {
     await this.initialize();
     const checkpoints = await this.getCheckpoints(sessionId);

package/dist/shared/@ai-setting/{roy-agent-core-mw2cen6s.js → roy-agent-core-vah6g5yx.js}

@@ -7,7 +7,7 @@ import {
 import {
   AgentComponentAdapter,
   init_agent_component_adapter
-} from "./roy-agent-core-002g6nfk.js";
+} from "./roy-agent-core-attpry6g.js";
 import {
   PythonCallNode,
   SkillNode,

package/dist/shared/@ai-setting/{roy-agent-core-07fvy74y.js → roy-agent-core-vm8h5zyj.js}

@@ -270,34 +270,48 @@ class AgentRegistry {
   }
   registerCompactAgent() {
     const name = "compact";
-    if (this.agents.has(name))
-      return;
     const agent = {
       name,
       type: "sub",
       description: "压缩子智能体 — 从父 session 的历史消息中提取结构化 checkpoint JSON",
       systemPromptRef: "compact",
-      allowedTools: ["workflow_submit_output"],
+      allowedTools: [],
       deniedTools: [],
       maxIterations: 3,
       filterHistory: false
     };
+    const existing = this.agents.get(name);
+    if (existing) {
+      this.agents.set(name, {
+        ...agent,
+        description: existing.description ?? agent.description
+      });
+      logger.info(`[AgentRegistry] Built-in compact agent overrode user-level definition ` + `(tool whitelist enforced: allowedTools=[])`);
+      return;
+    }
     this.agents.set(name, agent);
   }
   registerCompactHintAgent() {
     const name = "compact-hint";
-    if (this.agents.has(name))
-      return;
     const agent = {
       name,
       type: "sub",
       description: "压缩提示子智能体 — 分析父 session 历史，生成场景化压缩指导提示",
       systemPromptRef: "compact-hint",
-      allowedTools: ["workflow_submit_output"],
+      allowedTools: [],
       deniedTools: [],
       maxIterations: 3,
       filterHistory: false
     };
+    const existing = this.agents.get(name);
+    if (existing) {
+      this.agents.set(name, {
+        ...agent,
+        description: existing.description ?? agent.description
+      });
+      logger.info(`[AgentRegistry] Built-in compact-hint agent overrode user-level definition ` + `(tool whitelist enforced: allowedTools=[])`);
+      return;
+    }
     this.agents.set(name, agent);
   }
   registerRoyAgent() {

package/dist/shared/@ai-setting/{roy-agent-core-x3xpkx84.js → roy-agent-core-wr7mv7k3.js}

@@ -1,6 +1,6 @@
 import {
   builtInHandlers
-} from "./roy-agent-core-npvejsg8.js";
+} from "./roy-agent-core-y12kyxwa.js";
 import {
   envKeyToConfigKey
 } from "./roy-agent-core-7hh0brvs.js";