@myagentroam/agent 0.11.33 → 0.11.35

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

@@ -0,0 +1,141 @@
+import type { InlineMediaGcCheckpoint } from './inline-media-contract.js';
+export type ContextGcWebToolName = 'web_search' | 'web_fetch';
+export type ContextGcSubagentToolName = 'agent_start' | 'agent_wait' | 'agent_message' | 'agent_cancel';
+export type ContextGcPlatform = 'linux' | 'darwin' | 'win32';
+export interface ContextGcEconomicsPolicy {
+    readonly version: 1;
+    readonly immediatePaybackRollouts: number;
+    readonly maximumPaybackRollouts: number;
+    readonly contextGrowthSampleWindow: number;
+    readonly minimumContextGrowthSamples: number;
+    readonly minimumObservationRollouts: number;
+    readonly stageAProtectionRollouts: number;
+    readonly largeExecProtectionRollouts: number;
+    readonly normalInputCostRate: number;
+    readonly cacheReadCostRate: number;
+    readonly cacheWriteCostRate: number;
+    readonly outputCostRate: number;
+    readonly minimumGrossReductionRate: number;
+    readonly minimumCacheInvestmentRoi: number;
+}
+export type ContextGcBase = {
+    readonly type: 'SESSION_START';
+    readonly firstSequence: number;
+} | {
+    readonly type: 'COMPACT';
+    readonly sequence: number;
+    readonly recordId: string;
+};
+export interface ContextGcTarget {
+    readonly observationId?: string;
+    readonly sequence: number;
+    readonly recordId: string;
+    readonly role: 'tool_call' | 'tool' | 'provider';
+    readonly callId?: string;
+    readonly toolName?: string;
+}
+export interface ContextGcReadItemReplacement {
+    readonly supersededByCallId?: string;
+    readonly index: number;
+    readonly path: string;
+    readonly replacement: string;
+    readonly evidenceSequence: number;
+}
+export type ContextGcReplacement = {
+    readonly kind: 'READ_OUTPUT_ITEMS';
+    readonly callId: string;
+    readonly target: ContextGcTarget;
+    readonly items: readonly ContextGcReadItemReplacement[];
+    readonly evidenceSequences: readonly number[];
+} | {
+    readonly kind: 'TOOL_CALL_INPUT';
+    readonly toolName: 'apply_patch' | 'exec' | 'exec_wait' | 'code_exec';
+    readonly callId: string;
+    readonly target: ContextGcTarget;
+    readonly replacementArguments: unknown;
+    readonly providerAliasTargets: readonly ContextGcTarget[];
+    readonly evidenceSequence: number;
+} | {
+    readonly kind: 'EXEC_OUTPUT';
+    readonly terminalCallId?: string;
+    readonly callId: string;
+    readonly target: ContextGcTarget;
+    readonly replacementContent: string;
+    readonly evidenceSequence: number;
+} | {
+    readonly kind: 'CODE_MODE_OUTPUT';
+    readonly callId: string;
+    readonly target: ContextGcTarget;
+    readonly replacementContent: string;
+    readonly evidenceSequence: number;
+} | {
+    readonly kind: 'SUBAGENT_OUTPUT';
+    readonly toolName: 'agent_wait' | 'agent_message' | 'agent_cancel';
+    readonly callId: string;
+    readonly target: ContextGcTarget;
+    readonly replacementContent: string;
+    readonly terminalToolName: ContextGcSubagentToolName;
+    readonly terminalCallId: string;
+    readonly evidenceSequence: number;
+    readonly retainedPriorFinal?: {
+        readonly toolName: ContextGcSubagentToolName;
+        readonly callId: string;
+        readonly evidenceSequence: number;
+    };
+} | {
+    readonly kind: 'WEB_OUTPUT';
+    readonly toolName: ContextGcWebToolName;
+    readonly callId: string;
+    readonly target: ContextGcTarget;
+    readonly replacementContent: string;
+    readonly evidenceSequence: number;
+};
+export interface ContextGcMetrics {
+    readonly stage: 'STAGE_A' | 'STAGE_A_AND_EXEC' | 'INLINE_MEDIA';
+    readonly tokenEstimator?: 'UTF8_BYTES_V1';
+    readonly beforeTokens: number;
+    readonly afterTokens: number;
+    readonly reclaimedTokens: number;
+    readonly grossReductionRate: number;
+    readonly effectiveMinimumGrossReductionRate?: number;
+    readonly minimumRequiredReclaimedTokens?: number;
+    readonly cacheRebuildPenaltyCostUnits: number;
+    readonly compactDeferralCreditCostUnits: number;
+    readonly imminentCompactAvoidanceCreditCostUnits?: number;
+    readonly appliedCompactCreditCostUnits?: number;
+    readonly requiredPositiveNetRollouts: 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 minimumObservedRollouts: number;
+    readonly protectedCandidateTokens: number;
+    readonly eligibleCandidateCount: number;
+    readonly eligibleTargetCount: number;
+    readonly cachePenaltyKnown?: boolean;
+}
+export interface ContextGcCheckpointDraft {
+    readonly inlineMedia?: InlineMediaGcCheckpoint;
+    readonly version: 1;
+    readonly base: ContextGcBase;
+    readonly boundarySequence: number;
+    readonly replacements: readonly ContextGcReplacement[];
+    readonly trigger: {
+        readonly usageSequence: number | null;
+        readonly contextInputTokens: number;
+        readonly contextWindowTokens: number;
+        readonly normalRolloutOrdinal: number;
+        readonly modelId: string;
+        readonly platform: ContextGcPlatform;
+    };
+    readonly economics: ContextGcEconomicsPolicy;
+    readonly metrics: ContextGcMetrics;
+}
+export interface ContextGcCheckpointPayload extends ContextGcCheckpointDraft {
+    readonly checkpointId: string;
+    readonly generation: number;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,58 @@
+import type { SessionRecord } from './store/types.js';
+import { type CodeObservation, type CodeToolCallRecord } from './code-observation-projection.js';
+/** Resolve private observation identity to real dispatch facts, not Provider tool calls. */
+export declare function codeObservationEvidence(records: readonly SessionRecord[], result: SessionRecord, observation: Extract<CodeObservation, {
+    type: 'tool_result';
+}>): {
+    callId: string;
+    call: SessionRecord;
+    completed: SessionRecord;
+    result: {
+        payload: {
+            role: string;
+            callId: string;
+            content: string;
+            observationId: string;
+        };
+        recordId: string;
+        sequence: number;
+        timestamp: string;
+        sessionId: string;
+        executionId?: string;
+        turnId?: string;
+        type: string;
+    };
+} | undefined;
+export declare function observationsFromRecord(record: SessionRecord): CodeObservation[] | undefined;
+export declare function codeCallEvidence(records: readonly SessionRecord[], result: SessionRecord, entry: CodeToolCallRecord): {
+    result: {
+        payload: {
+            role: string;
+            callId: string;
+            content: string;
+        };
+        recordId: string;
+        sequence: number;
+        timestamp: string;
+        sessionId: string;
+        executionId?: string;
+        turnId?: string;
+        type: string;
+    };
+    callId: string;
+    call: SessionRecord;
+    completed: SessionRecord;
+} | undefined;
+/** Failed patch calls can prove applied file units, never successful input reclamation. */
+export declare function codePartialPatchCallEvidence(records: readonly SessionRecord[], result: SessionRecord, entry: CodeToolCallRecord): {
+    callId: string;
+    call: SessionRecord;
+    failed: SessionRecord;
+    result: SessionRecord;
+} | undefined;
+export declare function callsFromRecord(record: SessionRecord): CodeToolCallRecord[] | undefined;
+export declare function retainedCodeInputs(records: readonly SessionRecord[], parentCallId: string): {
+    callId: unknown;
+    toolName: unknown;
+    input: unknown;
+}[];

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

@@ -0,0 +1,187 @@
+import { isDeepStrictEqual } from 'node:util';
+import { codeCellCompletionSequence, contextGcPatchResultFromCompletedPayload, contextGcPatchResultFromFailedPayload } from './context-gc-replacements.js';
+import { parseCodeCalls, parseObservations } from './code-observation-projection.js';
+/** Resolve private observation identity to real dispatch facts, not Provider tool calls. */
+export function codeObservationEvidence(records, result, observation) {
+    if (observation.outcome !== 'completed')
+        return undefined;
+    const evidence = codeToolEvidence(records, result, observation.source, 'completed');
+    if (!evidence)
+        return undefined;
+    return {
+        callId: evidence.callId,
+        call: evidence.call,
+        completed: evidence.terminal,
+        result: {
+            ...result,
+            payload: {
+                role: 'tool',
+                callId: evidence.callId,
+                content: observation.result.content,
+                observationId: observation.id
+            }
+        }
+    };
+}
+function codeToolEvidence(records, result, source, outcome) {
+    const started = records.findLast((record) => record.sequence < result.sequence &&
+        record.type === 'tool.started' &&
+        isRecord(record.payload) &&
+        record.payload.callId === source.callId &&
+        record.payload.toolName === source.toolName &&
+        typeof record.payload.parentCallId === 'string' &&
+        isDeepStrictEqual(record.payload.input, source.input));
+    if (!started || !isRecord(started.payload))
+        return undefined;
+    const parentId = started.payload.parentCallId;
+    const parent = records.find((record) => record.type === 'model.context' &&
+        record.sequence < started.sequence &&
+        isRecord(record.payload) &&
+        record.payload.role === 'tool_call' &&
+        record.payload.callId === parentId &&
+        record.payload.name === 'code_exec');
+    if (!parent)
+        return undefined;
+    const original = records.find((record) => record.recordId === result.recordId) ?? result;
+    if (!isRecord(original.payload))
+        return undefined;
+    const outerId = original.payload.callId;
+    const outer = records.findLast((record) => record.sequence < result.sequence &&
+        (record.type === 'tool.completed' ||
+            (outcome === 'failed' && record.type === 'tool.failed')) &&
+        isRecord(record.payload) &&
+        record.payload.callId === outerId &&
+        (record.payload.toolName === 'code_exec' || record.payload.toolName === 'code_exec_wait'));
+    if (!outer ||
+        (outcome === 'completed'
+            ? codeCellCompletionSequence(records, outer)
+            : partialPatchCellTerminalSequence(records, outer)) === undefined ||
+        (outcome === 'completed' &&
+            records.some((record) => record.sequence < result.sequence &&
+                record.type === 'tool.failed' &&
+                isRecord(record.payload) &&
+                record.payload.callId === outerId)))
+        return undefined;
+    if (original.payload.callId !== parentId) {
+        const initial = records.find((record) => record.sequence < outer.sequence &&
+            record.type === 'tool.completed' &&
+            isRecord(record.payload) &&
+            record.payload.callId === parentId);
+        if (!initial ||
+            !isRecord(outer.payload) ||
+            outer.payload.toolName !== 'code_exec_wait' ||
+            !isRecord(initial.payload) ||
+            !isRecord(outer.payload.data) ||
+            !isRecord(initial.payload.data) ||
+            typeof outer.payload.data.cellId !== 'string' ||
+            outer.payload.data.cellId !== initial.payload.data.cellId)
+            return undefined;
+    }
+    const completed = records.findLast((record) => record.sequence > started.sequence &&
+        record.sequence < result.sequence &&
+        record.type === `tool.${outcome}` &&
+        isRecord(record.payload) &&
+        record.payload.callId === source.callId &&
+        record.payload.toolName === source.toolName &&
+        record.payload.parentCallId === parentId);
+    if (!completed ||
+        records.some((record) => record.sequence > started.sequence &&
+            record.sequence < result.sequence &&
+            record.type === (outcome === 'completed' ? 'tool.failed' : 'tool.completed') &&
+            isRecord(record.payload) &&
+            record.payload.callId === source.callId))
+        return undefined;
+    const call = {
+        ...started,
+        payload: {
+            role: 'tool_call',
+            name: source.toolName,
+            callId: source.callId,
+            arguments: source.input
+        }
+    };
+    return { callId: source.callId, call, terminal: completed, result };
+}
+function partialPatchCellTerminalSequence(records, result) {
+    if (!isRecord(result.payload) || !isRecord(result.payload.data))
+        return undefined;
+    const data = result.payload.data;
+    if (typeof data.cellId !== 'string')
+        return undefined;
+    const terminal = (status) => status === 'completed' || status === 'failed' || status === 'cancelled';
+    if (terminal(data.status))
+        return result.sequence;
+    if (data.status !== 'running')
+        return undefined;
+    return records.findLast((record) => record.type === 'code.cell.completed' &&
+        isRecord(record.payload) &&
+        record.payload.cellId === data.cellId &&
+        terminal(record.payload.status))?.sequence;
+}
+export function observationsFromRecord(record) {
+    return isRecord(record.payload) ? parseObservations(record.payload.observations) : undefined;
+}
+export function codeCallEvidence(records, result, entry) {
+    if (entry.status !== 'completed')
+        return undefined;
+    const evidence = codeObservationEvidence(records, result, {
+        type: 'tool_result',
+        id: `call:${entry.callId}`,
+        source: { callId: entry.callId, toolName: entry.toolName, input: entry.input },
+        outcome: 'completed',
+        result: { content: '' }
+    });
+    if (!evidence || !isRecord(evidence.completed.payload))
+        return undefined;
+    return {
+        ...evidence,
+        result: {
+            ...evidence.result,
+            payload: {
+                role: 'tool',
+                callId: entry.callId,
+                content: JSON.stringify(evidence.completed.payload.data ?? {})
+            }
+        }
+    };
+}
+/** Failed patch calls can prove applied file units, never successful input reclamation. */
+export function codePartialPatchCallEvidence(records, result, entry) {
+    if (entry.status !== 'failed' || entry.toolName !== 'apply_patch')
+        return undefined;
+    const evidence = codeToolEvidence(records, result, { callId: entry.callId, toolName: entry.toolName, input: entry.input }, 'failed');
+    if (!evidence || !contextGcPatchResultFromFailedPayload(evidence.terminal.payload))
+        return undefined;
+    return { callId: evidence.callId, call: evidence.call, failed: evidence.terminal, result };
+}
+export function callsFromRecord(record) {
+    return isRecord(record.payload) ? parseCodeCalls(record.payload.calls) : undefined;
+}
+export function retainedCodeInputs(records, parentCallId) {
+    return records.flatMap((record) => {
+        if (!isRecord(record.payload) ||
+            record.type !== 'tool.started' ||
+            record.payload.parentCallId !== parentCallId)
+            return [];
+        const call = record.payload;
+        const completedPatch = call.toolName === 'apply_patch' &&
+            records.some((next) => next.sequence > record.sequence &&
+                next.type === 'tool.completed' &&
+                isRecord(next.payload) &&
+                next.payload.callId === call.callId &&
+                next.payload.toolName === 'apply_patch' &&
+                next.payload.parentCallId === parentCallId &&
+                contextGcPatchResultFromCompletedPayload(next.payload) !== undefined) &&
+            !records.some((next) => next.sequence > record.sequence &&
+                next.type === 'tool.failed' &&
+                isRecord(next.payload) &&
+                next.payload.callId === call.callId);
+        // Successful patches have durable file evidence; other inputs retain their direct-mode semantics.
+        return completedPatch
+            ? []
+            : [{ callId: call.callId, toolName: call.toolName, input: call.input }];
+    });
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}

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

@@ -0,0 +1,63 @@
+import type { ContextGcWebToolName } from './context-gc-contract.js';
+export type { ContextGcWebToolName } from './context-gc-contract.js';
+export interface ContextGcCodeModeInput {
+    readonly code: string;
+    readonly inputMode: 'freeform' | 'json';
+}
+export declare function normalizeContextGcCodeModeInput(arguments_: unknown): ContextGcCodeModeInput | undefined;
+export declare function contextGcCodeModeInputReplacement(input: ContextGcCodeModeInput, retainedInputs?: readonly unknown[]): unknown;
+export declare function contextGcCodeModeOutputReplacement(originalContent: string, truncated: boolean): string;
+export interface ContextGcPatchFile {
+    readonly path: string;
+    readonly targetPath?: string;
+    readonly operation: 'added' | 'modified' | 'deleted' | 'moved';
+    readonly addedLines: number;
+    readonly deletedLines: number;
+}
+export interface ContextGcPatchResult {
+    readonly files: readonly ContextGcPatchFile[];
+    readonly totals: {
+        readonly files: number;
+        readonly addedLines: number;
+        readonly deletedLines: number;
+    };
+}
+export type ContextGcExecResult = {
+    readonly source: 'STRUCTURED';
+    readonly status: 'running' | 'completed' | 'cancelled';
+    readonly processId?: string;
+    readonly exitCode?: number | null;
+    readonly truncated: boolean;
+    readonly stdoutBytes: number;
+    readonly stderrBytes: number;
+    readonly stdoutDroppedBytes: number;
+    readonly stderrDroppedBytes: number;
+    readonly stdout: string;
+    readonly stderr: string;
+} | {
+    readonly source: 'MODEL_CONTEXT_TRUNCATED';
+    readonly status: 'completed' | 'cancelled';
+    readonly processId?: string;
+    readonly exitCode?: number | null;
+    readonly truncated: boolean;
+    readonly stdoutBytes: number;
+    readonly stderrBytes: number;
+    readonly stdoutDroppedBytes: number;
+    readonly stderrDroppedBytes: number;
+    readonly modelContextContent: string;
+};
+export declare function contextGcPatchResultFromCompletedPayload(payload: unknown): ContextGcPatchResult | undefined;
+export declare function contextGcPatchResultFromFailedPayload(payload: unknown): ContextGcPatchResult | undefined;
+export declare function contextGcApplyPatchInputReplacement(arguments_: unknown, result: ContextGcPatchResult): string;
+export declare function contextGcStaleReadReplacement(input: {
+    readonly path: string;
+    readonly content: string;
+    readonly operation: Exclude<ContextGcPatchFile['operation'], 'added'>;
+}): string;
+export declare function contextGcWebOutputReplacement(toolName: ContextGcWebToolName, originalContent: string, truncated: boolean): string;
+export declare function contextGcExecInputReplacement(arguments_: unknown, toolName?: string): unknown;
+export declare function contextGcExecOutputReplacement(result: ContextGcExecResult): string;
+export declare function normalizeContextGcExecResult(modelContent: unknown, completedPayload: unknown): ContextGcExecResult | undefined;
+export declare function parseContextGcExecResult(value: unknown): ContextGcExecResult | undefined;
+/** A returned tool wait is not proof that its retained JavaScript cell finished. */
+export declare function codeCellCompletionSequence(records: readonly import('./store/types.js').SessionRecord[], completed: import('./store/types.js').SessionRecord): number | undefined;

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

@@ -0,0 +1,54 @@
+import type { ContextGcSubagentToolName } from './context-gc-contract.js';
+export type { ContextGcSubagentToolName } from './context-gc-contract.js';
+export interface ContextGcSubagentSnapshot {
+    readonly agentId: string;
+    readonly description: string;
+    readonly status: 'queued' | 'running' | 'completed' | 'failed' | 'cancelled' | 'interrupted';
+    readonly modelId?: string;
+    readonly modelName?: string;
+    readonly reasoningEffort?: string;
+    readonly latestMessage?: {
+        readonly itemId: string;
+        readonly turnId: string;
+        readonly phase: 'commentary' | 'final_answer';
+        readonly text: string;
+        readonly timestamp: string;
+        readonly truncated?: boolean;
+    };
+    readonly latestActivity?: {
+        readonly kind: 'message';
+        readonly timestamp: string;
+        readonly phase: 'commentary' | 'final_answer';
+    } | {
+        readonly kind: 'tool';
+        readonly timestamp: string;
+        readonly toolName: string;
+        readonly status: 'started' | 'completed' | 'failed';
+    };
+    readonly summary?: string;
+    readonly changedFiles?: readonly string[];
+    readonly verification?: readonly string[];
+    readonly evidence?: readonly {
+        readonly path: string;
+        readonly startLine?: number;
+        readonly endLine?: number;
+    }[];
+    readonly errorCode?: string;
+    readonly errorMessage?: string;
+    readonly messageId?: string;
+    readonly turnId?: string;
+    readonly deliveryStatus?: 'accepted' | 'applied' | 'cancelled' | 'failed';
+    readonly waitOutcome?: 'snapshot' | 'message' | 'completion' | 'timeout';
+}
+export declare function normalizeContextGcSubagentSnapshot(modelContent: unknown, completedPayload: unknown, toolName: ContextGcSubagentToolName): ContextGcSubagentSnapshot | undefined;
+export declare function contextGcCompletedSubagentTurnId(snapshot: ContextGcSubagentSnapshot): string | undefined;
+export declare function contextGcSubagentSnapshotTurnId(snapshot: ContextGcSubagentSnapshot): string | undefined;
+export declare function contextGcSubagentNeedsRetainedPriorFinal(snapshot: ContextGcSubagentSnapshot): boolean;
+export declare function contextGcSubagentPriorFinalIsRetained(source: ContextGcSubagentSnapshot, retained: ContextGcSubagentSnapshot | undefined): boolean;
+export declare function contextGcSubagentSnapshotIsSuperseded(source: ContextGcSubagentSnapshot, terminal: ContextGcSubagentSnapshot, retainedPriorFinal?: ContextGcSubagentSnapshot): boolean;
+export declare function contextGcSubagentSnapshotIsPreciselyCovered(source: ContextGcSubagentSnapshot, retained: ContextGcSubagentSnapshot): boolean;
+export declare function contextGcSubagentOutputReplacement(input: {
+    readonly sourceContent: string;
+    readonly source: ContextGcSubagentSnapshot;
+    readonly terminal: ContextGcSubagentSnapshot;
+}): string;

package/dist/session/deferred-input.d.ts

@@ -0,0 +1,5 @@
+import type { SessionRecord } from './store/types.js';
+/** The application is self-contained; the receive record may precede the Compact window. */
+export declare function appliedInputRecord(record: SessionRecord): SessionRecord | undefined;
+/** Only the last checkpoint and its tail are needed, never a historical consume index. */
+export declare function pendingDeferredInputs(records: readonly SessionRecord[]): Map<string, SessionRecord>;

package/dist/session/deferred-input.js

@@ -0,0 +1,74 @@
+import { AgentError } from '../error.js';
+/** The application is self-contained; the receive record may precede the Compact window. */
+export function appliedInputRecord(record) {
+    if (record.type !== 'model.context' || !record.payload || typeof record.payload !== 'object')
+        return undefined;
+    const payload = record.payload;
+    if (payload.inputRef === undefined)
+        return undefined;
+    const input = payload.input;
+    if (payload.role !== 'user' ||
+        typeof payload.content !== 'string' ||
+        typeof payload.inputRef !== 'string' ||
+        !payload.inputRef ||
+        !input ||
+        typeof input !== 'object' ||
+        Array.isArray(input) ||
+        typeof input.prompt !== 'string' ||
+        input.deferred !== true ||
+        payload.content !==
+            (input.modelText ?? input.prompt))
+        throw new AgentError('MAR_AGENT_SESSION_CORRUPT', 'Deferred input application is invalid.');
+    return { ...record, type: 'turn.user', recordId: payload.inputRef, payload: input };
+}
+/** Only the last checkpoint and its tail are needed, never a historical consume index. */
+export function pendingDeferredInputs(records) {
+    const pending = new Map();
+    const applied = new Set();
+    for (const record of records) {
+        const payload = (record.payload ?? {});
+        if (record.type === 'compact.completed' && typeof payload.summary === 'string') {
+            pending.clear();
+            applied.clear();
+            if (payload.pendingInputs !== undefined) {
+                if (!Array.isArray(payload.pendingInputs))
+                    corrupt();
+                for (const item of payload.pendingInputs) {
+                    if (!item ||
+                        item.type !== 'turn.user' ||
+                        item.sessionId !== record.sessionId ||
+                        typeof item.recordId !== 'string' ||
+                        !Number.isSafeInteger(item.sequence) ||
+                        item.sequence < 1 ||
+                        item.sequence >= record.sequence ||
+                        !item.payload ||
+                        item.payload.deferred !== true ||
+                        typeof item.payload.prompt !== 'string' ||
+                        pending.has(item.recordId))
+                        corrupt();
+                    pending.set(item.recordId, item);
+                }
+            }
+        }
+        else if (record.type === 'turn.user' && payload.deferred === true) {
+            if (typeof payload.prompt !== 'string' ||
+                pending.has(record.recordId) ||
+                applied.has(record.recordId))
+                corrupt();
+            pending.set(record.recordId, record);
+        }
+        else {
+            const input = appliedInputRecord(record);
+            if (!input)
+                continue;
+            if (applied.has(input.recordId))
+                corrupt();
+            applied.add(input.recordId);
+            pending.delete(input.recordId);
+        }
+    }
+    return new Map([...pending].sort(([, a], [, b]) => a.sequence - b.sequence));
+}
+function corrupt() {
+    throw new AgentError('MAR_AGENT_SESSION_CORRUPT', 'Deferred input state is invalid.');
+}

package/dist/session/extension-checkpoint.d.ts

@@ -0,0 +1,8 @@
+export type ExtensionJsonValue = null | boolean | number | string | readonly ExtensionJsonValue[] | {
+    readonly [key: string]: ExtensionJsonValue;
+};
+export interface ExtensionCheckpoint {
+    readonly revision: number;
+    readonly value?: ExtensionJsonValue;
+}
+export declare function cloneCoreJson(value: unknown): ExtensionJsonValue;

package/dist/session/extension-checkpoint.js

@@ -0,0 +1,30 @@
+import { AgentError } from '../error.js';
+export function cloneCoreJson(value) {
+    try {
+        const ancestors = new Set();
+        const copy = (value) => {
+            if (value === null || typeof value === 'string' || typeof value === 'boolean')
+                return value;
+            if (typeof value === 'number' && Number.isFinite(value))
+                return value;
+            if (typeof value !== 'object' || !value || ancestors.has(value))
+                throw new Error();
+            ancestors.add(value);
+            try {
+                if (Array.isArray(value))
+                    return Array.from(value, copy);
+                if (Object.prototype.toString.call(value) !== '[object Object]')
+                    throw new Error();
+                // Define own JSON keys, including __proto__, without assigning to a prototype setter.
+                return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, copy(item)]));
+            }
+            finally {
+                ancestors.delete(value);
+            }
+        };
+        return copy(value);
+    }
+    catch {
+        throw new AgentError('MAR_AGENT_EXTENSION_DATA_INVALID', 'Extension data must be serializable JSON.');
+    }
+}

package/dist/session/history-input-limits.d.ts

@@ -0,0 +1,4 @@
+export declare const HISTORY_INPUT_LIMITS: Readonly<{
+    codeMaxInputBytes: 1048576;
+    patchMaxBytes: 4194304;
+}>;

package/dist/session/history-input-limits.js

@@ -0,0 +1,4 @@
+export const HISTORY_INPUT_LIMITS = Object.freeze({
+    codeMaxInputBytes: 1_048_576,
+    patchMaxBytes: 4_194_304
+});

package/dist/session/inline-media-contract.d.ts

@@ -0,0 +1,16 @@
+export interface InlineMediaCursor {
+    sourceId: string;
+    imageIndex: number;
+}
+/** Processing progress, not evidence that the provider inspected an image. */
+export interface InlineMediaState {
+    version: 1;
+    consideredThrough?: InlineMediaCursor;
+    evictedThrough?: InlineMediaCursor;
+}
+export interface InlineMediaGcCheckpoint {
+    readonly reason: 'SOFT_LIMIT' | 'HARD_LIMIT' | 'TEXT_GC';
+    readonly state: InlineMediaState;
+    readonly beforeBytes: number;
+    readonly afterBytes: number;
+}

package/dist/session/inline-media-contract.js

@@ -0,0 +1 @@
+export {};