@myagentroam/agent 0.9.164 → 0.9.165

package/dist/agent-core/runtime/context/gc.js

@@ -1,5 +1,3 @@
-import { countModelTokens } from '../token-budget.js';
-import { renderObservations } from '../../tools/code-mode/observations.js';
 import { codeCallEvidence, codeObservationEvidence, retainedCodeInputs } from '../../session/context-gc-observations.js';
 import { ContextGcCheckpointCache, contextGcBaseFromRecords, contextGcLogicalPathKey, contextGcMinimumUsageGrowth, contextGcRecordSourceHash, contextGcTargetKey, normalizeContextGcReplacements } from '../../session/context-gc-checkpoint.js';
 import { codeCellCompletionSequence, contextGcApplyPatchInputReplacement, contextGcCodeModeInputReplacement, contextGcCodeModeOutputReplacement, contextGcExecInputReplacement, contextGcExecOutputReplacement, contextGcPatchResultFromCompletedPayload, contextGcStaleReadReplacement, contextGcWebOutputReplacement, normalizeContextGcCodeModeInput, normalizeContextGcExecResult } from '../../session/context-gc-replacements.js';
@@ -30,8 +28,6 @@ const MINIMUM_CONTEXT_WINDOW_REDUCTION_RATIO = 0.05;
 const COMPACT_CREDIT_ACTIVATION_RATIO = 0.8;
 const COMPACT_THRESHOLD_RATIO = 0.9;
 const IMMINENT_COMPACT_CREDIT_DISCOUNT = 0.8;
-const LARGE_TERMINAL_OUTPUT_TOKENS = 4_096;
-const HIGH_WATER_LARGE_TERMINAL_OUTPUT_TOKENS = 2_048;
 export function evaluateContextGcEconomics(input) {
     const reclaimedTokens = Math.max(0, input.reclaimedTokens);
     const cacheReadTokens = Math.max(0, input.cacheReadTokens);
@@ -150,14 +146,15 @@ export function inspectContextGc(input) {
         return {};
     const groups = buildToolGroups(input.records, input.messages, input.messageSources);
     const existing = previous?.payload.replacements ?? [];
+    const candidateSavings = createCandidateSavingsEstimator(input, existing);
     const existingTargets = new Set(existing.flatMap((replacement) => [
         contextGcTargetKey(replacement.target),
         ...(replacement.kind === 'TOOL_CALL_INPUT'
             ? replacement.providerAliasTargets.map(contextGcTargetKey)
             : [])
     ]));
-    const stageA = collectStageACandidates(input, groups, existing, existingTargets);
-    const subagent = collectSubagentCandidates(input, groups, existingTargets);
+    const stageA = collectStageACandidates(input, groups, existing, existingTargets, candidateSavings);
+    const subagent = collectSubagentCandidates(input, groups, existingTargets, candidateSavings);
     const deterministicCandidates = [...stageA.eligible, ...subagent.eligible];
     const deterministicProtectedTokens = stageA.protectedTokens + subagent.protectedTokens;
     const stageAPlan = evaluateCandidateSet(input, existing, deterministicCandidates, {
@@ -169,9 +166,9 @@ export function inspectContextGc(input) {
         protectedCandidateTokens: deterministicProtectedTokens
     });
     if (stageAPlan?.economics.passes) {
-        const exec = collectExecCandidates(input, groups, existingTargets, usageRatio);
-        const codeMode = collectCodeModeCandidates(input, groups, existingTargets, usageRatio);
-        const web = collectWebCandidates(input, groups, existingTargets, usageRatio);
+        const exec = collectExecCandidates(input, groups, existingTargets, candidateSavings);
+        const codeMode = collectCodeModeCandidates(input, groups, existingTargets, candidateSavings);
+        const web = collectWebCandidates(input, groups, existingTargets, candidateSavings);
         const protectedCandidateTokens = deterministicProtectedTokens +
             exec.protectedTokens +
             codeMode.protectedTokens +
@@ -202,9 +199,9 @@ export function inspectContextGc(input) {
             }
             : {};
     }
-    const exec = collectExecCandidates(input, groups, existingTargets, usageRatio);
-    const codeMode = collectCodeModeCandidates(input, groups, existingTargets, usageRatio);
-    const web = collectWebCandidates(input, groups, existingTargets, usageRatio);
+    const exec = collectExecCandidates(input, groups, existingTargets, candidateSavings);
+    const codeMode = collectCodeModeCandidates(input, groups, existingTargets, candidateSavings);
+    const web = collectWebCandidates(input, groups, existingTargets, candidateSavings);
     const combined = evaluateCandidateSet(input, existing, [...deterministicCandidates, ...exec.eligible, ...codeMode.eligible, ...web.eligible], {
         stage: 'STAGE_A_AND_EXEC',
         contextUsageTokens,
@@ -230,7 +227,7 @@ export function inspectContextGc(input) {
         ? { retryAfterRollouts }
         : {};
 }
-function collectCodeModeCandidates(input, groups, existingTargets, usageRatio) {
+function collectCodeModeCandidates(input, groups, existingTargets, candidateSavings) {
     const eligible = [];
     let protectedTokens = 0;
     let retryAfterRollouts = Infinity;
@@ -251,19 +248,8 @@ function collectCodeModeCandidates(input, groups, existingTargets, usageRatio) {
             !isRecord(completedPayload) ||
             typeof completedPayload.truncated !== 'boolean')
             continue;
-        const visibleTokens = contextGcMessageTokens(input, [
-            group.call.message,
-            group.result.message,
-            ...group.aliases.map((alias) => alias.message)
-        ]);
-        const minimumVisibleTokens = usageRatio >= COMPACT_CREDIT_ACTIVATION_RATIO
-            ? HIGH_WATER_LARGE_TERMINAL_OUTPUT_TOKENS
-            : LARGE_TERMINAL_OUTPUT_TOKENS;
-        if (visibleTokens < minimumVisibleTokens)
-            continue;
         for (const observation of group.result.message.observations ?? []) {
-            if (observation.type !== 'value' ||
-                countModelTokens(observation.value) < minimumVisibleTokens)
+            if (observation.type !== 'value')
                 continue;
             const target = targetFor(group.result.record, {
                 ...group.result.message,
@@ -285,10 +271,13 @@ function collectCodeModeCandidates(input, groups, existingTargets, usageRatio) {
                 observedRollouts: successfulRolloutsAfter(input.records, Math.max(evidenceSequence, completionSequence), input.modelId, input.contextWindowTokens),
                 evidenceSequence
             };
+            const reclaimedTokens = candidateSavings(candidate);
+            if (reclaimedTokens <= 0)
+                continue;
             if (candidate.observedRollouts >= CONTEXT_GC_POLICY.largeExecProtectionRollouts)
                 eligible.push(candidate);
             else {
-                protectedTokens += candidateTokens(input, candidate);
+                protectedTokens += reclaimedTokens;
                 retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.largeExecProtectionRollouts - candidate.observedRollouts);
             }
         }
@@ -323,10 +312,13 @@ function collectCodeModeCandidates(input, groups, existingTargets, usageRatio) {
             continue;
         const observedRollouts = successfulRolloutsAfter(input.records, Math.max(evidenceSequence, completionSequence), input.modelId, input.contextWindowTokens);
         const candidate = { replacements, observedRollouts, evidenceSequence };
+        const reclaimedTokens = candidateSavings(candidate);
+        if (reclaimedTokens <= 0)
+            continue;
         if (observedRollouts >= CONTEXT_GC_POLICY.largeExecProtectionRollouts)
             eligible.push(candidate);
         else {
-            protectedTokens += candidateTokens(input, candidate);
+            protectedTokens += reclaimedTokens;
             retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.largeExecProtectionRollouts - observedRollouts);
         }
     }
@@ -528,7 +520,7 @@ function evaluateCandidateSet(input, existing, candidates, state) {
         eligibleCandidateCount: candidates.length
     };
 }
-function collectStageACandidates(input, groups, existingReplacements, existingTargets) {
+function collectStageACandidates(input, groups, existingReplacements, existingTargets, candidateSavings) {
     const eligible = [];
     let protectedTokens = 0;
     let retryAfterRollouts = Infinity;
@@ -555,6 +547,7 @@ function collectStageACandidates(input, groups, existingReplacements, existingTa
         const patchCall = patch.call;
         const observedRollouts = successfulRolloutsAfter(input.records, evidenceSequence, input.modelId, input.contextWindowTokens);
         const replacements = [];
+        const candidateReadItems = new Set();
         const patchTarget = targetFor(patchCall.record, patchCall.message);
         if (patchTarget && !existingTargets.has(contextGcTargetKey(patchTarget)))
             replacements.push({
@@ -578,14 +571,14 @@ function collectStageACandidates(input, groups, existingReplacements, existingTa
                 if (item.pathTruncated)
                     return [];
                 const itemKey = `${read.result.record.recordId}:${read.result.message.observationId ?? ''}:${item.index}`;
-                if (claimedReadItems.has(itemKey))
+                if (claimedReadItems.has(itemKey) || candidateReadItems.has(itemKey))
                     return [];
                 const pathKey = contextGcLogicalPathKey(item.path, input.workspace, input.platform);
                 const matched = result.files.find((file) => file.operation !== 'added' &&
                     contextGcLogicalPathKey(file.path, input.workspace, input.platform) === pathKey);
                 if (!pathKey || !matched || matched.operation === 'added')
                     return [];
-                claimedReadItems.add(itemKey);
+                candidateReadItems.add(itemKey);
                 return [
                     {
                         index: item.index,
@@ -625,16 +618,21 @@ function collectStageACandidates(input, groups, existingReplacements, existingTa
             observedRollouts,
             evidenceSequence
         };
+        const reclaimedTokens = candidateSavings(candidate);
+        if (reclaimedTokens <= 0)
+            continue;
+        for (const itemKey of candidateReadItems)
+            claimedReadItems.add(itemKey);
         if (observedRollouts >= CONTEXT_GC_POLICY.stageAProtectionRollouts)
             eligible.push(candidate);
         else {
-            protectedTokens += candidateTokens(input, candidate);
+            protectedTokens += reclaimedTokens;
             retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.stageAProtectionRollouts - observedRollouts);
         }
     }
     return { eligible, protectedTokens, retryAfterRollouts };
 }
-function collectSubagentCandidates(input, groups, existingTargets) {
+function collectSubagentCandidates(input, groups, existingTargets, candidateSavings) {
     const eligible = [];
     let protectedTokens = 0;
     let retryAfterRollouts = Infinity;
@@ -714,16 +712,19 @@ function collectSubagentCandidates(input, groups, existingTargets) {
             observedRollouts,
             evidenceSequence
         };
+        const reclaimedTokens = candidateSavings(candidate);
+        if (reclaimedTokens <= 0)
+            continue;
         if (observedRollouts >= CONTEXT_GC_POLICY.stageAProtectionRollouts)
             eligible.push(candidate);
         else {
-            protectedTokens += candidateTokens(input, candidate);
+            protectedTokens += reclaimedTokens;
             retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.stageAProtectionRollouts - observedRollouts);
         }
     }
     return { eligible, protectedTokens, retryAfterRollouts };
 }
-function collectExecCandidates(input, groups, existingTargets, usageRatio) {
+function collectExecCandidates(input, groups, existingTargets, candidateSavings) {
     const eligible = [];
     let protectedTokens = 0;
     let retryAfterRollouts = Infinity;
@@ -797,18 +798,6 @@ function collectExecCandidates(input, groups, existingTargets, usageRatio) {
         if (!terminal || (processId && input.activeProcessIds.has(processId)))
             continue;
         const final = lifecycle.at(-1);
-        const visibleTokens = contextGcMessageTokens(input, lifecycle
-            .filter((invocation) => !invocation.group.evidenceOnly)
-            .flatMap((invocation) => [
-            invocation.group.call.message,
-            invocation.group.result.message,
-            ...invocation.group.aliases.map((alias) => alias.message)
-        ]));
-        const minimumVisibleTokens = usageRatio >= COMPACT_CREDIT_ACTIVATION_RATIO
-            ? HIGH_WATER_LARGE_TERMINAL_OUTPUT_TOKENS
-            : LARGE_TERMINAL_OUTPUT_TOKENS;
-        if (visibleTokens < minimumVisibleTokens)
-            continue;
         const evidenceSequence = final.group.result.record.sequence;
         const observedRollouts = successfulRolloutsAfter(input.records, evidenceSequence, input.modelId, input.contextWindowTokens);
         const replacements = [];
@@ -850,22 +839,22 @@ function collectExecCandidates(input, groups, existingTargets, usageRatio) {
             observedRollouts,
             evidenceSequence
         };
+        const reclaimedTokens = candidateSavings(candidate);
+        if (reclaimedTokens <= 0)
+            continue;
         if (observedRollouts >= CONTEXT_GC_POLICY.largeExecProtectionRollouts)
             eligible.push(candidate);
         else {
-            protectedTokens += candidateTokens(input, candidate);
+            protectedTokens += reclaimedTokens;
             retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.largeExecProtectionRollouts - observedRollouts);
         }
     }
     return { eligible, protectedTokens, retryAfterRollouts };
 }
-function collectWebCandidates(input, groups, existingTargets, usageRatio) {
+function collectWebCandidates(input, groups, existingTargets, candidateSavings) {
     const eligible = [];
     let protectedTokens = 0;
     let retryAfterRollouts = Infinity;
-    const minimumVisibleTokens = usageRatio >= COMPACT_CREDIT_ACTIVATION_RATIO
-        ? HIGH_WATER_LARGE_TERMINAL_OUTPUT_TOKENS
-        : LARGE_TERMINAL_OUTPUT_TOKENS;
     for (const group of [...groups.values()].sort((left, right) => (left.result?.record.sequence ?? Number.MAX_SAFE_INTEGER) -
         (right.result?.record.sequence ?? Number.MAX_SAFE_INTEGER))) {
         if (!isContextGcWebToolName(group.toolName) ||
@@ -885,9 +874,6 @@ function collectWebCandidates(input, groups, existingTargets, usageRatio) {
         const target = targetFor(group.result.record, group.result.message);
         if (!target || existingTargets.has(contextGcTargetKey(target)))
             continue;
-        const visibleTokens = contextGcMessageTokens(input, [group.result.message]);
-        if (visibleTokens < minimumVisibleTokens)
-            continue;
         const evidenceSequence = group.result.record.sequence;
         const observedRollouts = successfulRolloutsAfter(input.records, evidenceSequence, input.modelId, input.contextWindowTokens);
         const candidate = {
@@ -904,10 +890,13 @@ function collectWebCandidates(input, groups, existingTargets, usageRatio) {
             observedRollouts,
             evidenceSequence
         };
+        const reclaimedTokens = candidateSavings(candidate);
+        if (reclaimedTokens <= 0)
+            continue;
         if (observedRollouts >= CONTEXT_GC_POLICY.largeExecProtectionRollouts)
             eligible.push(candidate);
         else {
-            protectedTokens += candidateTokens(input, candidate);
+            protectedTokens += reclaimedTokens;
             retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.largeExecProtectionRollouts - observedRollouts);
         }
     }
@@ -1230,23 +1219,46 @@ function firstMatchingUsageAfter(records, sequence, modelId, contextWindowTokens
     }
     return undefined;
 }
-function candidateTokens(input, candidate) {
-    const targets = new Set(candidate.replacements.flatMap((replacement) => [
-        contextGcTargetKey(replacement.target),
-        ...(replacement.kind === 'TOOL_CALL_INPUT'
-            ? replacement.providerAliasTargets.map(contextGcTargetKey)
-            : [])
-    ]));
-    return contextGcMessageTokens(input, input.messages.flatMap((message, index) => {
-        const target = targetFor(input.messageSources[index], message);
-        if (target && targets.has(contextGcTargetKey(target)))
-            return [message];
-        const selected = target &&
-            message.observations?.filter((value) => targets.has(contextGcTargetKey({ ...target, observationId: value.id })));
-        return selected?.length
-            ? [{ ...message, observations: selected, content: renderObservations(selected) }]
-            : [];
-    }));
+/** Measure only affected call families, retaining native aliases for provider lowering. */
+function createCandidateSavingsEstimator(input, existing) {
+    const byCall = new Map();
+    const byRecord = new Map();
+    for (const [index, message] of input.messages.entries()) {
+        const callId = message.role === 'provider' ? providerToolCallId(message) : message.callId;
+        if (callId) {
+            const indices = byCall.get(callId) ?? [];
+            indices.push(index);
+            byCall.set(callId, indices);
+        }
+        const recordId = input.messageSources[index].recordId;
+        const indices = byRecord.get(recordId) ?? [];
+        indices.push(index);
+        byRecord.set(recordId, indices);
+    }
+    return (candidate) => {
+        const indices = new Set();
+        for (const replacement of candidate.replacements) {
+            const targets = [
+                replacement.target,
+                ...(replacement.kind === 'TOOL_CALL_INPUT' ? replacement.providerAliasTargets : [])
+            ];
+            for (const target of targets) {
+                for (const index of byRecord.get(target.recordId) ?? [])
+                    indices.add(index);
+                if (target.callId)
+                    for (const index of byCall.get(target.callId) ?? [])
+                        indices.add(index);
+            }
+        }
+        const ordered = [...indices].sort((a, b) => a - b);
+        const messages = ordered.map((index) => input.messages[index]);
+        const sources = ordered.map((index) => input.messageSources[index]);
+        const replacements = normalizeContextGcReplacements([...existing, ...candidate.replacements]);
+        if (!replacements)
+            return 0;
+        const projected = applyContextGcReplacementsToMessages(messages, sources, replacements);
+        return contextGcReclaimedTokens(input, messages, projected.messages);
+    };
 }
 function targetFor(record, message) {
     if (record.type !== 'model.context' ||

package/dist/agent-core/runtime/context/projection.js

@@ -272,7 +272,9 @@ function targetFromMessage(record, message) {
     };
 }
 function targetMatchesReplacement(left, right) {
-    return (contextGcTargetKey(left) === contextGcTargetKey(right) && left.sourceHash === right.sourceHash);
+    return (contextGcTargetKey(left) === contextGcTargetKey(right) &&
+        left.sourceHash === right.sourceHash &&
+        (right.toolName === undefined || right.toolName === left.toolName));
 }
 function cloneMessage(message) {
     return structuredClone(message);

package/dist/agent-core/session/context-gc-checkpoint.js

@@ -58,7 +58,8 @@ export function contextGcLogicalPathKey(path, workspace, platform) {
     return resolved;
 }
 export function contextGcTargetKey(target) {
-    return `${target.sequence}:${target.recordId}:${target.role}:${target.callId ?? ''}:${target.toolName ?? ''}${target.observationId ? `:${target.observationId}` : ''}`;
+    // Tool outputs are identified by their record/call and observation, not optional tool-name metadata.
+    return `${target.sequence}:${target.recordId}:${target.role}:${target.callId ?? ''}:${target.role === 'tool' ? '' : (target.toolName ?? '')}${target.observationId ? `:${target.observationId}` : ''}`;
 }
 export function contextGcReplacementKey(replacement) {
     return contextGcTargetKey(replacement.target);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/agent",
-  "version": "0.9.164",
+  "version": "0.9.165",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",