@agent-native/core 0.101.3 → 0.101.5

package/dist/agent/production-agent.js

@@ -1436,18 +1436,23 @@ function seedReadOnlyToolResultsFromHistory(messages, actions) {
     const cache = new Map();
     if (!isInternalContinuationTurn(messages))
         return cache;
+    // Scoped to the current turn only (same slice as
+    // seedWriteToolInterruptionsFromHistory) — reads from a prior turn are no
+    // longer relevant context and must not seed skip-as-duplicate behavior.
+    const turnStart = findCurrentTurnStartForContinuation(messages);
+    const turnMessages = messages.slice(turnStart);
     const pendingToolCalls = new Map();
-    for (const message of messages) {
+    for (const message of turnMessages) {
         if (message.role === "assistant") {
             for (const part of message.content) {
                 if (part.type !== "tool-call")
                     continue;
                 const entry = actions[part.name];
-                if (entry?.readOnly !== true)
-                    continue;
                 pendingToolCalls.set(part.id, {
                     name: part.name,
                     input: part.input,
+                    readOnly: entry?.readOnly === true,
+                    dedupe: entry?.dedupe !== false,
                 });
             }
             continue;
@@ -1458,6 +1463,19 @@ function seedReadOnlyToolResultsFromHistory(messages, actions) {
             const call = pendingToolCalls.get(part.toolCallId);
             if (!call)
                 continue;
+            if (!call.readOnly) {
+                // Mirror the live loop: a successful write invalidates all cached
+                // reads (see the `readOnlyToolResultCache.clear()` call below), so a
+                // read seeded from before an intervening write must not be replayed
+                // as still-fresh.
+                if (part.isError !== true)
+                    cache.clear();
+                continue;
+            }
+            // dedupe:false read-only tools (volatile/polling reads) are never
+            // cached — every call must execute fresh, seeded or not.
+            if (!call.dedupe)
+                continue;
             if (!isReusableReadOnlyToolResult(part))
                 continue;
             cache.set(toolCallCacheKey(call.name, call.input), part.content);
@@ -1465,19 +1483,135 @@ function seedReadOnlyToolResultsFromHistory(messages, actions) {
     }
     return cache;
 }
+function visibleDuplicateReadOnlyToolResult(toolName) {
+    return (`Skipped duplicate read-only call to ${toolName}: identical input already ran in this turn. ` +
+        `Use the previous result already in the conversation instead of calling this tool again.`);
+}
+function resurfacedDuplicateReadOnlyToolResultPrefix(toolName) {
+    return (`Skipped duplicate read-only call to ${toolName}: identical input already ran in this turn. ` +
+        `Its earlier result is no longer in view, so here it is again:\n\n`);
+}
+function resurfacedDuplicateReadOnlyToolResult(toolName, cachedResult) {
+    return `${resurfacedDuplicateReadOnlyToolResultPrefix(toolName)}${cachedResult}`;
+}
+/** Restore visible-repeat strike counts for this continuation's active turn. */
+function seedDuplicateReadOnlyToolCallsFromHistory(messages, actions) {
+    const repeats = new Map();
+    if (!isInternalContinuationTurn(messages))
+        return repeats;
+    const turnStart = findCurrentTurnStartForContinuation(messages);
+    const pendingToolCalls = new Map();
+    const reusableReadKeys = new Set();
+    for (const message of messages.slice(turnStart)) {
+        if (message.role === "assistant") {
+            for (const part of message.content) {
+                if (part.type !== "tool-call")
+                    continue;
+                const entry = actions[part.name];
+                pendingToolCalls.set(part.id, {
+                    name: part.name,
+                    input: part.input,
+                    readOnly: entry?.readOnly === true,
+                    dedupe: entry?.dedupe !== false,
+                });
+            }
+            continue;
+        }
+        for (const part of message.content) {
+            if (part.type !== "tool-result")
+                continue;
+            const call = pendingToolCalls.get(part.toolCallId);
+            if (!call)
+                continue;
+            if (!call.readOnly) {
+                if (part.isError !== true) {
+                    repeats.clear();
+                    reusableReadKeys.clear();
+                }
+                continue;
+            }
+            if (!call.dedupe || part.isError === true)
+                continue;
+            const cacheKey = toolCallCacheKey(call.name, call.input);
+            if (part.content === visibleDuplicateReadOnlyToolResult(call.name)) {
+                if (reusableReadKeys.has(cacheKey)) {
+                    repeats.set(cacheKey, (repeats.get(cacheKey) ?? 0) + 1);
+                }
+                continue;
+            }
+            if (part.content.startsWith(resurfacedDuplicateReadOnlyToolResultPrefix(call.name))) {
+                if (reusableReadKeys.has(cacheKey))
+                    repeats.set(cacheKey, 0);
+                continue;
+            }
+            if (isReusableReadOnlyToolResult(part)) {
+                reusableReadKeys.add(cacheKey);
+            }
+        }
+    }
+    return repeats;
+}
 function isReusableReadOnlyToolResult(part) {
     if (part.isError)
         return false;
     const lower = part.content.trim().toLowerCase();
     if (!lower)
         return false;
-    return !(lower.startsWith("invalid action parameters for ") ||
+    return !(lower.startsWith("skipped duplicate read-only call to ") ||
+        lower.startsWith("invalid action parameters for ") ||
         lower.startsWith("error running ") ||
         lower.includes("run aborted") ||
         lower.includes("tool call timed out") ||
         lower.includes("stale_run") ||
         lower.includes("connection_error"));
 }
+/**
+ * Whether a cached read-only tool result is still something the model can
+ * actually see in `contextMessages` — the trimmed/summarized view the engine
+ * is streamed (NOT the raw, ever-growing `messages` array the cache is keyed
+ * off of). Context-xray `evict` drops tool-result parts entirely, `summarize`
+ * replaces their content with a placeholder, and observational-memory
+ * trimming drops whole older messages once active. When the cached result
+ * has fallen out of that view, re-serving "use the previous result" is not
+ * actionable — the model has nothing to point back to.
+ *
+ * A visible result must belong to the same tool name + normalized input and
+ * contain either the exact cached body or the exact wrapper used when that
+ * body was re-served after trimming. Matching only by a content suffix is too
+ * loose: short results such as "ok" can also end unrelated tool output.
+ */
+export function isCachedToolResultVisibleInContext(contextMessages, toolCall, cachedResult) {
+    if (cachedResult.length === 0)
+        return true;
+    const cacheKey = toolCallCacheKey(toolCall.name, toolCall.input);
+    const matchingToolCallIds = new Set();
+    for (const message of contextMessages) {
+        if (message.role !== "assistant")
+            continue;
+        for (const part of message.content) {
+            if (part.type !== "tool-call")
+                continue;
+            if (toolCallCacheKey(part.name, part.input) === cacheKey) {
+                matchingToolCallIds.add(part.id);
+            }
+        }
+    }
+    const resurfacedResult = resurfacedDuplicateReadOnlyToolResult(toolCall.name, cachedResult);
+    for (const message of contextMessages) {
+        if (message.role !== "user")
+            continue;
+        for (const part of message.content) {
+            if (part.type !== "tool-result")
+                continue;
+            if (!matchingToolCallIds.has(part.toolCallId))
+                continue;
+            if (part.content === cachedResult || part.content === resurfacedResult) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
 /**
  * Counts how many times each write (non-read-only) tool call was interrupted
  * before returning a result in the continuation history. When a connection
@@ -2126,7 +2260,7 @@ export async function runAgentLoop(opts) {
         runCtx.toolResults = toolResultHistory;
     }
     const readOnlyToolResultCache = seedReadOnlyToolResultsFromHistory(messages, actions);
-    const duplicateReadOnlyToolCalls = new Map();
+    const duplicateReadOnlyToolCalls = seedDuplicateReadOnlyToolCallsFromHistory(messages, actions);
     const writeToolInterruptions = seedWriteToolInterruptionsFromHistory(messages, actions);
     const repeatedToolErrors = new Map();
     // Tool-call journal hard-block (resume safety). See
@@ -3206,16 +3340,41 @@ export async function runAgentLoop(opts) {
                     isError: true,
                 };
             }
-            const cacheKey = actionEntry.readOnly === true
+            // dedupe: false opts a read-only tool out of the guard entirely — the
+            // cacheKey stays null so it never gets skipped-as-duplicate and never
+            // populates the cache (see the success handler below, which also
+            // leaves dedupe:false results uncached and un-cleared).
+            const cacheKey = actionEntry.readOnly === true && actionEntry.dedupe !== false
                 ? toolCallCacheKey(toolCall.name, toolCall.input)
                 : null;
             if (cacheKey && readOnlyToolResultCache.has(cacheKey)) {
-                const repeats = (duplicateReadOnlyToolCalls.get(cacheKey) ?? 0) + 1;
-                duplicateReadOnlyToolCalls.set(cacheKey, repeats);
                 const previousResult = readOnlyToolResultCache.get(cacheKey) ?? "";
-                const result = `Skipped duplicate read-only call to ${toolCall.name}: identical input already ran in this turn. ` +
-                    `Use the previous result already in the conversation instead of calling this tool again.\n\n` +
-                    `Previous result:\n${previousResult}`;
+                // `contextMessages` (not `messages`) is what the model actually sees
+                // this iteration — context-xray eviction/summarization and
+                // observational-memory trimming can drop the earlier result from
+                // view even though it's still cached here. Only strike-count the
+                // repeat when the model could have looked back and found it itself.
+                const visible = isCachedToolResultVisibleInContext(contextMessages, toolCall, previousResult);
+                let result;
+                if (visible) {
+                    const repeats = (duplicateReadOnlyToolCalls.get(cacheKey) ?? 0) + 1;
+                    duplicateReadOnlyToolCalls.set(cacheKey, repeats);
+                    result = visibleDuplicateReadOnlyToolResult(toolCall.name);
+                    if (repeats >= 3) {
+                        requestedActionStop ??= {
+                            message: "I stopped because the agent kept asking for the same read-only context it already had. Please send the request again if you want me to retry from a fresh turn.",
+                            errorCode: "duplicate_read_only_tool",
+                        };
+                    }
+                }
+                else {
+                    // The earlier result was trimmed out of the model's visible
+                    // context — this isn't a repetitive loop, the model legitimately
+                    // can't see the answer anymore. Re-serve it in full and don't
+                    // count a strike.
+                    duplicateReadOnlyToolCalls.set(cacheKey, 0);
+                    result = resurfacedDuplicateReadOnlyToolResult(toolCall.name, previousResult);
+                }
                 send({
                     type: "tool_done",
                     id: toolCall.id,
@@ -3225,12 +3384,6 @@ export async function runAgentLoop(opts) {
                     completedSideEffect: false,
                 });
                 recordToolResult(result, false);
-                if (repeats >= 3) {
-                    requestedActionStop ??= {
-                        message: "I stopped because the agent kept asking for the same read-only context it already had. Please send the request again if you want me to retry from a fresh turn.",
-                        errorCode: "duplicate_read_only_tool",
-                    };
-                }
                 return {
                     type: "tool-result",
                     toolCallId: toolCall.id,
@@ -3467,7 +3620,11 @@ export async function runAgentLoop(opts) {
                 if (cacheKey) {
                     readOnlyToolResultCache.set(cacheKey, result);
                 }
-                else {
+                else if (actionEntry.readOnly !== true) {
+                    // A genuine write invalidates all cached reads. A dedupe:false
+                    // read-only tool also has a null cacheKey (see above) but must NOT
+                    // clear the cache — it isn't a write and other tools' cached reads
+                    // are still valid.
                     readOnlyToolResultCache.clear();
                     duplicateReadOnlyToolCalls.clear();
                 }