@ai-setting/roy-agent-core 1.6.42 → 1.7.1

package/dist/shared/@ai-setting/{roy-agent-core-fzyn4fxx.js → roy-agent-core-3dwcwgn5.js}

@@ -1,6 +1,3 @@
-import {
-  withTimeout
-} from "./roy-agent-core-c1stgqnw.js";
 import {
   truncateOutputInline
 } from "./roy-agent-core-h28gcd77.js";
@@ -22,10 +19,11 @@ import {
 } from "./roy-agent-core-ctdhjv68.js";
 import {
   SessionMessageConverter
-} from "./roy-agent-core-1k9j90s7.js";
+} from "./roy-agent-core-zcx8nf4a.js";
 import {
-  safeParseToolArgs
-} from "./roy-agent-core-12gac5zn.js";
+  safeParseToolArgs,
+  withTimeout
+} from "./roy-agent-core-2xb3f3ye.js";
 import {
   envKeyToConfigKey
 } from "./roy-agent-core-7hh0brvs.js";
@@ -810,20 +808,6 @@ class AgentComponent extends BaseComponent {
         const workspaceDir = this.env?.getComponent?.("config")?.get?.("workspace_dir") || process.cwd();
         resolvedSystemPrompt = resolvedSystemPrompt.replaceAll("{{workspace_dir}}", String(workspaceDir));
       }
-      if (resolvedSystemPrompt.includes("{{memory}}")) {
-        try {
-          const memoryComponent = this.env?.getComponent?.("memory");
-          if (memoryComponent && typeof memoryComponent.recallMemory === "function") {
-            const memoryContent = await memoryComponent.recallMemory();
-            resolvedSystemPrompt = resolvedSystemPrompt.replaceAll("{{memory}}", memoryContent || "(No memory)");
-          } else {
-            resolvedSystemPrompt = resolvedSystemPrompt.replaceAll("{{memory}}", "(Memory component not available)");
-          }
-        } catch (err) {
-          logger2.warn(`[AgentComponent._run] Failed to replace {{memory}}: ${err}`);
-          resolvedSystemPrompt = resolvedSystemPrompt.replaceAll("{{memory}}", "(Failed to load memory)");
-        }
-      }
     }
     const effectiveContext = {
       ...context,
@@ -846,6 +830,12 @@ class AgentComponent extends BaseComponent {
         resolvedSystemPrompt = eventSourceSystemPrompt;
       }
     }
+    const { snapshot: cacheSnapshot, systemPromptOverride } = await this._loadOrCreateCacheSnapshot(effectiveContext.sessionId, effectiveContext, resolvedSystemPrompt, agent.config.systemPrompt);
+    if (systemPromptOverride !== undefined) {
+      resolvedSystemPrompt = systemPromptOverride;
+    } else if (resolvedSystemPrompt) {
+      resolvedSystemPrompt = await this._fallbackReplaceMemory(resolvedSystemPrompt);
+    }
     const hookCtx = {
       agent,
       iteration: 0,
@@ -853,7 +843,8 @@ class AgentComponent extends BaseComponent {
       messages: [],
       tools: this.getAvailableTools(agent, effectiveContext),
       systemPrompt: resolvedSystemPrompt ?? agent.config.systemPrompt ?? "You are a helpful assistant.",
-      context: effectiveContext
+      context: effectiveContext,
+      ...cacheSnapshot ? { _cacheSnapshot: cacheSnapshot } : {}
     };
     let historyMessageCount = 0;
     if (effectiveContext.messages && effectiveContext.messages.length > 0) {
@@ -1034,7 +1025,7 @@ class AgentComponent extends BaseComponent {
               }
               const func = toolCall.function;
               const tcName = func?.name || toolCall.name || "unknown";
-              const tcArgs = func?.arguments ? typeof func.arguments === "string" ? safeParseToolArgs(func.arguments) : func.arguments : toolCall.arguments;
+              const tcArgs = this.parseToolCallArguments(toolCall);
               hookCtx.currentToolCall = {
                 id: toolCall.id,
                 name: tcName,
@@ -1328,7 +1319,80 @@ class AgentComponent extends BaseComponent {
     }
     logger2.info(`All agents aborted (${this.abortControllers.size} runs)`);
   }
+  async _loadOrCreateCacheSnapshot(sessionId, effectiveContext, initialSystemPrompt, agentConfigSystemPrompt) {
+    if (!sessionId) {
+      return { snapshot: null, systemPromptOverride: undefined };
+    }
+    try {
+      const sessionComponent = this.env?.getComponent?.("session");
+      if (!sessionComponent) {
+        return { snapshot: null, systemPromptOverride: undefined };
+      }
+      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
+        };
+      }
+      let resolvedSystemPrompt = initialSystemPrompt;
+      if (resolvedSystemPrompt && resolvedSystemPrompt.includes("{{memory}}")) {
+        try {
+          const memoryComponent = this.env?.getComponent?.("memory");
+          if (memoryComponent && typeof memoryComponent.recallMemory === "function") {
+            const memoryContent = await memoryComponent.recallMemory();
+            resolvedSystemPrompt = resolvedSystemPrompt.replaceAll("{{memory}}", memoryContent || "(No memory)");
+          } else {
+            resolvedSystemPrompt = resolvedSystemPrompt.replaceAll("{{memory}}", "(Memory component not available)");
+          }
+        } catch (err) {
+          logger2.warn(`[AgentComponent._run] Failed to replace {{memory}}: ${err}`);
+          resolvedSystemPrompt = resolvedSystemPrompt.replaceAll("{{memory}}", "(Failed to load memory)");
+        }
+      }
+      const snapshot = {
+        systemPrompt: resolvedSystemPrompt ?? agentConfigSystemPrompt ?? "",
+        additionInfo: effectiveContext.additionInfo || "",
+        snapshotAt: Date.now()
+      };
+      try {
+        await sessionComponent.update(sessionId, {
+          metadata: {
+            ...session?.metadata ?? {},
+            cacheSnapshot: snapshot
+          }
+        });
+        logger2.debug(`[AgentComponent._run] Created cacheSnapshot for session ${sessionId} (snapshotAt=${snapshot.snapshotAt})`);
+      } catch (updateErr) {
+        logger2.warn(`[AgentComponent._run] Failed to persist cacheSnapshot for session ${sessionId}: ${updateErr}`);
+      }
+      return { snapshot, systemPromptOverride: resolvedSystemPrompt };
+    } catch (err) {
+      logger2.warn(`[AgentComponent._run] Failed to load cacheSnapshot: ${err}`);
+      return { snapshot: null, systemPromptOverride: undefined };
+    }
+  }
+  async _fallbackReplaceMemory(systemPrompt) {
+    if (!systemPrompt.includes("{{memory}}"))
+      return systemPrompt;
+    try {
+      const memoryComponent = this.env?.getComponent?.("memory");
+      if (memoryComponent && typeof memoryComponent.recallMemory === "function") {
+        const memoryContent = await memoryComponent.recallMemory();
+        return systemPrompt.replaceAll("{{memory}}", memoryContent || "(No memory)");
+      }
+      return systemPrompt.replaceAll("{{memory}}", "(Memory component not available)");
+    } catch (err) {
+      logger2.warn(`[AgentComponent._run] Failed to replace {{memory}}: ${err}`);
+      return systemPrompt.replaceAll("{{memory}}", "(Failed to load memory)");
+    }
+  }
   async _buildAdditionInfo(ctx) {
+    if (ctx._cacheSnapshot) {
+      return ctx._cacheSnapshot.additionInfo;
+    }
     let additionInfo = ctx.context?.additionInfo || "";
     return additionInfo;
   }
@@ -1336,21 +1400,28 @@ class AgentComponent extends BaseComponent {
     const messages = [];
     const additionInfo = await this._buildAdditionInfo(ctx);
     if (ctx.systemPrompt) {
+      messages.push(...buildMultiBlockSystem({
+        characterSheet: ctx.systemPrompt,
+        toolDefinitions: undefined,
+        memoryBlock: undefined,
+        dynamicContext: additionInfo
+      }));
+    } else if (additionInfo) {
       messages.push({
         role: "system",
-        content: `${ctx.systemPrompt}
-
-${additionInfo}`
-      });
-    } else {
-      messages.push({
-        role: "system",
-        content: `${additionInfo}`
+        content: additionInfo
       });
     }
     messages.push(...ctx.messages);
     return messages;
   }
+  _formatToolDefinitions(tools) {
+    if (!tools || tools.length === 0)
+      return "";
+    const sorted = [...tools].sort((a, b) => a.name.localeCompare(b.name));
+    return sorted.map((t) => `${t.name}: ${t.description || ""}`).join(`
+`);
+  }
   async invokeLLM(ctx) {
     logger2.debug("[invokeLLM] Starting LLM invocation");
     if (this.llmComponent?.invoke) {
@@ -1401,6 +1472,10 @@ ${additionInfo}`
       finishReason: "stop"
     };
   }
+  parseToolCallArguments(toolCall) {
+    const rawArgs = toolCall.function?.arguments ?? toolCall.arguments;
+    return safeParseToolArgs(rawArgs);
+  }
   async executeTool(ctx) {
     const toolCall = ctx.currentToolCall;
     const toolName = toolCall.function?.name || toolCall.name || "unknown";
@@ -1689,12 +1764,37 @@ __legacyDecorateClassTS([
 __legacyDecorateClassTS([
   TracedAs("agent.component.run", { recordParams: true, recordResult: true, log: true })
 ], AgentComponent.prototype, "_run", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.component.loadOrCreateCacheSnapshot", { recordParams: true, recordResult: true, log: true })
+], AgentComponent.prototype, "_loadOrCreateCacheSnapshot", null);
 __legacyDecorateClassTS([
   TracedAs("agent.component.buildAdditionInfo", { recordParams: true, recordResult: true, log: true })
 ], AgentComponent.prototype, "_buildAdditionInfo", null);
 __legacyDecorateClassTS([
   TracedAs("agent.component.invokeLLM", { recordParams: true, recordResult: true, log: true })
 ], AgentComponent.prototype, "invokeLLM", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.tool_call.parse", {
+    recordParams: true,
+    recordResult: true,
+    log: true,
+    paramFilter: (args) => {
+      const toolCall = args[0];
+      const hasFunctionArgs = toolCall?.function?.arguments !== undefined;
+      const rawArgs = hasFunctionArgs ? toolCall.function.arguments : toolCall?.arguments;
+      return {
+        tool_call_id: toolCall?.id,
+        tool_name: toolCall?.function?.name ?? toolCall?.name ?? "unknown",
+        argument_source: hasFunctionArgs ? "function.arguments" : "arguments",
+        argument_type: rawArgs === null ? "null" : Array.isArray(rawArgs) ? "array" : typeof rawArgs
+      };
+    },
+    resultFilter: (result) => ({
+      argument_type: "object",
+      keys: Object.keys(result).sort()
+    })
+  })
+], AgentComponent.prototype, "parseToolCallArguments", null);
 __legacyDecorateClassTS([
   TracedAs("agent.component.executeTool", { recordParams: true, recordResult: true, log: true })
 ], AgentComponent.prototype, "executeTool", null);
@@ -1704,6 +1804,39 @@ __legacyDecorateClassTS([
 __legacyDecorateClassTS([
   TracedAs("agent.component.getConversationHistory", { recordParams: true, recordResult: true, log: true })
 ], AgentComponent.prototype, "getConversationHistory", null);
+function buildMultiBlockSystem(ctx) {
+  const ANTHROPIC_CACHE_CONTROL = {
+    anthropic: { cacheControl: { type: "ephemeral" } }
+  };
+  const messages = [];
+  if (ctx.characterSheet) {
+    messages.push({
+      role: "system",
+      content: ctx.characterSheet,
+      providerOptions: ANTHROPIC_CACHE_CONTROL
+    });
+  }
+  if (ctx.toolDefinitions) {
+    messages.push({
+      role: "system",
+      content: ctx.toolDefinitions,
+      providerOptions: ANTHROPIC_CACHE_CONTROL
+    });
+  }
+  if (ctx.memoryBlock) {
+    messages.push({
+      role: "system",
+      content: ctx.memoryBlock
+    });
+  }
+  if (ctx.dynamicContext) {
+    messages.push({
+      role: "system",
+      content: ctx.dynamicContext
+    });
+  }
+  return messages;
+}
 // src/env/agent/summary-agent.ts
 class SummaryAgent {
   llmComponent;

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

@@ -14,7 +14,7 @@ import {
 } from "./roy-agent-core-c1v263jn.js";
 import {
   isValidSessionId
-} from "./roy-agent-core-f2nync7q.js";
+} from "./roy-agent-core-xvag5pd0.js";
 import {
   TracedAs,
   init_decorator