@myagentroam/agent 0.11.32 → 0.11.34

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

@@ -1,60 +0,0 @@
-import type { SessionRecord } from './store/index.js';
-import { type CodeObservation, type CodeToolCallRecord } from '../tools/code-mode/observations.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;
-        };
-        schemaVersion: 1;
-        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;
-        };
-        schemaVersion: 1;
-        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/agent-core/session/context-gc-observations.js

@@ -1,187 +0,0 @@
-import { isDeepStrictEqual } from 'node:util';
-import { codeCellCompletionSequence, contextGcPatchResultFromCompletedPayload, contextGcPatchResultFromFailedPayload } from './context-gc-replacements.js';
-import { parseCodeCalls, parseObservations } from '../tools/code-mode/observations.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/agent-core/session/context-gc-replacements.d.ts

@@ -1,62 +0,0 @@
-export type ContextGcWebToolName = 'web_search' | 'web_fetch';
-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/index.js').SessionRecord[], completed: import('./store/index.js').SessionRecord): number | undefined;

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

@@ -1,53 +0,0 @@
-export type ContextGcSubagentToolName = 'agent_start' | 'agent_wait' | 'agent_message' | 'agent_cancel';
-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/agent-core/session/deferred-input.d.ts

@@ -1,5 +0,0 @@
-import type { SessionRecord } from './store/index.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/agent-core/session/deferred-input.js

@@ -1,74 +0,0 @@
-import { MarAgentError } 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 MarAgentError('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 MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Deferred input state is invalid.');
-}

package/dist/agent-core/session/inline-media.d.ts

@@ -1,45 +0,0 @@
-import type { ModelMessage, ModelRequest } from '../model/contracts.js';
-import type { ModelImage } from '../model/image.js';
-import type { SessionRecord } from './store/types.js';
-export declare const INLINE_MEDIA_POLICY: Readonly<{
-    historicalInlineMediaTrigger: number;
-    historicalInlineMediaTarget: number;
-    requestInlineMediaHardLimit: number;
-}>;
-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;
-}
-export interface InlineMediaGcCandidate extends InlineMediaGcCheckpoint {
-    /** Apply the proposed eviction to the current visual-window projection. */
-    readonly project: (messages: readonly ModelMessage[]) => ModelMessage[];
-}
-export declare function parseInlineMediaGc(value: unknown): InlineMediaGcCheckpoint | undefined;
-export declare function inlineMediaSource(message: ModelMessage): string | ModelMessage;
-/** GC may advance only a durable, already-considered source prefix. */
-export declare function inlineMediaGcAnchored(records: readonly SessionRecord[], media: InlineMediaGcCheckpoint): boolean;
-export declare function inlineMediaBytes(image: ModelImage): number;
-export declare function inlineMediaLimit(): never;
-/** Final encoding guard; URL-only images do not consume the inline budget. */
-export declare function assertInlineMediaBudget(request: Pick<ModelRequest, 'messages' | 'images'>): void;
-export declare function parseInlineMediaState(value: unknown): InlineMediaState | undefined;
-/** Recover ordering once at the lifecycle boundary, including GC-omitted sources. */
-export declare function inlineMediaHistory(records: readonly SessionRecord[]): {
-    cursors: (InlineMediaCursor & {
-        rollout: number;
-    })[];
-    rollouts: number;
-    state?: InlineMediaState;
-};

package/dist/agent-core/session/inline-media.js

@@ -1,163 +0,0 @@
-import { MarAgentError } from '../error.js';
-import { appliedInputRecord } from './deferred-input.js';
-const MiB = 1_048_576;
-export const INLINE_MEDIA_POLICY = Object.freeze({
-    historicalInlineMediaTrigger: 7 * MiB,
-    historicalInlineMediaTarget: 5 * MiB,
-    requestInlineMediaHardLimit: 12 * MiB
-});
-export function parseInlineMediaGc(value) {
-    if (!value || typeof value !== 'object')
-        return undefined;
-    const item = value;
-    const state = parseInlineMediaState(item.state);
-    return state?.evictedThrough &&
-        state.consideredThrough &&
-        Number.isSafeInteger(item.beforeBytes) &&
-        item.beforeBytes > 0 &&
-        Number.isSafeInteger(item.afterBytes) &&
-        item.afterBytes >= 0 &&
-        item.afterBytes <= INLINE_MEDIA_POLICY.historicalInlineMediaTarget &&
-        item.afterBytes < item.beforeBytes &&
-        (item.reason === 'SOFT_LIMIT' || item.reason === 'HARD_LIMIT' || item.reason === 'TEXT_GC') &&
-        (item.reason !== 'SOFT_LIMIT' ||
-            item.beforeBytes > INLINE_MEDIA_POLICY.historicalInlineMediaTrigger) &&
-        (item.reason !== 'TEXT_GC' ||
-            item.beforeBytes > INLINE_MEDIA_POLICY.historicalInlineMediaTarget)
-        ? { reason: item.reason, state, beforeBytes: item.beforeBytes, afterBytes: item.afterBytes }
-        : undefined;
-}
-export function inlineMediaSource(message) {
-    return message.callId !== undefined
-        ? `tool:${message.callId}`
-        : message.metadata?.recordId !== undefined
-            ? `input:${message.metadata.recordId}`
-            : message;
-}
-/** GC may advance only a durable, already-considered source prefix. */
-export function inlineMediaGcAnchored(records, media) {
-    const history = inlineMediaHistory(records);
-    const positions = new Map();
-    const key = (cursor) => JSON.stringify([cursor?.sourceId, cursor?.imageIndex]);
-    for (const cursor of history.cursors) {
-        const identity = key({ sourceId: cursor.sourceId, imageIndex: cursor.imageIndex });
-        if (!positions.has(identity))
-            positions.set(identity, { index: positions.size, rollout: cursor.rollout });
-    }
-    const evicted = positions.get(key(media.state.evictedThrough));
-    const considered = positions.get(key(media.state.consideredThrough));
-    const previous = positions.get(key(history.state?.evictedThrough));
-    return (evicted !== undefined &&
-        considered !== undefined &&
-        key(media.state.consideredThrough) === key(history.state?.consideredThrough) &&
-        evicted.index <= considered.index &&
-        evicted.index > (previous?.index ?? -1) &&
-        (media.reason === 'HARD_LIMIT' || history.rollouts - evicted.rollout >= 2));
-}
-export function inlineMediaBytes(image) {
-    const bytes = image.dataBase64 !== undefined
-        ? image.dataBase64.length
-        : image.byteSize !== undefined
-            ? 4 * Math.ceil(image.byteSize / 3)
-            : undefined;
-    if (bytes === undefined)
-        throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Resource size is unavailable.');
-    return bytes + Buffer.byteLength(`data:${image.mimeType};base64,`);
-}
-export function inlineMediaLimit() {
-    throw new MarAgentError('MAR_AGENT_INLINE_MEDIA_LIMIT', 'Inline images exceed the 12 MiB request limit. Reduce this image batch or use view_image with resize or region before retrying.');
-}
-/** Final encoding guard; URL-only images do not consume the inline budget. */
-export function assertInlineMediaBudget(request) {
-    let total = 0;
-    for (const message of request.messages)
-        for (const image of message.images ?? [])
-            if (image.dataBase64 !== undefined)
-                total += inlineMediaBytes(image);
-    for (const image of request.images ?? [])
-        if (image.dataBase64 !== undefined)
-            total += inlineMediaBytes(image);
-    if (total > INLINE_MEDIA_POLICY.requestInlineMediaHardLimit)
-        inlineMediaLimit();
-}
-export function parseInlineMediaState(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return undefined;
-    const state = value;
-    const cursor = (value) => {
-        if (!value || typeof value !== 'object')
-            return false;
-        const item = value;
-        return (typeof item.sourceId === 'string' &&
-            item.sourceId.length > 0 &&
-            item.sourceId.length <= 256 &&
-            Number.isSafeInteger(item.imageIndex) &&
-            item.imageIndex >= 0);
-    };
-    if (state.version !== 1 ||
-        (state.consideredThrough !== undefined && !cursor(state.consideredThrough)) ||
-        (state.evictedThrough !== undefined && !cursor(state.evictedThrough)))
-        return undefined;
-    return structuredClone(state);
-}
-/** Recover ordering once at the lifecycle boundary, including GC-omitted sources. */
-export function inlineMediaHistory(records) {
-    const cursors = [];
-    let rollouts = 0;
-    let state;
-    const add = (sourceId, images) => {
-        if (!sourceId || !Array.isArray(images))
-            return;
-        for (let imageIndex = 0; imageIndex < images.length; imageIndex++)
-            cursors.push({ sourceId, imageIndex, rollout: rollouts });
-    };
-    for (const record of records) {
-        const payload = record.payload;
-        if (!payload || typeof payload !== 'object')
-            continue;
-        if (record.type === 'model.attempt' &&
-            payload.purpose === 'EXECUTION' &&
-            payload.state === 'SUCCEEDED')
-            rollouts++;
-        if (record.type === 'compact.completed') {
-            cursors.splice(0);
-            state = parseInlineMediaState(payload.inlineMediaState);
-            for (const item of (payload.retainedModelContext ?? [])) {
-                const applied = appliedInputRecord({ ...record, type: 'model.context', payload: item });
-                if (applied) {
-                    add(`input:${applied.recordId}`, applied.payload.images);
-                    continue;
-                }
-                const key = inlineMediaSource(item);
-                add(typeof key === 'string' ? key : undefined, item.images);
-            }
-        }
-        else if (record.type === 'resource.window') {
-            state = parseInlineMediaState(payload);
-        }
-        else if (record.type === 'context.gc.completed' && payload.inlineMedia !== undefined) {
-            const media = parseInlineMediaGc(payload.inlineMedia);
-            if (!media)
-                throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Inline media GC state is invalid.');
-            state = media.state;
-        }
-        else if ((record.type === 'turn.user' || record.type === 'extension.input') &&
-            payload.deferred !== true) {
-            add(`input:${record.recordId}`, payload.images);
-        }
-        else if (record.type === 'model.context') {
-            const applied = appliedInputRecord(record);
-            if (applied) {
-                add(`input:${applied.recordId}`, applied.payload.images);
-                continue;
-            }
-            const key = typeof payload.inputRef === 'string'
-                ? `input:${payload.inputRef}`
-                : typeof payload.callId === 'string'
-                    ? `tool:${payload.callId}`
-                    : undefined;
-            add(key, payload.images);
-        }
-    }
-    return { cursors, rollouts, ...(state ? { state } : {}) };
-}

package/dist/agent-core/session/rollback.d.ts

@@ -1,13 +0,0 @@
-import type { SessionRecord } from './store/types.js';
-export type MarAgentSessionRollbackInput = {
-    readonly boundaryTurnId: string | null;
-    readonly beforeInput?: never;
-} | {
-    readonly boundaryTurnId?: never;
-    readonly beforeInput: {
-        readonly turnId: string;
-        readonly clientMessageId: string;
-    };
-};
-/** Resolve the retained prefix only from records read under the Session maintenance lease. */
-export declare function rollbackBoundaryIndex(records: readonly SessionRecord[], input: MarAgentSessionRollbackInput): number;