@ai-setting/roy-agent-core 1.7.65 → 1.7.67

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

@@ -1,7 +1,7 @@
 import {
   isToolUnavailableError,
   truncateOutputInline
-} from "./roy-agent-core-es467wsz.js";
+} from "./roy-agent-core-dt104qa1.js";
 import {
   AgentRegistry
 } from "./roy-agent-core-07fvy74y.js";
@@ -68,6 +68,8 @@ import {
 
 // src/env/agent/agent-component.ts
 init_logger();
+import fs from "fs/promises";
+import path from "path";
 import { z } from "zod";
 
 // src/env/task/plugins/max-iteration-reminder-plugin.ts
@@ -600,6 +602,7 @@ class AgentComponent extends BaseComponent {
   doomLoopCaches = new Map;
   fallbackState = new Map;
   configComponent;
+  skipAbortRunningTasksOnStop = false;
   configWatcher;
   messageConverter = new SessionMessageConverter;
   _constructorConfig;
@@ -622,6 +625,7 @@ class AgentComponent extends BaseComponent {
       throw new Error("ConfigComponent is required for AgentComponent initialization");
     }
     this.configComponent = options.configComponent;
+    this.skipAbortRunningTasksOnStop = options.skipAbortRunningTasksOnStop === true;
     await this.registerConfig(options);
     await this.initRegistry(options.configComponent);
     this.setStatus("running");
@@ -794,13 +798,19 @@ class AgentComponent extends BaseComponent {
   }
   async onStop() {
     logger2.info("[AgentComponent] Stopping and cleaning up resources...");
-    for (const [name, agent] of this.agents) {
-      if (agent.status === "running" || agent.status === "idle") {
-        this.abort(name);
-        logger2.debug(`[AgentComponent] Aborted agent: ${name}`);
+    const skipAbort = this.skipAbortRunningTasksOnStop === true;
+    if (!skipAbort) {
+      for (const [name, agent] of this.agents) {
+        if (agent.status === "running" || agent.status === "idle") {
+          this.abort(name);
+          logger2.debug(`[AgentComponent] Aborted agent: ${name}`);
+        }
       }
+    } else {
+      logger2.info("[AgentComponent] skipAbortRunningTasksOnStop=true — keeping running agent runs alive");
     }
     this.abortControllers.clear();
+    this.aborted.clear();
     this.doomLoopCaches.clear();
     if (this.configWatcher) {
       this.configWatcher();
@@ -1125,6 +1135,7 @@ class AgentComponent extends BaseComponent {
       }
       let iteration = 0;
       let finalText;
+      let persistedMessageCount = historyMessageCount;
       while (iteration < agent.config.maxIterations) {
         if (hookCtx._stopped) {
           break;
@@ -1337,6 +1348,17 @@ class AgentComponent extends BaseComponent {
               this.flushPendingFakeUserMessage(hookCtx, pendingFakeUserMessage, iteration);
             }
             await this.executePluginHooks(agent, "agent:on.iteration", hookCtx);
+            if (effectiveContext.persistSession !== false) {
+              const iterNewMessages = hookCtx.messages.slice(persistedMessageCount);
+              if (iterNewMessages.length > 0) {
+                const persisted = await this.recordSessionMessages(effectiveContext.sessionId, iterNewMessages);
+                if (persisted) {
+                  persistedMessageCount = hookCtx.messages.length;
+                } else if (effectiveContext.sessionId) {
+                  logger2.warn(`[agent.component.run] Iteration ${iteration} session persist failed — ` + `keeping ${iterNewMessages.length} message(s) for the post-loop retry.`);
+                }
+              }
+            }
           }
         } catch (error) {
           logger2.error(`Iteration ${iteration} error`, { error });
@@ -1467,9 +1489,12 @@ class AgentComponent extends BaseComponent {
       if (iteration >= agent.config.maxIterations && !result.finalText) {
         result.finalText = "Maximum iterations reached.";
       }
-      const newMessages = hookCtx.messages.slice(historyMessageCount);
+      const newMessages = hookCtx.messages.slice(persistedMessageCount);
       if (effectiveContext.persistSession !== false) {
-        await this.recordSessionMessages(effectiveContext.sessionId, newMessages);
+        const finalPersisted = await this.recordSessionMessages(effectiveContext.sessionId, newMessages);
+        if (!finalPersisted && newMessages.length > 0 && effectiveContext.sessionId) {
+          logger2.error(`[agent.component.run] Final session persist FAILED — ${newMessages.length} message(s) were not written to session ${effectiveContext.sessionId}. Session history is now incomplete relative to the LLM context.`);
+        }
       } else {
         logger2.debug(`Skipping session message recording (persistSession=false, sessionId=${effectiveContext.sessionId})`);
       }
@@ -1588,12 +1613,18 @@ class AgentComponent extends BaseComponent {
       const session = await sessionComponent.get(sessionId);
       const existingSnapshot = session?.metadata?.cacheSnapshot;
       if (existingSnapshot && typeof existingSnapshot === "object" && existingSnapshot.systemPrompt) {
-        logger2.debug(`[AgentComponent._run] Reusing cacheSnapshot for session ${sessionId} (snapshotAt=${existingSnapshot.snapshotAt})`);
-        return {
-          snapshot: existingSnapshot,
-          systemPromptOverride: existingSnapshot.systemPrompt
-        };
+        const stale = await this._isMemorySnapshotStale(existingSnapshot);
+        if (stale) {
+          logger2.info(`[AgentComponent._run] cacheSnapshot for session ${sessionId} is stale (${stale}); recreating`);
+        } else {
+          logger2.debug(`[AgentComponent._run] Reusing cacheSnapshot for session ${sessionId} (snapshotAt=${existingSnapshot.snapshotAt})`);
+          return {
+            snapshot: existingSnapshot,
+            systemPromptOverride: existingSnapshot.systemPrompt
+          };
+        }
       }
+      const memoryStat = await this._collectMemoryStat();
       let resolvedSystemPrompt = initialSystemPrompt;
       if (resolvedSystemPrompt && resolvedSystemPrompt.includes("{{memory}}")) {
         try {
@@ -1612,7 +1643,8 @@ class AgentComponent extends BaseComponent {
       const snapshot = {
         systemPrompt: resolvedSystemPrompt ?? agentConfigSystemPrompt ?? "",
         additionInfo: effectiveContext.additionInfo || "",
-        snapshotAt: Date.now()
+        snapshotAt: Date.now(),
+        memoryStat
       };
       try {
         await sessionComponent.update(sessionId, {
@@ -1631,6 +1663,46 @@ class AgentComponent extends BaseComponent {
       return { snapshot: null, systemPromptOverride: undefined };
     }
   }
+  async _isMemorySnapshotStale(snapshot) {
+    const stat = snapshot.memoryStat;
+    if (!stat || typeof stat !== "object") {
+      return "no-memoryStat (legacy snapshot)";
+    }
+    const current = await this._collectMemoryStat();
+    if (current.globalMtime !== stat.globalMtime) {
+      return `global memory.md mtime changed (${stat.globalMtime} -> ${current.globalMtime})`;
+    }
+    if (current.projectMtime !== stat.projectMtime) {
+      return `project memory.md mtime changed (${stat.projectMtime} -> ${current.projectMtime})`;
+    }
+    return null;
+  }
+  async _collectMemoryStat() {
+    const empty = { globalMtime: 0, projectMtime: 0 };
+    try {
+      const memoryComponent = this.env?.getComponent?.("memory");
+      if (!memoryComponent?.getMemoryPaths || !memoryComponent.getMemoryFile) {
+        return empty;
+      }
+      const memoryFile = memoryComponent.getMemoryFile();
+      const paths = memoryComponent.getMemoryPaths();
+      const result = { globalMtime: 0, projectMtime: 0 };
+      for (const p of paths) {
+        const filePath = path.join(p.path, memoryFile);
+        try {
+          const st = await fs.stat(filePath);
+          if (p.type === "global") {
+            result.globalMtime = st.mtimeMs;
+          } else if (p.type === "project") {
+            result.projectMtime = st.mtimeMs;
+          }
+        } catch {}
+      }
+      return result;
+    } catch {
+      return empty;
+    }
+  }
   async _fallbackReplaceMemory(systemPrompt) {
     if (!systemPrompt.includes("{{memory}}"))
       return systemPrompt;
@@ -1688,8 +1760,9 @@ class AgentComponent extends BaseComponent {
       logger2.debug(`[invokeLLM] Calling LLMComponent.invoke with ${convertedMessages.length} messages`);
       const runKey = ctx._runId ?? ctx.context.sessionId ?? "default-run";
       const sticky = this.fallbackState.get(runKey);
-      const configuredFallback = this.resolveFallbackModel(ctx.context.fallbackModel);
+      const configuredFallbacks = this.resolveFallbackModels(ctx.context.fallbackModels, ctx.context.fallbackModel);
       const activeModel = sticky?.activeModel ?? ctx.context.model;
+      const pendingFallbacks = sticky ? sticky.remaining : configuredFallbacks.filter((m) => !AgentComponent.sameModel(m, activeModel));
       const invokeWithModel = (model, signal) => llm.invoke({
         messages: convertedMessages,
         tools: ctx.tools.map((t) => ({
@@ -1730,30 +1803,39 @@ class AgentComponent extends BaseComponent {
         if (ctx.context.abort?.aborted) {
           throw error;
         }
-        const alreadyDowngraded = sticky?.fallbackModel !== undefined;
-        const canFallback = !alreadyDowngraded && !!configuredFallback && !AgentComponent.sameModel(configuredFallback, activeModel) && isFallbackEligibleError(error, true);
-        if (!canFallback) {
+        if (pendingFallbacks.length === 0 || !isFallbackEligibleError(error, true)) {
           throw error;
         }
-        logger2.warn(`[invokeLLM] primary model "${activeModel ?? "(default)"}" failed with a fallback-eligible error; downgrading to fallback model "${configuredFallback}" for run ${runKey}`);
-        this.fallbackState.set(runKey, {
-          activeModel: configuredFallback,
-          fallbackModel: configuredFallback
-        });
-        const fallbackAttempt = startAttempt(configuredFallback, "LLM invocation timeout after 300s (fallback)");
-        try {
-          const result = await fallbackAttempt.promise;
-          logger2.info(`[invokeLLM] fallback model "${configuredFallback}" succeeded for run ${runKey}`);
-          return this.normalizeLLMOutput(result);
-        } catch (fallbackError) {
-          fallbackAttempt.cancel();
-          if (fallbackError instanceof ContextError) {
-            logger2.warn(`[invokeLLM] fallback model "${configuredFallback}" hit a context limit; re-throwing ContextError so the compaction pipeline can handle it`);
-            throw fallbackError;
+        for (let i = 0;i < pendingFallbacks.length; i++) {
+          const fallbackModel = pendingFallbacks[i];
+          const remaining = pendingFallbacks.slice(i + 1);
+          logger2.warn(`[invokeLLM] model "${activeModel ?? "(default)"}" failed with a fallback-eligible error; downgrading to fallback model "${fallbackModel}" (${i + 1}/${pendingFallbacks.length}) for run ${runKey}`);
+          this.fallbackState.set(runKey, {
+            activeModel: fallbackModel,
+            remaining
+          });
+          const fallbackAttempt = startAttempt(fallbackModel, "LLM invocation timeout after 300s (fallback)");
+          try {
+            const result = await fallbackAttempt.promise;
+            logger2.info(`[invokeLLM] fallback model "${fallbackModel}" succeeded for run ${runKey}`);
+            return this.normalizeLLMOutput(result);
+          } catch (fallbackError) {
+            fallbackAttempt.cancel();
+            if (fallbackError instanceof ContextError) {
+              logger2.warn(`[invokeLLM] fallback model "${fallbackModel}" hit a context limit; re-throwing ContextError so the compaction pipeline can handle it`);
+              throw fallbackError;
+            }
+            if (ctx.context.abort?.aborted) {
+              throw error;
+            }
+            logger2.error(`[invokeLLM] fallback model "${fallbackModel}" also failed; ` + (remaining.length > 0 ? `trying next fallback model "${remaining[0]}"` : `no more fallback models left; re-throwing the ORIGINAL primary error`), fallbackError);
+            if (remaining.length === 0) {
+              this.fallbackState.delete(runKey);
+              throw error;
+            }
           }
-          logger2.error(`[invokeLLM] fallback model "${configuredFallback}" also failed; re-throwing the ORIGINAL primary error`, fallbackError);
-          throw error;
         }
+        throw error;
       }
     }
     logger2.warn("[invokeLLM] No LLMComponent available, using mock");
@@ -1762,24 +1844,51 @@ class AgentComponent extends BaseComponent {
       finishReason: "stop"
     };
   }
-  resolveFallbackModel(explicit) {
+  resolveFallbackModels(explicitList, explicitSingle) {
     const readConfig = (key) => {
-      const raw2 = this.configComponent?.get?.(key);
-      if (typeof raw2 !== "string")
+      const raw = this.configComponent?.get?.(key);
+      if (typeof raw !== "string")
         return;
-      const trimmed = raw2.trim();
+      const trimmed = raw.trim();
       return trimmed ? trimmed : undefined;
     };
-    const raw = explicit?.trim() || readConfig("llm.fallbackModel");
-    if (!raw)
-      return;
-    const parsed = parseFallbackModel(raw);
-    if (!parsed?.modelId)
-      return;
-    if (parsed.providerId)
-      return `${parsed.providerId}/${parsed.modelId}`;
-    const provider = readConfig("llm.fallbackProvider");
-    return provider ? `${provider}/${parsed.modelId}` : parsed.modelId;
+    const normalize = (raw) => {
+      const trimmed = raw.trim();
+      if (!trimmed)
+        return;
+      const parsed = parseFallbackModel(trimmed);
+      if (!parsed?.modelId)
+        return;
+      if (parsed.providerId)
+        return `${parsed.providerId}/${parsed.modelId}`;
+      const provider = readConfig("llm.fallbackProvider");
+      return provider ? `${provider}/${parsed.modelId}` : parsed.modelId;
+    };
+    if (Array.isArray(explicitList)) {
+      const normalized = AgentComponent.dedupeModels(explicitList.map((m) => typeof m === "string" ? normalize(m) : undefined).filter((m) => !!m));
+      return normalized;
+    }
+    if (explicitSingle?.trim()) {
+      const normalized = normalize(explicitSingle);
+      return normalized ? [normalized] : [];
+    }
+    const configuredList = this.configComponent?.get?.("llm.fallbackModels");
+    const configuredItems = Array.isArray(configuredList) ? configuredList : typeof configuredList === "string" ? configuredList.split(",") : [];
+    if (configuredItems.length > 0) {
+      const normalized = AgentComponent.dedupeModels(configuredItems.map((m) => typeof m === "string" ? normalize(m) : undefined).filter((m) => !!m));
+      if (normalized.length > 0)
+        return normalized;
+    }
+    const legacy = readConfig("llm.fallbackModel");
+    if (legacy) {
+      const normalized = normalize(legacy);
+      if (normalized)
+        return [normalized];
+    }
+    return [];
+  }
+  static dedupeModels(models) {
+    return Array.from(new Set(models));
   }
   static sameModel(a, b) {
     const norm = (value) => {
@@ -1857,13 +1966,18 @@ class AgentComponent extends BaseComponent {
         },
         sessionId: toolEventSessionId
       });
-      const effectiveRunModel = this.fallbackState.get(ctx._runId ?? ctx.context.sessionId ?? "default-run")?.activeModel ?? ctx.context.model;
+      const runKey = ctx._runId ?? ctx.context.sessionId ?? "default-run";
+      const runFallbackState = this.fallbackState.get(runKey);
+      const effectiveRunModel = runFallbackState?.activeModel ?? ctx.context.model;
+      const effectiveFallbackModels = runFallbackState ? runFallbackState.remaining : this.resolveFallbackModels(ctx.context.fallbackModels, ctx.context.fallbackModel);
+      const fallbackExplicitlySet = Array.isArray(ctx.context.fallbackModels) || ctx.context.fallbackModel !== undefined;
       const toolContext = {
         session_id: ctx.context.sessionId,
         message_id: ctx.context.messageId,
         abort: ctx.context.abort,
         model: effectiveRunModel,
         fallbackModel: ctx.context.fallbackModel,
+        ...effectiveFallbackModels.length > 0 ? { fallbackModels: effectiveFallbackModels } : fallbackExplicitlySet ? { fallbackModels: [] } : {},
         workdir: ctx.context.metadata?.workdir,
         metadata: ctx.context.metadata
       };
@@ -2011,14 +2125,14 @@ class AgentComponent extends BaseComponent {
   }
   async recordSessionMessages(sessionId, allMessages = []) {
     if (!sessionId) {
-      return;
+      return false;
     }
     let filtered;
     try {
       const sessionComponent = this.env.getComponent("session");
       if (!sessionComponent) {
         logger2.warn("SessionComponent not found, skipping session recording");
-        return;
+        return false;
       }
       filtered = [];
       for (const msg of allMessages) {
@@ -2036,9 +2150,10 @@ class AgentComponent extends BaseComponent {
         filtered.push(this.messageConverter.fromModelMessage(msg, { sessionID: sessionId }));
       }
       if (filtered.length === 0) {
-        return;
+        return true;
       }
       await sessionComponent.addMessages(sessionId, filtered);
+      return true;
     } catch (err) {
       const kind = err && typeof err === "object" && "kind" in err ? err.kind : undefined;
       if (kind === "lock_exhausted") {
@@ -2046,6 +2161,7 @@ class AgentComponent extends BaseComponent {
       } else {
         logger2.error(`[recordSessionMessages] Failed to record session messages for ${sessionId}: ${err}`);
       }
+      return false;
     }
   }
   isEmptyMessage(content) {