@myagentroam/agent 0.11.32 → 0.11.34

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

@@ -0,0 +1,57 @@
+import type { ClientToolDefinition } from '../../tools/contracts.js';
+import type { SessionModelMessage as ModelMessage } from '../../session/model-request.js';
+import type { ModelUsage } from '../../model/contracts.js';
+import { ContextGcCheckpointCache, type ContextGcCheckpointDraft, type ContextGcMetrics, type ContextGcPlatform, type ContextGcReplacement } from '../../session/context-gc-checkpoint.js';
+import type { SessionRecord } from '../../session/record-contract.js';
+export interface ContextGcPlan {
+    readonly stage: ContextGcMetrics['stage'];
+    readonly draft: ContextGcCheckpointDraft;
+    readonly metrics: ContextGcMetrics;
+}
+export interface ContextGcInspection {
+    readonly plan?: ContextGcPlan;
+    readonly retryAfterRollouts?: number;
+}
+export interface ContextGcPlannerInput {
+    readonly inlineMedia?: import('../../session/inline-media.js').InlineMediaGcCandidate;
+    readonly records: readonly SessionRecord[];
+    readonly messages: readonly ModelMessage[];
+    readonly messageSources: readonly SessionRecord[];
+    readonly system: string;
+    readonly tools: readonly ClientToolDefinition[];
+    readonly modelId: string;
+    readonly modelProtocol?: string;
+    readonly responsesConfigurationUpdates?: boolean;
+    readonly contextWindowTokens: number;
+    readonly usage: ModelUsage;
+    readonly workspace: string;
+    readonly platform: ContextGcPlatform;
+    readonly activeProcessIds: ReadonlySet<string>;
+    readonly tokenCache?: Map<string, number>;
+    readonly checkpointCache?: ContextGcCheckpointCache;
+}
+export interface ContextCandidate {
+    readonly replacements: readonly ContextGcReplacement[];
+    readonly observedRollouts: number;
+    readonly evidenceSequence: number;
+}
+export type CandidateSavings = (candidate: ContextCandidate) => number;
+export interface ToolGroup {
+    evidenceOnly?: boolean;
+    readonly callId: string;
+    toolName: string;
+    call?: {
+        message: ModelMessage;
+        record: SessionRecord;
+    };
+    result?: {
+        message: ModelMessage;
+        record: SessionRecord;
+    };
+    aliases: Array<{
+        message: ModelMessage;
+        record: SessionRecord;
+    }>;
+    completed?: SessionRecord;
+    failed?: SessionRecord;
+}

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

@@ -0,0 +1,48 @@
+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;
+interface ContextGcEconomicsInput {
+    readonly contextUsageTokens: number;
+    readonly reclaimedTokens: number;
+    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;
+    readonly requiredPositiveNetRollouts: number;
+    readonly requiredTargetRoiRollouts: number;
+    readonly expectedNetSavedCostUnits: number;
+    readonly cacheInvestmentRoi: number;
+    readonly grossReductionRate: number;
+    readonly passes: boolean;
+}
+interface ContextGcCacheEconomicsProfile {
+    readonly reclaimedTokens: number;
+    readonly reclaimedCachedTokens: number;
+    readonly cacheRebuildPenaltyCostUnits: number;
+}
+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 contextGcEligibleUsage(usage: ModelUsage, contextWindowTokens: number): number | undefined;
+export declare function contextGcMarginalCacheInvestmentPaysBack(current: ContextGcCacheEconomicsProfile, combined: ContextGcCacheEconomicsProfile): boolean;
+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

@@ -0,0 +1,161 @@
+export const CONTEXT_GC_POLICY = {
+    version: 1,
+    immediatePaybackRollouts: 3,
+    maximumPaybackRollouts: 20,
+    contextGrowthSampleWindow: 16,
+    minimumContextGrowthSamples: 6,
+    minimumObservationRollouts: 1,
+    stageAProtectionRollouts: 2,
+    largeExecProtectionRollouts: 6,
+    normalInputCostRate: 1,
+    cacheReadCostRate: 0.1,
+    cacheWriteCostRate: 1.25,
+    outputCostRate: 1,
+    minimumGrossReductionRate: 0.2,
+    minimumCacheInvestmentRoi: 0.1
+};
+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;
+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);
+    const preservedCachedPrefixTokens = clamp(input.preservedCachedPrefixTokens, 0, cacheReadTokens);
+    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);
+    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 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 passes = reclaimedTokens > 0 &&
+        reclaimedTokens >= minimumReclaimedTokens &&
+        Number.isFinite(requiredTargetRoiRollouts) &&
+        (immediate ||
+            (requiredTargetRoiRollouts <= CONTEXT_GC_POLICY.maximumPaybackRollouts &&
+                input.contextGrowthSampleCount >= CONTEXT_GC_POLICY.minimumContextGrowthSamples &&
+                requiredTargetRoiRollouts <= input.projectedRolloutsUntilCompactAfterGc));
+    return {
+        cacheRebuildPenaltyCostUnits,
+        requiredPositiveNetRollouts,
+        requiredTargetRoiRollouts,
+        expectedNetSavedCostUnits,
+        cacheInvestmentRoi,
+        grossReductionRate,
+        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 contextGcEligibleUsage(usage, contextWindowTokens) {
+    const contextUsageTokens = modelContextUsage(usage);
+    if (contextUsageTokens === undefined ||
+        !Number.isSafeInteger(contextWindowTokens) ||
+        contextWindowTokens <= 0)
+        return undefined;
+    const usageRatio = contextUsageTokens / contextWindowTokens;
+    if (usageRatio < CONTEXT_GC_START_RATIO || usageRatio >= COMPACT_THRESHOLD_RATIO)
+        return undefined;
+    return contextUsageTokens;
+}
+export function contextGcMarginalCacheInvestmentPaysBack(current, combined) {
+    const marginalPenalty = combined.cacheRebuildPenaltyCostUnits - current.cacheRebuildPenaltyCostUnits;
+    if (marginalPenalty <= 0)
+        return true;
+    const firstRolloutSavings = (profile) => {
+        const reclaimedCachedTokens = clamp(profile.reclaimedCachedTokens, 0, Math.max(0, profile.reclaimedTokens));
+        return (reclaimedCachedTokens * CONTEXT_GC_POLICY.cacheReadCostRate +
+            Math.max(0, profile.reclaimedTokens - reclaimedCachedTokens) *
+                CONTEXT_GC_POLICY.normalInputCostRate);
+    };
+    const marginalFirstRolloutSavings = firstRolloutSavings(combined) - firstRolloutSavings(current);
+    const marginalSteadyRolloutSavings = Math.max(0, combined.reclaimedTokens - current.reclaimedTokens) *
+        CONTEXT_GC_POLICY.cacheReadCostRate;
+    for (let rollouts = 1; rollouts <= CONTEXT_GC_POLICY.immediatePaybackRollouts; rollouts++) {
+        const net = -marginalPenalty +
+            marginalFirstRolloutSavings +
+            Math.max(0, rollouts - 1) * marginalSteadyRolloutSavings;
+        if (net > 0 && net / marginalPenalty >= CONTEXT_GC_POLICY.minimumCacheInvestmentRoi)
+            return true;
+    }
+    return false;
+}
+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
+        ? 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-runtime.d.ts

@@ -0,0 +1,43 @@
+import type { ClientToolDefinition } from '../../tools/contracts.js';
+import type { SessionModelMessage as ModelMessage } from '../../session/model-request.js';
+import type { ModelUsage } from '../../model/contracts.js';
+import { type ContextGcPlatform } from '../../session/context-gc-checkpoint.js';
+import type { SessionStore } from '../../session/store/contracts.js';
+import type { SessionRecord } from '../../session/record-contract.js';
+import { type ContextProjection } from './projection.js';
+type ContextGcStore = Pick<SessionStore, 'readExecutionState' | 'commitContextGc' | 'readPage'>;
+export interface ContextGcRuntimeInput {
+    readonly inlineMedia?: import('../../session/inline-media.js').InlineMediaGcCandidate | undefined;
+    readonly store: ContextGcStore;
+    readonly sessionId: string;
+    readonly records?: readonly SessionRecord[];
+    readonly mediaView?: (messages: readonly ModelMessage[]) => readonly ModelMessage[];
+    readonly system: string;
+    readonly tools: readonly ClientToolDefinition[];
+    readonly modelId: string;
+    readonly modelProtocol?: string;
+    readonly responsesConfigurationUpdates?: boolean;
+    readonly contextWindowTokens: number;
+    readonly usage: ModelUsage;
+    readonly workspace: string;
+    readonly platform: ContextGcPlatform;
+    readonly activeProcessIds?: ReadonlySet<string>;
+    readonly getActiveProcessIds?: () => Promise<ReadonlySet<string>>;
+}
+export interface ContextGcCommitResult {
+    readonly records: readonly SessionRecord[];
+    readonly projection: ContextProjection;
+}
+/** Only scheduling metadata survives a call; records and validation caches do not. */
+export declare class ContextGcRuntime {
+    #private;
+    reset(): void;
+    run(input: ContextGcRuntimeInput): Promise<ContextGcCommitResult | false>;
+}
+/**
+ * Runs the deterministic planner and commits its checkpoint. Planning and
+ * commit failures are opportunistic no-ops unless the checkpoint is confirmed
+ * durable after an ambiguous append result.
+ */
+export declare function tryCommitContextGc(input: ContextGcRuntimeInput): Promise<ContextGcCommitResult | false>;
+export {};

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

@@ -0,0 +1,26 @@
+import type { ClientToolDefinition } from '../../tools/contracts.js';
+import type { SessionModelMessage as ModelMessage } from '../../session/model-request.js';
+export { MODEL_TOKEN_ESTIMATOR as CONTEXT_GC_TOKEN_ESTIMATOR } from '../token-budget.js';
+interface TokenContext {
+    readonly modelId: string;
+    readonly modelProtocol?: string;
+    readonly responsesConfigurationUpdates?: boolean;
+    readonly system: string;
+    readonly tools: readonly ClientToolDefinition[];
+    readonly messages?: readonly ModelMessage[];
+    readonly tokenCache?: Map<string, number>;
+}
+/** Uses Responses lowering, including native alias and cross-model filtering. */
+export declare function contextGcTokenEntries(input: TokenContext, messages: readonly ModelMessage[]): {
+    tokens: number;
+    key: string;
+    text: string;
+}[];
+/** Cancel identical entries, including multiplicity, before estimating the difference. */
+export declare function contextGcReclaimedTokens(input: TokenContext, before: readonly ModelMessage[], after: readonly ModelMessage[]): number;
+export declare function contextGcPrefixTokens(input: TokenContext): number;
+export declare function contextGcMessageTokens(input: TokenContext, messages: readonly ModelMessage[]): number;
+export declare function contextGcCacheImpact(input: TokenContext, before: readonly ModelMessage[], after: readonly ModelMessage[], cacheRead: number, reclaimedTokens: number): {
+    preservedCachedPrefixTokens: number;
+    reclaimedCachedTokens: number;
+};

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

@@ -0,0 +1,106 @@
+import { openAiInput } from '../../model/openai-responses.js';
+import { countModelTokens } from '../token-budget.js';
+import { observationModelParts, observationModelText } from '../../session/code-observation-projection.js';
+export { MODEL_TOKEN_ESTIMATOR as CONTEXT_GC_TOKEN_ESTIMATOR } from '../token-budget.js';
+/** Uses Responses lowering, including native alias and cross-model filtering. */
+export function contextGcTokenEntries(input, messages) {
+    return serializedEntries(input, messages).map((entry) => ({
+        ...entry,
+        tokens: tokensFor(input, entry.text)
+    }));
+}
+function serializedEntries(input, messages) {
+    // Media bytes have a separate budget. Keep identity for cache boundaries without
+    // loading resources or counting base64 payloads as text tokens.
+    messages = messages.map((message) => message.images?.length
+        ? {
+            ...message,
+            images: message.images.map((image) => ({
+                mimeType: image.mimeType,
+                url: image.resourceId
+                    ? `https://mar.invalid/resource/${image.resourceId}`
+                    : (image.url ?? 'https://mar.invalid/inline-image')
+            }))
+        }
+        : message);
+    const responses = input.modelProtocol === 'OPENAI_RESPONSES' ||
+        (input.modelProtocol === undefined &&
+            (input.messages ?? messages).some((message) => message.provider === 'OPENAI_RESPONSES'));
+    const values = responses
+        ? openAiInput(messages.map((message) => {
+            const contentParts = message.role === 'tool' ? observationModelParts(message) : undefined;
+            return contentParts === undefined ? message : { ...message, contentParts };
+        }), undefined, input.modelId, true, input.responsesConfigurationUpdates !== false)
+        : messages
+            .filter((message) => message.role !== 'provider' ||
+            (message.provider === 'ANTHROPIC_MESSAGES' && message.providerModelId === input.modelId))
+            .map((original) => {
+            const { observations: _observations, observationId: _observationId, ...message } = original;
+            const content = original.role === 'tool' ? observationModelText(original) : undefined;
+            return content === undefined ? message : { ...message, content };
+        });
+    return values.map((value, index) => {
+        const item = value;
+        const callId = item.call_id ?? item.callId;
+        const output = item.role === 'tool' ||
+            item.type === 'function_call_output' ||
+            item.type === 'custom_tool_call_output';
+        const key = typeof callId === 'string'
+            ? `${output ? 'output' : 'input'}:${callId}`
+            : typeof item.id === 'string'
+                ? `id:${item.id}`
+                : `index:${index}`;
+        const text = stableJson(value);
+        return { key, text };
+    });
+}
+/** Cancel identical entries, including multiplicity, before estimating the difference. */
+export function contextGcReclaimedTokens(input, before, after) {
+    const counts = new Map();
+    for (const entry of serializedEntries(input, before))
+        counts.set(entry.text, (counts.get(entry.text) ?? 0) + 1);
+    for (const entry of serializedEntries(input, after))
+        counts.set(entry.text, (counts.get(entry.text) ?? 0) - 1);
+    let reclaimed = 0;
+    for (const [text, count] of counts)
+        if (count !== 0)
+            reclaimed += count * tokensFor(input, text);
+    return Math.max(0, reclaimed);
+}
+export function contextGcPrefixTokens(input) {
+    return tokensFor(input, stableJson({ system: input.system, tools: input.tools }));
+}
+export function contextGcMessageTokens(input, messages) {
+    return contextGcTokenEntries(input, messages).reduce((sum, entry) => sum + entry.tokens, 0);
+}
+export function contextGcCacheImpact(input, before, after, cacheRead, reclaimedTokens) {
+    const afterByKey = new Map(contextGcTokenEntries(input, after).map((entry) => [entry.key, entry]));
+    let offset = contextGcPrefixTokens(input);
+    let earliest = cacheRead;
+    let reclaimedCachedTokens = 0;
+    for (const entry of contextGcTokenEntries(input, before)) {
+        const replacement = afterByKey.get(entry.key);
+        if (entry.text !== replacement?.text) {
+            earliest = Math.min(earliest, offset);
+            reclaimedCachedTokens += Math.min(Math.max(0, entry.tokens - (replacement?.tokens ?? 0)), Math.max(0, cacheRead - offset));
+        }
+        offset += entry.tokens;
+    }
+    return {
+        preservedCachedPrefixTokens: Math.max(0, Math.min(cacheRead, earliest)),
+        reclaimedCachedTokens: Math.min(reclaimedTokens, reclaimedCachedTokens)
+    };
+}
+function tokensFor(input, text) {
+    const cached = input.tokenCache?.get(text);
+    if (cached !== undefined)
+        return cached;
+    const tokens = countModelTokens(text);
+    input.tokenCache?.set(text, tokens);
+    return tokens;
+}
+function stableJson(value) {
+    return JSON.stringify(value, (_key, item) => item && typeof item === 'object' && !Array.isArray(item)
+        ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a.localeCompare(b)))
+        : item);
+}

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

@@ -0,0 +1,7 @@
+import { type ContextGcReplacement } from '../../session/context-gc-checkpoint.js';
+import { type ContextGcPlan, type ContextGcInspection, type ContextGcPlannerInput } from './gc-contracts.js';
+export { CONTEXT_GC_POLICY, type ContextGcEconomicsResult, evaluateContextGcEconomics, contextGcMinimumGrossReductionRate, contextGcMinimumReclaimedTokens, contextGcEligibleUsage, contextGcMarginalCacheInvestmentPaysBack, contextGcImminentCompactAvoidanceCredit, contextGcAppliedCompactCreditCostUnits } 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;
+export declare function contextGcEarliestReplacementSequence(replacements: readonly ContextGcReplacement[]): number;