@myagentroam/agent 0.11.56 → 0.11.58

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

@@ -1,7 +1,6 @@
 import type { ModelUsage } from '../../model/contracts.js';
 export declare const CONTEXT_GC_POLICY: {
     version: 1;
-    immediatePaybackRollouts: number;
     minimumPaybackRollouts: number;
     maximumPaybackRollouts: number;
     contextGrowthSampleWindow: number;
@@ -11,10 +10,7 @@ export declare const CONTEXT_GC_POLICY: {
     largeExecProtectionRollouts: number;
     normalInputCostRate: number;
     cacheReadCostRate: number;
-    outputCostRate: number;
-    minimumGrossReductionRate: number;
 };
-export declare const COMPACT_CREDIT_ACTIVATION_RATIO = 0.8;
 export declare const COMPACT_THRESHOLD_RATIO: number;
 interface ContextGcEconomicsInput {
     readonly contextUsageTokens: number;
@@ -23,11 +19,6 @@ interface ContextGcEconomicsInput {
     readonly reclaimedCachedTokens: number;
     readonly cacheReadTokens: number;
     readonly preservedCachedPrefixTokens: number;
-    readonly compactDeferralCreditCostUnits: number;
-    readonly projectedRolloutsUntilCompactAfterGc: number;
-    readonly contextGrowthSampleCount: number;
-    readonly minimumGrossReductionRate?: number;
-    readonly minimumReclaimedTokens?: number;
 }
 export interface ContextGcEconomicsResult {
     readonly cacheRebuildPenaltyCostUnits: number;
@@ -37,18 +28,8 @@ export interface ContextGcEconomicsResult {
     readonly passes: boolean;
 }
 export declare function evaluateContextGcEconomics(input: ContextGcEconomicsInput): ContextGcEconomicsResult;
-export declare function contextGcMinimumGrossReductionRate(usageRatio: number): number;
-export declare function contextGcMinimumReclaimedTokens(contextUsageTokens: number, contextWindowTokens: number): number;
+export declare function contextGcMinimumReclaimedTokens(contextWindowTokens: number): number;
 export declare function contextGcEligibleUsage(usage: ModelUsage, contextWindowTokens: number): number | undefined;
-export declare function contextGcImminentCompactAvoidanceCredit(input: {
-    readonly contextUsageTokens: number;
-    readonly contextWindowTokens: number;
-    readonly compactThresholdTokens: number;
-    readonly projectedTokensBeforeGc: number;
-    readonly projectedTokensAfterGc: number;
-    readonly contextGrowthP75Tokens: number;
-}): number;
-export declare function contextGcAppliedCompactCreditCostUnits(compactDeferralCreditCostUnits: number, imminentCompactAvoidanceCreditCostUnits: number): number;
 export declare function modelContextUsage(value: ModelUsage | Record<string, unknown>): number | undefined;
 export declare function clamp(value: number, minimum: number, maximum: number): number;
 export {};

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

@@ -2,7 +2,6 @@ import { AGENT_EXECUTION_POLICY } from '../execution-policy.js';
 import { CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS } from '../../session/context-gc-protection.js';
 export const CONTEXT_GC_POLICY = {
     version: 1,
-    immediatePaybackRollouts: 3,
     minimumPaybackRollouts: 30,
     maximumPaybackRollouts: 60,
     contextGrowthSampleWindow: 16,
@@ -11,17 +10,10 @@ export const CONTEXT_GC_POLICY = {
     stageAProtectionRollouts: CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS,
     largeExecProtectionRollouts: CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS,
     normalInputCostRate: 1,
-    cacheReadCostRate: 0.05,
-    outputCostRate: 1,
-    minimumGrossReductionRate: 0.2
+    cacheReadCostRate: 0.05
 };
 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 = AGENT_EXECUTION_POLICY.backgroundCompactionPercent / 100;
-const IMMINENT_COMPACT_CREDIT_DISCOUNT = 0.8;
 export function evaluateContextGcEconomics(input) {
     const reclaimedTokens = Math.max(0, input.reclaimedTokens);
     const cacheReadTokens = Math.max(0, input.cacheReadTokens);
@@ -55,9 +47,7 @@ export function evaluateContextGcEconomics(input) {
     }
     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 minimumReclaimedTokens = contextGcMinimumReclaimedTokens(input.contextWindowTokens);
     const usageRatio = input.contextUsageTokens / input.contextWindowTokens;
     const progress = clamp((usageRatio - CONTEXT_GC_START_RATIO) / (COMPACT_THRESHOLD_RATIO - CONTEXT_GC_START_RATIO), 0, 1);
     const paybackWindow = CONTEXT_GC_POLICY.minimumPaybackRollouts +
@@ -78,26 +68,8 @@ export function evaluateContextGcEconomics(input) {
         passes
     };
 }
-export function contextGcMinimumGrossReductionRate(usageRatio) {
-    if (!Number.isFinite(usageRatio) || usageRatio <= HIGH_WATER_GROSS_REDUCTION_START_RATIO)
-        return CONTEXT_GC_POLICY.minimumGrossReductionRate;
-    if (usageRatio >= COMPACT_THRESHOLD_RATIO)
-        return HIGH_WATER_MINIMUM_GROSS_REDUCTION_RATE;
-    const progress = (usageRatio - HIGH_WATER_GROSS_REDUCTION_START_RATIO) /
-        (COMPACT_THRESHOLD_RATIO - HIGH_WATER_GROSS_REDUCTION_START_RATIO);
-    return (CONTEXT_GC_POLICY.minimumGrossReductionRate -
-        progress *
-            (CONTEXT_GC_POLICY.minimumGrossReductionRate - HIGH_WATER_MINIMUM_GROSS_REDUCTION_RATE));
-}
-export function contextGcMinimumReclaimedTokens(contextUsageTokens, contextWindowTokens) {
-    if (!Number.isFinite(contextUsageTokens) ||
-        contextUsageTokens < 0 ||
-        !Number.isFinite(contextWindowTokens) ||
-        contextWindowTokens <= 0)
-        return 0;
-    const usageRatio = contextUsageTokens / contextWindowTokens;
-    const required = Math.max(contextUsageTokens * contextGcMinimumGrossReductionRate(usageRatio), contextWindowTokens * MINIMUM_CONTEXT_WINDOW_REDUCTION_RATIO);
-    return Math.ceil(required - 1e-9);
+export function contextGcMinimumReclaimedTokens(contextWindowTokens) {
+    return Math.ceil(contextWindowTokens / 20);
 }
 export function contextGcEligibleUsage(usage, contextWindowTokens) {
     const contextUsageTokens = modelContextUsage(usage);
@@ -110,21 +82,6 @@ export function contextGcEligibleUsage(usage, contextWindowTokens) {
         return undefined;
     return contextUsageTokens;
 }
-export function contextGcImminentCompactAvoidanceCredit(input) {
-    if (input.contextUsageTokens >= input.compactThresholdTokens ||
-        input.contextGrowthP75Tokens <= 0 ||
-        input.projectedTokensBeforeGc < input.compactThresholdTokens)
-        return 0;
-    const safetyMarginTokens = Math.max(input.contextWindowTokens * MINIMUM_CONTEXT_WINDOW_REDUCTION_RATIO, input.contextGrowthP75Tokens * CONTEXT_GC_POLICY.immediatePaybackRollouts);
-    if (input.projectedTokensAfterGc > input.compactThresholdTokens - safetyMarginTokens)
-        return 0;
-    return (input.contextUsageTokens *
-        CONTEXT_GC_POLICY.normalInputCostRate *
-        IMMINENT_COMPACT_CREDIT_DISCOUNT);
-}
-export function contextGcAppliedCompactCreditCostUnits(compactDeferralCreditCostUnits, imminentCompactAvoidanceCreditCostUnits) {
-    return Math.max(0, compactDeferralCreditCostUnits, imminentCompactAvoidanceCreditCostUnits);
-}
 export function modelContextUsage(value) {
     const context = value.contextInputTokens ?? value.inputTokens;
     return typeof context === 'number' && Number.isSafeInteger(context) && context >= 0

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

@@ -1,5 +1,5 @@
 import { type ContextGcPlan, type ContextGcInspection, type ContextGcPlannerInput } from './gc-contracts.js';
-export { CONTEXT_GC_POLICY, type ContextGcEconomicsResult, evaluateContextGcEconomics, contextGcMinimumGrossReductionRate, contextGcMinimumReclaimedTokens, contextGcEligibleUsage, contextGcImminentCompactAvoidanceCredit, contextGcAppliedCompactCreditCostUnits } from './gc-economics.js';
+export { CONTEXT_GC_POLICY, type ContextGcEconomicsResult, evaluateContextGcEconomics, contextGcMinimumReclaimedTokens, contextGcEligibleUsage } from './gc-economics.js';
 export { type ContextGcPlan, type ContextGcInspection, type ContextGcPlannerInput } from './gc-contracts.js';
 export declare function planContextGc(input: ContextGcPlannerInput): ContextGcPlan | undefined;
 export declare function inspectContextGc(input: ContextGcPlannerInput): ContextGcInspection;

package/dist/runtime/context/gc.js

@@ -2,13 +2,13 @@ import { ContextGcCheckpointCache, contextGcBaseFromRecords, contextGcCheckpoint
 import { buildContextGcProtection } from '../../session/context-gc-protection.js';
 import { CONTEXT_GC_TOKEN_ESTIMATOR, contextGcCacheImpact, contextGcMessageTokens, contextGcPrefixTokens, contextGcReclaimedTokens } from './gc-tokens.js';
 import { applyContextGcReplacementsToMessages, providerToolCallId } from './projection.js';
-import { CONTEXT_GC_POLICY, COMPACT_CREDIT_ACTIVATION_RATIO, COMPACT_THRESHOLD_RATIO, evaluateContextGcEconomics, contextGcMinimumGrossReductionRate, contextGcMinimumReclaimedTokens, contextGcEligibleUsage, contextGcImminentCompactAvoidanceCredit, modelContextUsage, clamp } from './gc-economics.js';
+import { CONTEXT_GC_POLICY, COMPACT_THRESHOLD_RATIO, evaluateContextGcEconomics, contextGcMinimumReclaimedTokens, contextGcEligibleUsage, modelContextUsage } from './gc-economics.js';
 import { buildToolGroups, countSuccessfulNormalRollouts, isRecord } from './gc-candidates.js';
 import { collectCodeModeCandidates } from './gc-candidates-code.js';
 import { collectDeterministicCandidates } from './gc-candidates-read-patch.js';
 import { collectExecCandidates } from './gc-candidates-exec.js';
 import { collectToolOutputCandidates, collectWebCandidates } from './gc-candidates-web.js';
-export { CONTEXT_GC_POLICY, evaluateContextGcEconomics, contextGcMinimumGrossReductionRate, contextGcMinimumReclaimedTokens, contextGcEligibleUsage, contextGcImminentCompactAvoidanceCredit, contextGcAppliedCompactCreditCostUnits } from './gc-economics.js';
+export { CONTEXT_GC_POLICY, evaluateContextGcEconomics, contextGcMinimumReclaimedTokens, contextGcEligibleUsage } from './gc-economics.js';
 export function planContextGc(input) {
     return inspectContextGc(input).plan;
 }
@@ -31,7 +31,6 @@ export function inspectContextGc(input) {
     const state = {
         stage: text.plan?.stage ?? 'INLINE_MEDIA',
         contextUsageTokens,
-        usageRatio: contextUsageTokens / input.contextWindowTokens,
         usageRecord,
         normalRolloutOrdinal: countSuccessfulNormalRollouts(input.records, input.modelId, input.contextWindowTokens),
         protectedCandidateTokens: text.plan?.metrics.protectedCandidateTokens ?? 0
@@ -73,7 +72,6 @@ function inspectTextGc(input) {
         checkpointCache: input.checkpointCache ?? new ContextGcCheckpointCache(),
         protection: buildContextGcProtection(input.records, input.modelId, input.contextWindowTokens)
     };
-    const usageRatio = contextUsageTokens / input.contextWindowTokens;
     const usageRecord = latestUsageRecord(input.records, input.modelId);
     if (!usageRecord)
         return {};
@@ -129,7 +127,6 @@ function inspectTextGc(input) {
     ], {
         stage: 'UNIFIED',
         contextUsageTokens,
-        usageRatio,
         usageRecord,
         normalRolloutOrdinal,
         protectedCandidateTokens
@@ -148,8 +145,7 @@ function inspectTextGc(input) {
     }
     return protectedCandidateTokens > 0 &&
         (combined?.economics.passes ||
-            protectedCandidateTokens >=
-                contextGcMinimumReclaimedTokens(contextUsageTokens, input.contextWindowTokens)) &&
+            protectedCandidateTokens >= contextGcMinimumReclaimedTokens(input.contextWindowTokens)) &&
         Number.isFinite(retryAfterRollouts)
         ? { retryAfterRollouts }
         : {};
@@ -175,12 +171,8 @@ function finalizePlan(input, evaluated, includeMedia = false) {
         afterTokens: evaluated.afterTokens,
         reclaimedTokens: evaluated.reclaimedTokens,
         grossReductionRate: evaluated.economics.grossReductionRate,
-        effectiveMinimumGrossReductionRate: evaluated.minimumGrossReductionRate,
         minimumRequiredReclaimedTokens: evaluated.minimumReclaimedTokens,
         cacheRebuildPenaltyCostUnits: evaluated.economics.cacheRebuildPenaltyCostUnits,
-        compactDeferralCreditCostUnits: evaluated.compactDeferralCreditCostUnits,
-        imminentCompactAvoidanceCreditCostUnits: evaluated.imminentCompactAvoidanceCreditCostUnits,
-        appliedCompactCreditCostUnits: evaluated.appliedCompactCreditCostUnits,
         requiredPositiveNetRollouts: evaluated.economics.requiredPositiveNetRollouts,
         projectedRolloutsUntilCompactAfterGc: evaluated.projectedRolloutsUntilCompactAfterGc,
         projectedTokensBeforeGc: evaluated.projectedTokensBeforeGc,
@@ -231,8 +223,7 @@ function evaluateCandidateSet(input, existing, candidates, state, mediaProjectio
     const projected = applyContextGcReplacementsToMessages(input.messages, input.messageSources, replacements);
     const projectedMessages = mediaProjection?.(projected.messages) ?? projected.messages;
     const reclaimedTokens = contextGcReclaimedTokens(input, input.messages, projectedMessages);
-    const minimumGrossReductionRate = contextGcMinimumGrossReductionRate(state.usageRatio);
-    const minimumReclaimedTokens = contextGcMinimumReclaimedTokens(state.contextUsageTokens, input.contextWindowTokens);
+    const minimumReclaimedTokens = contextGcMinimumReclaimedTokens(input.contextWindowTokens);
     if (!state.mediaOnly && reclaimedTokens < minimumReclaimedTokens)
         return undefined;
     const beforeTokens = contextGcPrefixTokens(input) + contextGcMessageTokens(input, input.messages);
@@ -251,31 +242,13 @@ function evaluateCandidateSet(input, existing, candidates, state, mediaProjectio
     const projectedRolloutsUntilCompactAfterGc = contextGrowthP75Tokens <= 0
         ? 0
         : Math.max(0, Math.floor((compactThresholdTokens - projectedTokensAfterGc) / Math.max(1, contextGrowthP75Tokens)));
-    const compactDeferralCreditCostUnits = state.usageRatio >= COMPACT_CREDIT_ACTIVATION_RATIO
-        ? compactDeferralCredit(input, reclaimedTokens, compactThresholdTokens)
-        : 0;
-    const imminentCompactAvoidanceCreditCostUnits = contextGcImminentCompactAvoidanceCredit({
-        contextUsageTokens: state.contextUsageTokens,
-        contextWindowTokens: input.contextWindowTokens,
-        compactThresholdTokens,
-        projectedTokensBeforeGc,
-        projectedTokensAfterGc,
-        contextGrowthP75Tokens
-    });
-    // Compact estimates remain diagnostic; only normal-request savings repay GC.
-    const appliedCompactCreditCostUnits = 0;
     const economics = evaluateContextGcEconomics({
         contextUsageTokens: state.contextUsageTokens,
         contextWindowTokens: input.contextWindowTokens,
         reclaimedTokens,
         reclaimedCachedTokens: cache.reclaimedCachedTokens,
         cacheReadTokens: input.usage.cacheReadTokens ?? 0,
-        preservedCachedPrefixTokens: cache.preservedCachedPrefixTokens,
-        compactDeferralCreditCostUnits: appliedCompactCreditCostUnits,
-        projectedRolloutsUntilCompactAfterGc,
-        contextGrowthSampleCount: growthSamples.length,
-        minimumGrossReductionRate,
-        minimumReclaimedTokens
+        preservedCachedPrefixTokens: cache.preservedCachedPrefixTokens
     });
     return {
         ...state,
@@ -287,14 +260,10 @@ function evaluateCandidateSet(input, existing, candidates, state, mediaProjectio
         reclaimedTokens,
         contextGrowthSamples: growthSamples,
         contextGrowthP75Tokens,
-        minimumGrossReductionRate,
         minimumReclaimedTokens,
         projectedRolloutsUntilCompactAfterGc,
         projectedTokensBeforeGc,
         projectedTokensAfterGc,
-        compactDeferralCreditCostUnits,
-        imminentCompactAvoidanceCreditCostUnits,
-        appliedCompactCreditCostUnits,
         boundarySequence: input.records.at(-1)?.sequence ?? state.usageRecord.sequence,
         minimumObservedRollouts: Math.min(...candidates.map((candidate) => candidate.observedRollouts)),
         eligibleCandidateCount: candidates.length
@@ -362,59 +331,6 @@ function collectContextGrowthSamples(records, modelId, contextWindowTokens, chec
     }
     return samples.slice(-CONTEXT_GC_POLICY.contextGrowthSampleWindow);
 }
-function compactDeferralCredit(input, reclaimedTokens, compactThresholdTokens) {
-    const base = contextGcBaseFromRecords(input.records);
-    if (base?.type !== 'COMPACT')
-        return 0;
-    const compact = input.records.find((record) => record.sequence === base.sequence);
-    if (!compact || !isRecord(compact.payload))
-        return 0;
-    if (compact.payload.modelId !== input.modelId ||
-        compact.payload.contextWindowTokens !== input.contextWindowTokens ||
-        !isRecord(compact.payload.usage))
-        return 0;
-    const usage = compact.payload.usage;
-    const contextInput = modelContextUsage(usage);
-    const cacheRead = nonnegativeNumber(usage.cacheReadTokens);
-    const output = nonnegativeNumber(usage.outputTokens);
-    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);
-    const compactCost = fresh * CONTEXT_GC_POLICY.normalInputCostRate +
-        cacheRead * CONTEXT_GC_POLICY.cacheReadCostRate +
-        output * CONTEXT_GC_POLICY.outputCostRate;
-    const cycleCapacity = Math.max(1, compactThresholdTokens - baseline);
-    return compactCost * clamp(reclaimedTokens / cycleCapacity, 0, 1);
-}
-function firstMatchingUsageAfter(records, sequence, modelId, contextWindowTokens) {
-    let activeModelId = modelId;
-    let activeContextWindowTokens = contextWindowTokens;
-    for (const record of records) {
-        if (record.sequence <= sequence)
-            continue;
-        if (record.type === 'execution.header' && isRecord(record.payload)) {
-            if (typeof record.payload.modelId === 'string')
-                activeModelId = record.payload.modelId;
-            if (typeof record.payload.contextWindowTokens === 'number' &&
-                Number.isSafeInteger(record.payload.contextWindowTokens) &&
-                record.payload.contextWindowTokens > 0)
-                activeContextWindowTokens = record.payload.contextWindowTokens;
-            continue;
-        }
-        if (activeModelId !== modelId ||
-            activeContextWindowTokens !== contextWindowTokens ||
-            !isRecord(record.payload) ||
-            record.payload.type !== 'usage.updated')
-            continue;
-        const usage = modelContextUsage(record.payload);
-        if (usage !== undefined)
-            return usage;
-    }
-    return undefined;
-}
 /** Measure only affected call families, retaining native aliases for provider lowering. */
 function createCandidateSavingsEstimator(input, existing) {
     const byCall = new Map();
@@ -467,6 +383,3 @@ function percentile75(values) {
     const sorted = [...values].sort((left, right) => left - right);
     return sorted[Math.max(0, Math.ceil(sorted.length * 0.75) - 1)];
 }
-function nonnegativeNumber(value) {
-    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
-}

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

@@ -1102,7 +1102,6 @@ function isContextGcEconomicsPolicy(value) {
     return (isRecord(value) &&
         value.version === 1 &&
         [
-            'immediatePaybackRollouts',
             'maximumPaybackRollouts',
             'contextGrowthSampleWindow',
             'minimumContextGrowthSamples',
@@ -1110,15 +1109,14 @@ function isContextGcEconomicsPolicy(value) {
             'stageAProtectionRollouts',
             'largeExecProtectionRollouts'
         ].every((key) => isNonnegativeInteger(value[key])) &&
-        (value.minimumPaybackRollouts === undefined ||
-            isNonnegativeInteger(value.minimumPaybackRollouts)) &&
+        ['minimumPaybackRollouts', 'immediatePaybackRollouts'].every((key) => value[key] === undefined || isNonnegativeInteger(value[key])) &&
+        ['normalInputCostRate', 'cacheReadCostRate'].every((key) => isNonnegativeFinite(value[key])) &&
         [
-            'normalInputCostRate',
-            'cacheReadCostRate',
-            'outputCostRate',
-            'minimumGrossReductionRate'
-        ].every((key) => isNonnegativeFinite(value[key])) &&
-        ['cacheWriteCostRate', 'minimumCacheInvestmentRoi'].every((key) => value[key] === undefined || isNonnegativeFinite(value[key])));
+            'cacheWriteCostRate',
+            'minimumCacheInvestmentRoi',
+            'minimumGrossReductionRate',
+            'outputCostRate'
+        ].every((key) => value[key] === undefined || isNonnegativeFinite(value[key])));
 }
 function isContextGcMetrics(value) {
     if (!isRecord(value) ||
@@ -1133,7 +1131,6 @@ function isContextGcMetrics(value) {
         'reclaimedTokens',
         'grossReductionRate',
         'cacheRebuildPenaltyCostUnits',
-        'compactDeferralCreditCostUnits',
         'projectedRolloutsUntilCompactAfterGc',
         'contextGrowthSampleCount',
         'contextGrowthP75Tokens',
@@ -1144,6 +1141,7 @@ function isContextGcMetrics(value) {
     ];
     const optionalNonnegative = [
         'effectiveMinimumGrossReductionRate',
+        'compactDeferralCreditCostUnits',
         'minimumRequiredReclaimedTokens',
         'imminentCompactAvoidanceCreditCostUnits',
         'appliedCompactCreditCostUnits',

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

@@ -4,7 +4,7 @@ export type ContextGcSubagentToolName = 'agent_start' | 'agent_wait' | 'agent_me
 export type ContextGcPlatform = 'linux' | 'darwin' | 'win32';
 export interface ContextGcEconomicsPolicy {
     readonly version: 1;
-    readonly immediatePaybackRollouts: number;
+    readonly immediatePaybackRollouts?: number;
     readonly minimumPaybackRollouts?: number;
     readonly maximumPaybackRollouts: number;
     readonly contextGrowthSampleWindow: number;
@@ -15,8 +15,8 @@ export interface ContextGcEconomicsPolicy {
     readonly normalInputCostRate: number;
     readonly cacheReadCostRate: number;
     readonly cacheWriteCostRate?: number;
-    readonly outputCostRate: number;
-    readonly minimumGrossReductionRate: number;
+    readonly outputCostRate?: number;
+    readonly minimumGrossReductionRate?: number;
     readonly minimumCacheInvestmentRoi?: number;
 }
 export type ContextGcBase = {
@@ -109,7 +109,7 @@ export interface ContextGcMetrics {
     readonly effectiveMinimumGrossReductionRate?: number;
     readonly minimumRequiredReclaimedTokens?: number;
     readonly cacheRebuildPenaltyCostUnits: number;
-    readonly compactDeferralCreditCostUnits: number;
+    readonly compactDeferralCreditCostUnits?: number;
     readonly imminentCompactAvoidanceCreditCostUnits?: number;
     readonly appliedCompactCreditCostUnits?: number;
     readonly requiredPositiveNetRollouts: number | null;

package/package.json

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