@myagentroam/agent 0.11.53 → 0.11.55

package/dist/model/native-context.d.ts

@@ -1,5 +1,9 @@
 import type { ModelMessage } from './contracts.js';
-/** Identity of a persisted complete native thinking item; payload content is never compared. */
-export declare function completedNativeThinkingIdentity(payload: Record<string, unknown>, recordId: string): string | undefined;
+/** Adapters persist native items at completion; consumers need only type and identity. */
+export declare function completedNativeThinkingIdentity(payload: {
+    role?: unknown;
+    provider?: unknown;
+    item?: unknown;
+}, recordId: string): string | undefined;
 /** Interpret only the existing native context record shapes and their model ownership. */
 export declare function restoreNativeModelContext(payload: Record<string, unknown>, activeModelId?: string): ModelMessage | undefined;

package/dist/model/native-context.js

@@ -1,29 +1,18 @@
 import { anthropicThinkingBlock } from './anthropic-thinking.js';
-/** Identity of a persisted complete native thinking item; payload content is never compared. */
+/** Adapters persist native items at completion; consumers need only type and identity. */
 export function completedNativeThinkingIdentity(payload, recordId) {
     if (payload.role !== 'provider')
         return undefined;
+    const item = payload.item;
+    if (!item || typeof item !== 'object' || Array.isArray(item))
+        return undefined;
+    const block = item;
     if (payload.provider === 'ANTHROPIC_MESSAGES') {
-        const item = payload.item;
-        if (!item || typeof item !== 'object' || Array.isArray(item))
-            return undefined;
-        const block = item;
-        return (block.type === 'thinking' &&
-            typeof block.thinking === 'string' &&
-            typeof block.signature === 'string' &&
-            block.signature.length > 0) ||
-            (block.type === 'redacted_thinking' &&
-                typeof block.data === 'string' &&
-                block.data.length > 0)
-            ? recordId
-            : undefined;
+        return block.type === 'thinking' || block.type === 'redacted_thinking' ? recordId : undefined;
     }
-    const message = restoreNativeModelContext(payload);
-    if (!message?.item)
-        return undefined;
-    if (message.provider !== 'OPENAI_RESPONSES' || message.item.type !== 'reasoning')
+    if (payload.provider !== 'OPENAI_RESPONSES' || block.type !== 'reasoning')
         return undefined;
-    return typeof message.item.id === 'string' ? message.item.id : recordId;
+    return typeof block.id === 'string' ? block.id : recordId;
 }
 /** Interpret only the existing native context record shapes and their model ownership. */
 export function restoreNativeModelContext(payload, activeModelId) {

package/dist/runtime/compaction/retained-context.d.ts

@@ -1,5 +1,10 @@
 import type { SessionModelMessage as ModelMessage } from '../../session/model-request.js';
 import type { CompactSnapshotAnchor } from '../events.js';
+/** Keep the live suffix intact, extending into the snapshot only to fill three native blocks. */
+export declare function compactRetainedStart(messages: readonly ModelMessage[], snapshotLength: number, model: {
+    readonly id: string;
+    readonly protocol: ModelMessage['provider'];
+}): number;
 /** Use a public native identity, never private context text, as the visible boundary. */
 export declare function compactSnapshotAnchor(messages: readonly ModelMessage[], sources: WeakMap<ModelMessage, import('../../session/record-contract.js').SessionRecord>): CompactSnapshotAnchor | undefined;
 /** Decode the SDK-owned checkpoint suffix without promoting contextual text to real input. */

package/dist/runtime/compaction/retained-context.js

@@ -1,6 +1,49 @@
 import { parseModelInputMetadata } from '../../session/record-projection.js';
-import { restoreModelContext } from '../context/projection.js';
+import { providerToolCallId, restoreModelContext } from '../context/projection.js';
 import { parseModelImages } from '../../model/image.js';
+import { completedNativeThinkingIdentity } from '../../model/native-context.js';
+/** Keep the live suffix intact, extending into the snapshot only to fill three native blocks. */
+export function compactRetainedStart(messages, snapshotLength, model) {
+    let start = snapshotLength;
+    const thinking = new Set();
+    for (let index = messages.length - 1; index >= 0 && thinking.size < 3; index--) {
+        const message = messages[index];
+        if (message.provider !== model.protocol ||
+            (message.providerModelId !== undefined && message.providerModelId !== model.id))
+            continue;
+        const identity = completedNativeThinkingIdentity(message, `message:${index}`);
+        if (identity === undefined || thinking.has(identity))
+            continue;
+        thinking.add(identity);
+        start = Math.min(start, index);
+    }
+    // The existing snapshot boundary already closes tool groups.
+    if (start === snapshotLength)
+        return start;
+    // A native item can follow text or tool calls within the same assistant response.
+    while (start > 0 && messages[start - 1].role !== 'user' && messages[start - 1].role !== 'tool')
+        start--;
+    // Resolve any retained result back to its call's assistant group in two linear passes.
+    const calls = new Map();
+    let responseStart = 0;
+    for (let index = 0; index < start; index++) {
+        const message = messages[index];
+        if (message.role === 'user' || message.role === 'tool')
+            responseStart = index + 1;
+        const callId = message.role === 'tool_call' ? message.callId : providerToolCallId(message);
+        if (callId !== undefined && !calls.has(callId))
+            calls.set(callId, responseStart);
+    }
+    for (let index = messages.length - 1; index >= start; index--) {
+        const message = messages[index];
+        if (message.role !== 'tool' || message.callId === undefined)
+            continue;
+        const callStart = calls.get(message.callId);
+        if (callStart !== undefined)
+            start = Math.min(start, callStart);
+    }
+    return start;
+}
 /** Use a public native identity, never private context text, as the visible boundary. */
 export function compactSnapshotAnchor(messages, sources) {
     for (let index = messages.length - 1; index >= 0; index--) {

package/dist/runtime/context/gc-economics.d.ts

@@ -2,9 +2,10 @@ import type { ModelUsage } from '../../model/contracts.js';
 import { type ContextGcEconomicsPolicy } from '../../session/context-gc-checkpoint.js';
 export declare const CONTEXT_GC_POLICY: ContextGcEconomicsPolicy;
 export declare const COMPACT_CREDIT_ACTIVATION_RATIO = 0.8;
-export declare const COMPACT_THRESHOLD_RATIO = 0.9;
+export declare const COMPACT_THRESHOLD_RATIO: number;
 interface ContextGcEconomicsInput {
     readonly contextUsageTokens: number;
+    readonly contextWindowTokens: number;
     readonly reclaimedTokens: number;
     readonly reclaimedCachedTokens: number;
     readonly cacheReadTokens: number;
@@ -17,10 +18,8 @@ interface ContextGcEconomicsInput {
 }
 export interface ContextGcEconomicsResult {
     readonly cacheRebuildPenaltyCostUnits: number;
-    readonly requiredPositiveNetRollouts: number;
-    readonly requiredTargetRoiRollouts: number;
+    readonly requiredPositiveNetRollouts: number | null;
     readonly expectedNetSavedCostUnits: number;
-    readonly cacheInvestmentRoi: number;
     readonly grossReductionRate: number;
     readonly passes: boolean;
 }

package/dist/runtime/context/gc-economics.js

@@ -1,3 +1,4 @@
+import { AGENT_EXECUTION_POLICY } from '../execution-policy.js';
 export const CONTEXT_GC_POLICY = {
     version: 1,
     immediatePaybackRollouts: 3,
@@ -8,18 +9,16 @@ export const CONTEXT_GC_POLICY = {
     stageAProtectionRollouts: 6,
     largeExecProtectionRollouts: 6,
     normalInputCostRate: 1,
-    cacheReadCostRate: 0.1,
-    cacheWriteCostRate: 1.25,
+    cacheReadCostRate: 0.05,
     outputCostRate: 1,
-    minimumGrossReductionRate: 0.2,
-    minimumCacheInvestmentRoi: 0.1
+    minimumGrossReductionRate: 0.2
 };
 const CONTEXT_GC_START_RATIO = 0.5;
 const HIGH_WATER_GROSS_REDUCTION_START_RATIO = 0.7;
 const HIGH_WATER_MINIMUM_GROSS_REDUCTION_RATE = 0.1;
 const MINIMUM_CONTEXT_WINDOW_REDUCTION_RATIO = 0.05;
 export const COMPACT_CREDIT_ACTIVATION_RATIO = 0.8;
-export const COMPACT_THRESHOLD_RATIO = 0.9;
+export const COMPACT_THRESHOLD_RATIO = AGENT_EXECUTION_POLICY.backgroundCompactionPercent / 100;
 const IMMINENT_COMPACT_CREDIT_DISCOUNT = 0.8;
 export function evaluateContextGcEconomics(input) {
     const reclaimedTokens = Math.max(0, input.reclaimedTokens);
@@ -28,49 +27,58 @@ export function evaluateContextGcEconomics(input) {
     const invalidatedCachedSuffixTokens = cacheReadTokens - preservedCachedPrefixTokens;
     const reclaimedCachedTokens = clamp(input.reclaimedCachedTokens, 0, invalidatedCachedSuffixTokens);
     const invalidatedRetainedCachedTokens = Math.max(0, invalidatedCachedSuffixTokens - reclaimedCachedTokens);
-    const cacheRebuildPenaltyCostUnits = invalidatedRetainedCachedTokens *
-        (CONTEXT_GC_POLICY.cacheWriteCostRate - CONTEXT_GC_POLICY.cacheReadCostRate);
+    // Calculate token-derived costs in cache-read units to keep exact zero exact.
+    const unitsPerNormalInput = CONTEXT_GC_POLICY.normalInputCostRate / CONTEXT_GC_POLICY.cacheReadCostRate;
+    const cacheRebuildPenalty = invalidatedRetainedCachedTokens * (unitsPerNormalInput - 1);
+    const cacheRebuildPenaltyCostUnits = cacheRebuildPenalty * CONTEXT_GC_POLICY.cacheReadCostRate;
     const reclaimedUncachedTokens = Math.max(0, reclaimedTokens - reclaimedCachedTokens);
-    const firstRolloutSavingsCostUnits = reclaimedCachedTokens * CONTEXT_GC_POLICY.cacheReadCostRate +
-        reclaimedUncachedTokens * CONTEXT_GC_POLICY.normalInputCostRate;
-    const steadyRolloutSavingsCostUnits = reclaimedTokens * CONTEXT_GC_POLICY.cacheReadCostRate;
-    const netAt = (rollouts) => input.compactDeferralCreditCostUnits -
-        cacheRebuildPenaltyCostUnits +
-        (rollouts <= 0
-            ? 0
-            : firstRolloutSavingsCostUnits + Math.max(0, rollouts - 1) * steadyRolloutSavingsCostUnits);
-    const maximumSearch = Math.max(CONTEXT_GC_POLICY.maximumPaybackRollouts + 1, 10_000);
-    const requiredPositiveNetRollouts = firstMatchingRollout(maximumSearch, (rollouts) => netAt(rollouts) > 0);
-    const requiredTargetRoiRollouts = cacheRebuildPenaltyCostUnits === 0
-        ? requiredPositiveNetRollouts
-        : firstMatchingRollout(maximumSearch, (rollouts) => netAt(rollouts) > 0 &&
-            netAt(rollouts) / cacheRebuildPenaltyCostUnits >=
-                CONTEXT_GC_POLICY.minimumCacheInvestmentRoi);
-    const targetRollouts = Number.isFinite(requiredTargetRoiRollouts)
-        ? requiredTargetRoiRollouts
-        : CONTEXT_GC_POLICY.maximumPaybackRollouts;
-    const expectedNetSavedCostUnits = netAt(targetRollouts);
-    const cacheInvestmentRoi = cacheRebuildPenaltyCostUnits === 0
-        ? 0
-        : expectedNetSavedCostUnits / cacheRebuildPenaltyCostUnits;
+    const firstRolloutSavings = reclaimedCachedTokens + reclaimedUncachedTokens * unitsPerNormalInput;
+    const steadyRolloutSavings = reclaimedTokens;
+    const netAt = (rollouts) => (rollouts <= 0
+        ? -cacheRebuildPenalty
+        : firstRolloutSavings +
+            Math.max(0, rollouts - 1) * steadyRolloutSavings -
+            cacheRebuildPenalty) +
+        input.compactDeferralCreditCostUnits / CONTEXT_GC_POLICY.cacheReadCostRate;
+    let requiredPositiveNetRollouts;
+    if (netAt(0) > 0)
+        requiredPositiveNetRollouts = 0;
+    else if (netAt(1) > 0)
+        requiredPositiveNetRollouts = 1;
+    else if (steadyRolloutSavings <= 0)
+        requiredPositiveNetRollouts = null;
+    else {
+        requiredPositiveNetRollouts = Math.max(2, Math.floor(-netAt(1) / steadyRolloutSavings) + 2);
+        if (netAt(requiredPositiveNetRollouts - 1) > 0)
+            requiredPositiveNetRollouts--;
+        else if (netAt(requiredPositiveNetRollouts) <= 0)
+            requiredPositiveNetRollouts++;
+    }
+    const expectedNetSavedCostUnits = netAt(requiredPositiveNetRollouts ?? 0) * CONTEXT_GC_POLICY.cacheReadCostRate;
     const grossReductionRate = reclaimedTokens / Math.max(1, Math.max(0, input.contextUsageTokens));
     const minimumGrossReductionRate = Math.max(0, input.minimumGrossReductionRate ?? CONTEXT_GC_POLICY.minimumGrossReductionRate);
     const minimumReclaimedTokens = Math.max(0, input.minimumReclaimedTokens ??
         Math.ceil(Math.max(0, input.contextUsageTokens) * minimumGrossReductionRate));
-    const immediate = requiredTargetRoiRollouts <= CONTEXT_GC_POLICY.immediatePaybackRollouts;
+    const usageRatio = input.contextUsageTokens / input.contextWindowTokens;
+    const thresholdPercent = AGENT_EXECUTION_POLICY.backgroundCompactionPercent;
+    const activationPercent = COMPACT_CREDIT_ACTIVATION_RATIO * 100;
+    const withinWindow = requiredPositiveNetRollouts !== null &&
+        (usageRatio <= COMPACT_CREDIT_ACTIVATION_RATIO
+            ? requiredPositiveNetRollouts <= CONTEXT_GC_POLICY.maximumPaybackRollouts
+            : requiredPositiveNetRollouts *
+                (thresholdPercent * input.contextWindowTokens - 100 * input.contextUsageTokens) <=
+                CONTEXT_GC_POLICY.maximumPaybackRollouts *
+                    (thresholdPercent - activationPercent) *
+                    input.contextWindowTokens);
     const passes = reclaimedTokens > 0 &&
         reclaimedTokens >= minimumReclaimedTokens &&
-        Number.isFinite(requiredTargetRoiRollouts) &&
-        (immediate ||
-            (requiredTargetRoiRollouts <= CONTEXT_GC_POLICY.maximumPaybackRollouts &&
-                input.contextGrowthSampleCount >= CONTEXT_GC_POLICY.minimumContextGrowthSamples &&
-                requiredTargetRoiRollouts <= input.projectedRolloutsUntilCompactAfterGc));
+        Number.isFinite(usageRatio) &&
+        usageRatio < COMPACT_THRESHOLD_RATIO &&
+        withinWindow;
     return {
         cacheRebuildPenaltyCostUnits,
         requiredPositiveNetRollouts,
-        requiredTargetRoiRollouts,
         expectedNetSavedCostUnits,
-        cacheInvestmentRoi,
         grossReductionRate,
         passes
     };
@@ -128,12 +136,6 @@ export function modelContextUsage(value) {
         ? context
         : undefined;
 }
-function firstMatchingRollout(limit, predicate) {
-    for (let rollouts = 0; rollouts <= limit; rollouts++)
-        if (predicate(rollouts))
-            return rollouts;
-    return Number.POSITIVE_INFINITY;
-}
 export function clamp(value, minimum, maximum) {
     return Math.min(maximum, Math.max(minimum, value));
 }

package/dist/runtime/context/gc.js

@@ -181,19 +181,13 @@ function finalizePlan(input, evaluated, includeMedia = false) {
         compactDeferralCreditCostUnits: evaluated.compactDeferralCreditCostUnits,
         imminentCompactAvoidanceCreditCostUnits: evaluated.imminentCompactAvoidanceCreditCostUnits,
         appliedCompactCreditCostUnits: evaluated.appliedCompactCreditCostUnits,
-        requiredPositiveNetRollouts: Number.isFinite(evaluated.economics.requiredPositiveNetRollouts)
-            ? evaluated.economics.requiredPositiveNetRollouts
-            : null,
-        requiredTargetRoiRollouts: Number.isFinite(evaluated.economics.requiredTargetRoiRollouts)
-            ? evaluated.economics.requiredTargetRoiRollouts
-            : null,
+        requiredPositiveNetRollouts: evaluated.economics.requiredPositiveNetRollouts,
         projectedRolloutsUntilCompactAfterGc: evaluated.projectedRolloutsUntilCompactAfterGc,
         projectedTokensBeforeGc: evaluated.projectedTokensBeforeGc,
         projectedTokensAfterGc: evaluated.projectedTokensAfterGc,
         contextGrowthSampleCount: evaluated.contextGrowthSamples.length,
         contextGrowthP75Tokens: evaluated.contextGrowthP75Tokens,
         expectedNetSavedCostUnits: evaluated.economics.expectedNetSavedCostUnits,
-        cacheInvestmentRoi: evaluated.economics.cacheInvestmentRoi,
         minimumObservedRollouts: evaluated.minimumObservedRollouts,
         protectedCandidateTokens: evaluated.protectedCandidateTokens,
         eligibleCandidateCount: evaluated.eligibleCandidateCount,
@@ -254,8 +248,6 @@ function evaluateCandidateSet(input, existing, candidates, state, mediaProjectio
     const pendingTokens = Math.max(0, input.usage.outputTokens ?? 0) + contextGcMessageTokens(input, pendingMessages);
     const projectedTokensBeforeGc = state.contextUsageTokens + pendingTokens;
     const projectedTokensAfterGc = Math.max(0, projectedTokensBeforeGc - reclaimedTokens);
-    if (!state.mediaOnly && projectedTokensAfterGc >= compactThresholdTokens)
-        return undefined;
     const projectedRolloutsUntilCompactAfterGc = contextGrowthP75Tokens <= 0
         ? 0
         : Math.max(0, Math.floor((compactThresholdTokens - projectedTokensAfterGc) / Math.max(1, contextGrowthP75Tokens)));
@@ -273,6 +265,7 @@ function evaluateCandidateSet(input, existing, candidates, state, mediaProjectio
     const appliedCompactCreditCostUnits = contextGcAppliedCompactCreditCostUnits(compactDeferralCreditCostUnits, imminentCompactAvoidanceCreditCostUnits);
     const economics = evaluateContextGcEconomics({
         contextUsageTokens: state.contextUsageTokens,
+        contextWindowTokens: input.contextWindowTokens,
         reclaimedTokens,
         reclaimedCachedTokens: cache.reclaimedCachedTokens,
         cacheReadTokens: input.usage.cacheReadTokens ?? 0,
@@ -382,20 +375,15 @@ function compactDeferralCredit(input, reclaimedTokens, compactThresholdTokens) {
     const usage = compact.payload.usage;
     const contextInput = modelContextUsage(usage);
     const cacheRead = nonnegativeNumber(usage.cacheReadTokens);
-    const cacheWrite = nonnegativeNumber(usage.cacheWriteTokens);
     const output = nonnegativeNumber(usage.outputTokens);
-    if (contextInput === undefined ||
-        cacheRead === undefined ||
-        cacheWrite === undefined ||
-        output === undefined)
+    if (contextInput === undefined || cacheRead === undefined || output === undefined)
         return 0;
     const baseline = firstMatchingUsageAfter(input.records, compact.sequence, input.modelId, input.contextWindowTokens);
     if (baseline === undefined || baseline >= compactThresholdTokens)
         return 0;
-    const fresh = Math.max(0, contextInput - cacheRead - cacheWrite);
+    const fresh = Math.max(0, contextInput - cacheRead);
     const compactCost = fresh * CONTEXT_GC_POLICY.normalInputCostRate +
         cacheRead * CONTEXT_GC_POLICY.cacheReadCostRate +
-        cacheWrite * CONTEXT_GC_POLICY.cacheWriteCostRate +
         output * CONTEXT_GC_POLICY.outputCostRate;
     const cycleCapacity = Math.max(1, compactThresholdTokens - baseline);
     return compactCost * clamp(reclaimedTokens / cycleCapacity, 0, 1);

package/dist/sdk/execution-compact-commit.d.ts

@@ -2,6 +2,7 @@ import type { SessionModelMessage } from '../session/model-request.js';
 import type { SessionRecord } from '../session/record-contract.js';
 import type { SessionStore, SessionStoreCompactInput } from '../session/store/contracts.js';
 import type { ResourceInputProjection } from './resource-input.js';
+import { compactRetainedStart } from '../runtime/compaction/retained-context.js';
 /** Commits one validated snapshot and records its fact before fallible live projection. */
 export declare function commitExecutionCompaction(input: {
     readonly store: Pick<SessionStore, 'compact'>;
@@ -9,9 +10,10 @@ export declare function commitExecutionCompaction(input: {
     readonly signal: AbortSignal;
     readonly prefix: readonly SessionModelMessage[];
     readonly messages: readonly SessionModelMessage[];
+    readonly model: Parameters<typeof compactRetainedStart>[2];
     readonly generation: string | undefined;
     readonly messageSources: WeakMap<SessionModelMessage, SessionRecord>;
-    draft(): Omit<SessionStoreCompactInput, 'retainedModelContext' | 'inlineMediaState'>;
+    draft(retainedStart: number): Omit<SessionStoreCompactInput, 'retainedModelContext' | 'inlineMediaState'>;
     readonly checkpoint: ResourceInputProjection['checkpoint'];
     readonly withProjection: <T>(action: () => Promise<T>) => Promise<T>;
     readonly currentGeneration: () => string | undefined;
@@ -20,4 +22,4 @@ export declare function commitExecutionCompaction(input: {
 }): Promise<{
     record: SessionRecord;
     retained: SessionModelMessage[];
-}>;
+} | undefined>;

package/dist/sdk/execution-compact-commit.js

@@ -1,4 +1,5 @@
 import { AgentError } from '../error.js';
+import { compactRetainedStart } from '../runtime/compaction/retained-context.js';
 /** Commits one validated snapshot and records its fact before fallible live projection. */
 export async function commitExecutionCompaction(input) {
     return input.withProjection(async () => {
@@ -6,14 +7,17 @@ export async function commitExecutionCompaction(input) {
         if (input.currentGeneration() !== input.generation ||
             input.prefix.some((message, index) => input.messages[index] !== message))
             throw new AgentError('MAR_AGENT_COMPACT_STALE', 'The compaction prefix has changed.');
+        const retainedStart = compactRetainedStart(input.messages, input.prefix.length, input.model);
+        if (retainedStart === 0)
+            return undefined;
         const retained = input.messages
-            .slice(input.prefix.length)
+            .slice(retainedStart)
             .filter((message) => message.contextKind !== 'private' || message.role === 'provider');
         const retainedModelContext = retained.map((message) => {
             const source = input.messageSources.get(message);
             const saved = source?.type === 'model.context' && source.payload.inputRef
                 ? source.payload
-                : source?.type === 'compact.completed'
+                : source?.type === 'compact.completed' && message.metadata?.recordId !== undefined
                     ? (source.payload
                         .retainedModelContext ?? []).find((item) => item.inputRef === message.metadata?.recordId)
                     : undefined;
@@ -30,7 +34,7 @@ export async function commitExecutionCompaction(input) {
                 };
         });
         const record = await input.store.compact(input.sessionId, {
-            ...input.draft(),
+            ...input.draft(retainedStart),
             inlineMediaState: input.checkpoint(retained),
             retainedModelContext
         }, { signal: input.signal });

package/dist/sdk/execution-compaction.d.ts

@@ -17,7 +17,7 @@ export declare function createExecutionCompaction(ports: {
     readonly sessionId: string;
     readonly executionId: string;
     readonly turnId: string;
-    readonly model: Pick<ResolvedModelConfiguration, 'id' | 'contextWindowTokens'>;
+    readonly model: Pick<ResolvedModelConfiguration, 'id' | 'protocol' | 'contextWindowTokens'>;
     readonly messages: SessionModelMessage[];
     readonly pendingInputs: Map<string, SessionRecord>;
     readonly messageSources: WeakMap<SessionModelMessage, SessionRecord>;

package/dist/sdk/execution-compaction.js

@@ -17,7 +17,6 @@ export function createExecutionCompaction(ports) {
             message.contextKind === 'summary'))
             return false;
         const history = structuredClone(prefix).map(({ images: _images, ...message }) => message);
-        const prefixInputs = modelContext.compactInputs(prefix);
         const tools = structuredClone(ports.snapshotTools());
         const generation = modelContext.worldState.generation;
         const usage = ports.usage();
@@ -62,7 +61,7 @@ export function createExecutionCompaction(ports) {
         await prepare();
         signal.throwIfAborted();
         const resources = await ports.retainedResources();
-        const replacementHistory = buildCompactedHistory(candidate.summary, prefixInputs, ports.userTokenLimit);
+        let replacementHistory;
         let committed = false;
         let retained;
         try {
@@ -72,6 +71,7 @@ export function createExecutionCompaction(ports) {
                 signal,
                 prefix,
                 messages,
+                model: ports.model,
                 generation,
                 messageSources: ports.messageSources,
                 checkpoint: (value) => ports.resourceInput.checkpoint(value),
@@ -85,21 +85,26 @@ export function createExecutionCompaction(ports) {
                     modelContext.replaceCompactMessages(replacementHistory, value);
                     ports.updateBoundary(messages.length - value.length);
                 },
-                draft: () => ({
-                    summary: candidate.summary,
-                    replacementHistory,
-                    pendingInputs: [...ports.pendingInputs.values()],
-                    snapshotMessageCount: prefix.length,
-                    ...(anchorRecordId ? { snapshotRecordId: anchorRecordId } : {}),
-                    automatic: ports.mode !== 'compact',
-                    environment: ports.environment(),
-                    modelId: ports.model.id,
-                    contextWindowTokens: ports.model.contextWindowTokens,
-                    ...(candidate.usage === undefined ? {} : { usage: candidate.usage }),
-                    executionId: ports.executionId,
-                    turnId: ports.turnId
-                })
+                draft: (retainedStart) => {
+                    replacementHistory = buildCompactedHistory(candidate.summary, modelContext.compactInputs(prefix.slice(0, retainedStart)), ports.userTokenLimit);
+                    return {
+                        summary: candidate.summary,
+                        replacementHistory,
+                        pendingInputs: [...ports.pendingInputs.values()],
+                        snapshotMessageCount: prefix.length,
+                        ...(anchorRecordId ? { snapshotRecordId: anchorRecordId } : {}),
+                        automatic: ports.mode !== 'compact',
+                        environment: ports.environment(),
+                        modelId: ports.model.id,
+                        contextWindowTokens: ports.model.contextWindowTokens,
+                        ...(candidate.usage === undefined ? {} : { usage: candidate.usage }),
+                        executionId: ports.executionId,
+                        turnId: ports.turnId
+                    };
+                }
             });
+            if (!result)
+                return false;
             retained = result.retained;
             await modelContext.adoptCompactCheckpoint(result.record.recordId, replacementHistory, retained, resources);
             ports.invalidateUsage();

package/dist/sdk/session-execution-factory.js

@@ -165,7 +165,8 @@ export function createSessionExecutionFactory(ports) {
                 const compactMayContainAgentInstructions = contextRecords.some((record) => compactSummaryFromCheckpoint(record) !== undefined);
                 const restored = await restoreMessages(store, sessionId, contextRecords, {
                     messageSources,
-                    includeImages: mode !== 'compact'
+                    // Keep durable references for the retained tail; the Compact snapshot removes images.
+                    includeImages: true
                 });
                 let modelLifecycle;
                 let applyCompactBoundary = () => { };

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

@@ -1113,11 +1113,10 @@ function isContextGcEconomicsPolicy(value) {
         [
             'normalInputCostRate',
             'cacheReadCostRate',
-            'cacheWriteCostRate',
             'outputCostRate',
-            'minimumGrossReductionRate',
-            'minimumCacheInvestmentRoi'
-        ].every((key) => isNonnegativeFinite(value[key])));
+            'minimumGrossReductionRate'
+        ].every((key) => isNonnegativeFinite(value[key])) &&
+        ['cacheWriteCostRate', 'minimumCacheInvestmentRoi'].every((key) => value[key] === undefined || isNonnegativeFinite(value[key])));
 }
 function isContextGcMetrics(value) {
     if (!isRecord(value) ||
@@ -1150,10 +1149,13 @@ function isContextGcMetrics(value) {
         'projectedTokensAfterGc'
     ];
     return (nonnegative.every((key) => isNonnegativeFinite(value[key])) &&
-        ['requiredPositiveNetRollouts', 'requiredTargetRoiRollouts'].every((key) => isNonnegativeFinite(value[key]) || (value.stage === 'INLINE_MEDIA' && value[key] === null)) &&
+        [
+            'requiredPositiveNetRollouts',
+            ...(value.requiredTargetRoiRollouts === undefined ? [] : ['requiredTargetRoiRollouts'])
+        ].every((key) => isNonnegativeFinite(value[key]) || (value.stage === 'INLINE_MEDIA' && value[key] === null)) &&
         optionalNonnegative.every((key) => value[key] === undefined || isNonnegativeFinite(value[key])) &&
         Number.isFinite(value.expectedNetSavedCostUnits) &&
-        Number.isFinite(value.cacheInvestmentRoi) &&
+        (value.cacheInvestmentRoi === undefined || Number.isFinite(value.cacheInvestmentRoi)) &&
         (value.tokenEstimator === undefined || value.tokenEstimator === 'UTF8_BYTES_V1') &&
         (value.cachePenaltyKnown === undefined || typeof value.cachePenaltyKnown === 'boolean'));
 }

package/dist/session/context-gc-contract.d.ts

@@ -13,10 +13,10 @@ export interface ContextGcEconomicsPolicy {
     readonly largeExecProtectionRollouts: number;
     readonly normalInputCostRate: number;
     readonly cacheReadCostRate: number;
-    readonly cacheWriteCostRate: number;
+    readonly cacheWriteCostRate?: number;
     readonly outputCostRate: number;
     readonly minimumGrossReductionRate: number;
-    readonly minimumCacheInvestmentRoi: number;
+    readonly minimumCacheInvestmentRoi?: number;
 }
 export type ContextGcBase = {
     readonly type: 'SESSION_START';
@@ -112,14 +112,14 @@ export interface ContextGcMetrics {
     readonly imminentCompactAvoidanceCreditCostUnits?: number;
     readonly appliedCompactCreditCostUnits?: number;
     readonly requiredPositiveNetRollouts: number | null;
-    readonly requiredTargetRoiRollouts: number | null;
+    readonly requiredTargetRoiRollouts?: number | null;
     readonly projectedRolloutsUntilCompactAfterGc: number;
     readonly projectedTokensBeforeGc?: number;
     readonly projectedTokensAfterGc?: number;
     readonly contextGrowthSampleCount: number;
     readonly contextGrowthP75Tokens: number;
     readonly expectedNetSavedCostUnits: number;
-    readonly cacheInvestmentRoi: number;
+    readonly cacheInvestmentRoi?: number;
     readonly minimumObservedRollouts: number;
     readonly protectedCandidateTokens: number;
     readonly eligibleCandidateCount: number;

package/package.json

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