@myagentroam/agent 0.9.140 → 0.9.142

package/dist/agent-core/runtime/compaction/operation.d.ts

@@ -0,0 +1,22 @@
+import type { ModelEvent, ModelRequest, ModelTurnSession } from '../../model/contracts.js';
+export interface CompactionProgress {
+    state: 'STARTED' | 'PROGRESS' | 'FINISHED';
+    elapsedMs: number;
+    inputTokensEstimate: number;
+    modelRequests: number;
+    eventCounts: Partial<Record<ModelEvent['type'], number>>;
+    textDeltaCharacters: number;
+    firstOutputAfterMs?: number;
+    lastOutputAfterMs?: number;
+    timedOut: boolean;
+}
+/** One deadline spans all model attempts and recovery waits for a single compaction. */
+export declare class CompactionOperation {
+    #private;
+    private readonly record;
+    readonly signal: AbortSignal;
+    constructor(parent: AbortSignal, record: (progress: CompactionProgress) => void | Promise<void>);
+    start(model: Pick<ModelTurnSession, 'start'>, request: ModelRequest): AsyncIterable<ModelEvent>;
+    dispose(): Promise<void>;
+    private report;
+}

package/dist/agent-core/runtime/compaction/operation.js

@@ -0,0 +1,91 @@
+import { MarAgentError } from '../../error.js';
+import { countModelTokens } from '../token-budget.js';
+const COMPACTION_TIMEOUT_MS = 600_000;
+const COMPACTION_PROGRESS_INTERVAL_MS = 30_000;
+/** One deadline spans all model attempts and recovery waits for a single compaction. */
+export class CompactionOperation {
+    record;
+    #controller = new AbortController();
+    signal;
+    #startedAt = Date.now();
+    #deadline;
+    #progressTimer;
+    #closed = false;
+    #tail = Promise.resolve();
+    #inputTokensEstimate = 0;
+    #modelRequests = 0;
+    #eventCounts = {};
+    #textDeltaCharacters = 0;
+    #firstOutputAfterMs;
+    #lastOutputAfterMs;
+    constructor(parent, record) {
+        this.record = record;
+        this.signal = AbortSignal.any([parent, this.#controller.signal]);
+        this.#deadline = setTimeout(() => this.#controller.abort(new MarAgentError('MAR_AGENT_MODEL_TIMEOUT', 'Compaction exceeded its total time limit; the previous context was retained.', { details: { reason: 'COMPACTION_DEADLINE_EXCEEDED' } })), COMPACTION_TIMEOUT_MS);
+        this.#deadline.unref();
+        this.#progressTimer = setInterval(() => {
+            void this.report('PROGRESS');
+        }, COMPACTION_PROGRESS_INTERVAL_MS);
+        this.#progressTimer.unref();
+    }
+    async *start(model, request) {
+        this.signal.throwIfAborted();
+        this.#modelRequests++;
+        this.#inputTokensEstimate =
+            countModelTokens(request.system) +
+                request.messages.reduce((sum, message) => sum + countModelTokens(message.content), 0);
+        await this.report(this.#modelRequests === 1 ? 'STARTED' : 'PROGRESS');
+        let completed = false;
+        try {
+            for await (const event of model.start(request, this.signal)) {
+                this.signal.throwIfAborted();
+                this.#eventCounts[event.type] = (this.#eventCounts[event.type] ?? 0) + 1;
+                if (event.type === 'completed')
+                    completed = event.reason === 'completed';
+                if (event.type === 'text.delta')
+                    this.#textDeltaCharacters += event.delta.length;
+                if ((event.type === 'text.delta' && event.delta.length > 0) ||
+                    ((event.type === 'text.completed' || event.type === 'reasoning.summary') &&
+                        event.text.length > 0)) {
+                    this.#lastOutputAfterMs = Math.max(0, Date.now() - this.#startedAt);
+                    this.#firstOutputAfterMs ??= this.#lastOutputAfterMs;
+                }
+                yield event;
+            }
+            this.signal.throwIfAborted();
+            if (!completed)
+                throw new MarAgentError('MAR_AGENT_COMPACT_FAILED', 'Compaction did not return a complete response.');
+        }
+        catch (error) {
+            this.signal.throwIfAborted();
+            throw error;
+        }
+    }
+    async dispose() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        clearTimeout(this.#deadline);
+        clearInterval(this.#progressTimer);
+        await this.report('FINISHED');
+    }
+    report(state) {
+        const progress = {
+            state,
+            elapsedMs: Math.max(0, Date.now() - this.#startedAt),
+            inputTokensEstimate: this.#inputTokensEstimate,
+            modelRequests: this.#modelRequests,
+            eventCounts: { ...this.#eventCounts },
+            textDeltaCharacters: this.#textDeltaCharacters,
+            ...(this.#firstOutputAfterMs === undefined
+                ? {}
+                : { firstOutputAfterMs: this.#firstOutputAfterMs }),
+            ...(this.#lastOutputAfterMs === undefined
+                ? {}
+                : { lastOutputAfterMs: this.#lastOutputAfterMs }),
+            timedOut: this.#controller.signal.aborted
+        };
+        this.#tail = this.#tail.then(() => this.record(progress)).catch(() => undefined);
+        return this.#tail;
+    }
+}

package/dist/agent-core/runtime/context/contracts.d.ts

@@ -0,0 +1,12 @@
+export interface EnvironmentContextState {
+    platform: string;
+    architecture?: string;
+    shell?: {
+        readonly name: string;
+        readonly path: string;
+    };
+    guaranteedCommands?: Readonly<Record<string, string>>;
+    workspace: string;
+    currentDate?: string;
+    timezone?: string;
+}

package/dist/{runtime/environment-context.d.ts → agent-core/runtime/context/environment.d.ts}

@@ -1,5 +1,5 @@
-import type { ModelMessage } from '../model/contracts.js';
-import { type EnvironmentContextState } from '../prompts/core.js';
+import type { ModelMessage } from '../../model/contracts.js';
+import type { EnvironmentContextState } from './contracts.js';
 export declare function restoreEnvironmentState(payload: unknown): EnvironmentContextState | undefined;
 export declare function environmentContextUpdate(current: EnvironmentContextState, previous?: EnvironmentContextState, contextualEntries?: readonly string[]): ModelMessage | undefined;
 export declare function currentLocalTimeContext(instant?: Date, timezone?: string): Pick<EnvironmentContextState, 'currentDate' | 'timezone'>;

package/dist/{runtime/environment-context.js → agent-core/runtime/context/environment.js}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { buildEnvironmentContext } from '../prompts/core.js';
+import { buildEnvironmentContext } from '../../prompts/core.js';
 const environmentStateSchema = z
     .object({
     platform: z.string().min(1).max(64),

package/dist/{runtime/context-gc-runtime.d.ts → agent-core/runtime/context/gc-runtime.d.ts}

@@ -1,7 +1,7 @@
-import type { ClientToolDefinition, ModelUsage } from '../model/contracts.js';
-import { type ContextGcPlatform } from '../session/context-gc-checkpoint.js';
-import { JsonlSessionStore, type SessionRecord } from '../session/jsonl-store.js';
-import { type ContextProjection } from './context-projection.js';
+import type { ClientToolDefinition, ModelUsage } from '../../model/contracts.js';
+import { type ContextGcPlatform } from '../../session/context-gc-checkpoint.js';
+import { JsonlSessionStore, type SessionRecord } from '../../session/jsonl-store.js';
+import { type ContextProjection } from './projection.js';
 export interface ContextGcRuntimeInput {
     readonly store: JsonlSessionStore;
     readonly sessionId: string;

package/dist/{runtime/context-gc-runtime.js → agent-core/runtime/context/gc-runtime.js}

@@ -1,7 +1,7 @@
 import { isDeepStrictEqual } from 'node:util';
-import { ContextGcCheckpointCache, contextGcMinimumUsageGrowth, contextGcReplacementKey, contextGcSourceProjectionHash } from '../session/context-gc-checkpoint.js';
-import { CONTEXT_GC_POLICY, contextGcEligibleUsage, inspectContextGc } from './context-gc.js';
-import { buildContextProjection } from './context-projection.js';
+import { ContextGcCheckpointCache, contextGcMinimumUsageGrowth, contextGcReplacementKey, contextGcSourceProjectionHash } from '../../session/context-gc-checkpoint.js';
+import { CONTEXT_GC_POLICY, contextGcEligibleUsage, inspectContextGc } from './gc.js';
+import { buildContextProjection } from './projection.js';
 /** Only scheduling metadata survives a call; records and validation caches do not. */
 export class ContextGcRuntime {
     #scope = '';

package/dist/{runtime/context-gc-tokens.d.ts → agent-core/runtime/context/gc-tokens.d.ts}

@@ -1,5 +1,5 @@
-import type { ClientToolDefinition, ModelMessage } from '../model/contracts.js';
-export { MODEL_TOKEN_ESTIMATOR as CONTEXT_GC_TOKEN_ESTIMATOR } from './token-budget.js';
+import type { ClientToolDefinition, ModelMessage } from '../../model/contracts.js';
+export { MODEL_TOKEN_ESTIMATOR as CONTEXT_GC_TOKEN_ESTIMATOR } from '../token-budget.js';
 interface TokenContext {
     readonly modelId: string;
     readonly modelProtocol?: string;

package/dist/{runtime/context-gc-tokens.js → agent-core/runtime/context/gc-tokens.js}

@@ -1,6 +1,6 @@
-import { openAiInput } from '../model/openai-responses.js';
-import { countModelTokens } from './token-budget.js';
-export { MODEL_TOKEN_ESTIMATOR as CONTEXT_GC_TOKEN_ESTIMATOR } from './token-budget.js';
+import { openAiInput } from '../../model/openai-responses.js';
+import { countModelTokens } from '../token-budget.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) => ({

package/dist/{runtime/context-gc.d.ts → agent-core/runtime/context/gc.d.ts}

@@ -1,6 +1,6 @@
-import type { ClientToolDefinition, ModelMessage, ModelUsage } from '../model/contracts.js';
-import { ContextGcCheckpointCache, type ContextGcCheckpointDraft, type ContextGcEconomicsPolicy, type ContextGcMetrics, type ContextGcPlatform, type ContextGcReplacement } from '../session/context-gc-checkpoint.js';
-import type { SessionRecord } from '../session/jsonl-store.js';
+import type { ClientToolDefinition, ModelMessage, ModelUsage } from '../../model/contracts.js';
+import { ContextGcCheckpointCache, type ContextGcCheckpointDraft, type ContextGcEconomicsPolicy, type ContextGcMetrics, type ContextGcPlatform, type ContextGcReplacement } from '../../session/context-gc-checkpoint.js';
+import type { SessionRecord } from '../../session/jsonl-store.js';
 export declare const CONTEXT_GC_POLICY: ContextGcEconomicsPolicy;
 interface ContextGcEconomicsInput {
     readonly contextUsageTokens: number;

package/dist/{runtime/context-gc.js → agent-core/runtime/context/gc.js}

@@ -1,9 +1,9 @@
-import { ContextGcCheckpointCache, contextGcBaseFromRecords, contextGcLogicalPathKey, contextGcMinimumUsageGrowth, contextGcRecordSourceHash, contextGcTargetKey, normalizeContextGcReplacements } from '../session/context-gc-checkpoint.js';
-import { codeCellCompletionSequence, contextGcApplyPatchInputReplacement, contextGcCodeModeInputReplacement, contextGcCodeModeOutputReplacement, contextGcExecInputReplacement, contextGcExecOutputReplacement, contextGcPatchResultFromCompletedPayload, contextGcStaleReadReplacement, contextGcWebOutputReplacement, normalizeContextGcCodeModeInput, normalizeContextGcExecResult } from '../session/context-gc-replacements.js';
-import { contextGcSubagentNeedsRetainedPriorFinal, contextGcSubagentOutputReplacement, contextGcSubagentPriorFinalIsRetained, contextGcSubagentSnapshotIsPreciselyCovered, contextGcSubagentSnapshotIsSuperseded, contextGcSubagentSnapshotTurnId, normalizeContextGcSubagentSnapshot } from '../session/context-gc-subagent.js';
-import { parseReadContextOutput } from '../tools/read-context.js';
-import { CONTEXT_GC_TOKEN_ESTIMATOR, contextGcCacheImpact, contextGcMessageTokens, contextGcPrefixTokens, contextGcReclaimedTokens } from './context-gc-tokens.js';
-import { applyContextGcReplacementsToMessages, providerToolCallId, providerToolName } from './context-projection.js';
+import { ContextGcCheckpointCache, contextGcBaseFromRecords, contextGcLogicalPathKey, contextGcMinimumUsageGrowth, contextGcRecordSourceHash, contextGcTargetKey, normalizeContextGcReplacements } from '../../session/context-gc-checkpoint.js';
+import { codeCellCompletionSequence, contextGcApplyPatchInputReplacement, contextGcCodeModeInputReplacement, contextGcCodeModeOutputReplacement, contextGcExecInputReplacement, contextGcExecOutputReplacement, contextGcPatchResultFromCompletedPayload, contextGcStaleReadReplacement, contextGcWebOutputReplacement, normalizeContextGcCodeModeInput, normalizeContextGcExecResult } from '../../session/context-gc-replacements.js';
+import { contextGcSubagentNeedsRetainedPriorFinal, contextGcSubagentOutputReplacement, contextGcSubagentPriorFinalIsRetained, contextGcSubagentSnapshotIsPreciselyCovered, contextGcSubagentSnapshotIsSuperseded, contextGcSubagentSnapshotTurnId, normalizeContextGcSubagentSnapshot } from '../../session/context-gc-subagent.js';
+import { parseReadContextOutput } from '../../tools/local/read-context.js';
+import { CONTEXT_GC_TOKEN_ESTIMATOR, contextGcCacheImpact, contextGcMessageTokens, contextGcPrefixTokens, contextGcReclaimedTokens } from './gc-tokens.js';
+import { applyContextGcReplacementsToMessages, providerToolCallId, providerToolName } from './projection.js';
 export const CONTEXT_GC_POLICY = {
     version: 1,
     immediatePaybackRollouts: 3,

package/dist/{runtime → agent-core/runtime/context}/instructions.d.ts

@@ -1,4 +1,4 @@
-import type { HostSkill } from '../sdk/types.js';
+import type { HostSkill } from '../../host/contracts.js';
 export interface AgentInstructionEntry {
     kind: 'user' | 'project' | 'scoped';
     label: string;

package/dist/{runtime → agent-core/runtime/context}/instructions.js

@@ -1,6 +1,6 @@
 import { open, readdir, realpath, stat } from 'node:fs/promises';
 import { dirname, isAbsolute, join, parse, posix, relative, resolve } from 'node:path';
-import { MarAgentError } from '../error.js';
+import { MarAgentError } from '../../error.js';
 const MAX_FILE_BYTES = 64 * 1024;
 const MAX_PROJECT_BYTES = 32 * 1024;
 const INSTRUCTION_FILENAMES = ['AGENTS.override.md', 'AGENTS.md'];

package/dist/{runtime → agent-core/runtime/context}/normalize.d.ts

@@ -1,4 +1,4 @@
-import type { ModelMessage } from '../model/contracts.js';
+import type { ModelMessage } from '../../model/contracts.js';
 export interface NormalizeModelContextInput {
     supportsImages: boolean;
 }

package/dist/{runtime/context-projection.d.ts → agent-core/runtime/context/projection.d.ts}

@@ -1,6 +1,6 @@
-import type { ModelMessage } from '../model/contracts.js';
-import { type ContextGcCheckpointCache, type ContextGcCheckpointPayload, type ContextGcReplacement } from '../session/context-gc-checkpoint.js';
-import type { SessionRecord } from '../session/jsonl-store.js';
+import type { ModelMessage } from '../../model/contracts.js';
+import { type ContextGcCheckpointCache, type ContextGcCheckpointPayload, type ContextGcReplacement } from '../../session/context-gc-checkpoint.js';
+import type { SessionRecord } from '../../session/jsonl-store.js';
 export interface ContextProjectionEntry {
     readonly record: SessionRecord;
     readonly message: ModelMessage;

package/dist/{runtime/context-projection.js → agent-core/runtime/context/projection.js}

@@ -1,7 +1,7 @@
-import { anthropicThinkingBlock } from '../model/anthropic-thinking.js';
-import { latestValidContextGcCheckpoint, contextGcRecordSourceHash, contextGcTargetKey } from '../session/context-gc-checkpoint.js';
-import { TOOL_EXECUTION_LIMITS } from '../tools/execution-limits.js';
-import { replaceReadContextItems } from '../tools/read-context.js';
+import { anthropicThinkingBlock } from '../../model/anthropic-thinking.js';
+import { contextGcRecordSourceHash, contextGcTargetKey, latestValidContextGcCheckpoint } from '../../session/context-gc-checkpoint.js';
+import { TOOL_EXECUTION_LIMITS } from '../../tools/execution-limits.js';
+import { replaceReadContextItems } from '../../tools/local/read-context.js';
 const MAX_MODEL_CONTEXT_BYTES = 1024 * 1024;
 export function buildContextProjection(records, workspace, checkpointCache) {
     let activeModelId;

package/dist/agent-core/runtime/context/request-budget.d.ts

@@ -0,0 +1,6 @@
+import type { ClientToolDefinition, ModelMessage } from '../../model/contracts.js';
+export declare function estimatedRequestTokens(system: string, messages: readonly ModelMessage[], tools: readonly ClientToolDefinition[], images?: readonly {
+    mimeType: string;
+    dataBase64: string;
+}[]): number;
+export declare function stableJson(value: unknown): string;

package/dist/agent-core/runtime/context/request-budget.js

@@ -0,0 +1,22 @@
+import { AGENT_EXECUTION_POLICY } from '../execution-policy.js';
+import { countModelTokens } from '../token-budget.js';
+export function estimatedRequestTokens(system, messages, tools, images) {
+    const transientImageCount = messages.reduce((total, message) => total + (message.images?.length ?? 0), images?.length ?? 0);
+    const textMessages = messages.map((message) => {
+        const textMessage = { ...message };
+        delete textMessage.images;
+        return textMessage;
+    });
+    return (countModelTokens(`${system}${stableJson(textMessages)}${stableJson(tools)}`) +
+        transientImageCount * AGENT_EXECUTION_POLICY.estimatedTokensPerImage);
+}
+export function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(',')}]`;
+    if (value !== null && typeof value === 'object')
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`)
+            .join(',')}}`;
+    return JSON.stringify(value) ?? 'undefined';
+}

package/dist/agent-core/runtime/context/restore.d.ts

@@ -0,0 +1,15 @@
+import type { ModelMessage } from '../../model/contracts.js';
+import { type JsonlSessionStore } from '../../session/jsonl-store.js';
+import type { EnvironmentContextState } from './contracts.js';
+import { type ContextProjection } from './projection.js';
+export declare function restoreMessages(store: JsonlSessionStore, sessionId: string, records: readonly import('../../session/jsonl-store.js').SessionRecord[], options: {
+    includeImages: boolean;
+    currentTurnId?: string;
+    projection?: ContextProjection;
+}): Promise<{
+    environmentState: EnvironmentContextState | undefined;
+    userMessages: string[];
+    messages: ModelMessage[];
+    ignoredImages: number;
+    currentTurnUserIndex: number | undefined;
+}>;

package/dist/agent-core/runtime/context/restore.js

@@ -0,0 +1,85 @@
+import { MarAgentError } from '../../error.js';
+import { compactSummaryFromCheckpoint, replacementHistoryFromCheckpoint } from '../../session/jsonl-store.js';
+import { compactedHistoryMessages, continuationMessage } from '../compaction/history.js';
+import { environmentContextUpdate, restoreEnvironmentState } from './environment.js';
+import { buildContextProjection } from './projection.js';
+export async function restoreMessages(store, sessionId, records, options) {
+    const messages = [];
+    const modelProjection = new Map((options.projection ??
+        buildContextProjection(records, (await store.getSession(sessionId)).workspace)).entries.map((entry) => [entry.record.recordId, entry.message]));
+    let userMessages = [];
+    let ignoredImages = 0;
+    let currentTurnUserIndex;
+    let environmentState;
+    for (const record of records) {
+        const payload = record.payload;
+        const compactSummary = compactSummaryFromCheckpoint(record);
+        if (record.type === 'turn.user' && typeof payload.prompt === 'string') {
+            userMessages.push(payload.prompt);
+            let images = [];
+            if (options.includeImages)
+                try {
+                    images = await store.readInputImages(sessionId, payload.images);
+                }
+                catch (error) {
+                    if (!(error instanceof MarAgentError) || error.code !== 'MAR_AGENT_SESSION_CORRUPT')
+                        throw error;
+                    ignoredImages += Array.isArray(payload.images) ? payload.images.length : 1;
+                }
+            if (record.turnId === options.currentTurnId && currentTurnUserIndex === undefined)
+                currentTurnUserIndex = messages.length;
+            messages.push({
+                role: 'user',
+                content: payload.prompt,
+                ...(images.length ? { images } : {})
+            });
+        }
+        else if ((record.type === 'message.completed' || record.type === 'plan.completed') &&
+            typeof payload.text === 'string')
+            messages.push({ role: 'assistant', content: payload.text });
+        else if (compactSummary !== undefined) {
+            environmentState = restoreEnvironmentState({ version: 1, state: payload.environment });
+            if (environmentState)
+                messages.push(environmentContextUpdate(environmentState));
+            const history = replacementHistoryFromCheckpoint(record);
+            userMessages =
+                history
+                    ?.filter((message) => message.kind === 'user_input')
+                    .map((message) => message.content) ?? [];
+            messages.push(...(history
+                ? compactedHistoryMessages(history)
+                : [{ role: 'user', content: continuationMessage(compactSummary) }]));
+        }
+        else if (record.type === 'context.environment') {
+            const current = restoreEnvironmentState(payload);
+            if (current) {
+                const message = environmentContextUpdate(current, environmentState);
+                if (message)
+                    messages.push(message);
+                environmentState = current;
+            }
+        }
+        else if (record.type === 'model.context') {
+            const message = modelProjection.get(record.recordId);
+            if (message)
+                messages.push(message);
+        }
+    }
+    const completedToolCalls = new Set(messages.filter((message) => message.role === 'tool').map((message) => message.callId));
+    return {
+        environmentState,
+        userMessages,
+        messages: messages.filter((message) => {
+            if (message.role === 'tool_call')
+                return completedToolCalls.has(message.callId);
+            if (message.role !== 'provider' || message.provider !== 'OPENAI_RESPONSES')
+                return true;
+            const item = message.item;
+            if (item.type !== 'function_call' && item.type !== 'custom_tool_call')
+                return true;
+            return typeof item.call_id !== 'string' || completedToolCalls.has(item.call_id);
+        }),
+        ignoredImages,
+        currentTurnUserIndex
+    };
+}

package/dist/agent-core/runtime/context/usage.d.ts

@@ -0,0 +1,18 @@
+import { type MarAgentReasoningEffort } from '../../model/configuration.js';
+import type { ModelMessage } from '../../model/contracts.js';
+export interface AuthoritativeModelUsage {
+    readonly contextInputTokens: number;
+    readonly outputTokens: number | undefined;
+    readonly historyMessages?: readonly ModelMessage[];
+    readonly appendedMessages?: readonly ModelMessage[];
+}
+export declare function latestModelUsage(records: readonly import('../../session/jsonl-store.js').SessionRecord[], selectedModelId: string): AuthoritativeModelUsage | undefined;
+export declare function reasoningEffortBaseline(records: readonly import('../../session/jsonl-store.js').SessionRecord[], modelId: string): MarAgentReasoningEffort | undefined;
+export declare function lastConfigurationEffort(messages: readonly ModelMessage[], modelId: string): MarAgentReasoningEffort | undefined;
+export declare function shouldUseNativeCompaction(input: {
+    readonly estimatedRequestTokens: number;
+    readonly contextWindowTokens: number;
+    readonly latestUsage: AuthoritativeModelUsage | undefined;
+    readonly historyMessages: readonly ModelMessage[];
+    readonly appendedMessages: readonly ModelMessage[];
+}): boolean;

package/dist/agent-core/runtime/context/usage.js

@@ -0,0 +1,138 @@
+import { isDeepStrictEqual } from 'node:util';
+import { marAgentReasoningEffortSchema } from '../../model/configuration.js';
+import { compactSummaryFromCheckpoint } from '../../session/jsonl-store.js';
+import { countModelTokens } from '../token-budget.js';
+import { stableJson } from './request-budget.js';
+export function latestModelUsage(records, selectedModelId) {
+    let usage;
+    const toolCallIds = new Set();
+    // readContext starts at compact.completed, whose execution header is before the boundary.
+    let activeModelId = selectedModelId;
+    for (const record of records) {
+        const payload = record.payload;
+        if (compactSummaryFromCheckpoint(record) !== undefined) {
+            usage = undefined;
+            toolCallIds.clear();
+            activeModelId = modelIdFromPayload(payload);
+            continue;
+        }
+        if (record.type === 'execution.header') {
+            activeModelId = modelIdFromPayload(payload);
+            usage = undefined;
+            toolCallIds.clear();
+            continue;
+        }
+        if (record.type === 'model.context' && payload.role === 'tool_call') {
+            if (typeof payload.callId === 'string' && payload.callId.length > 0)
+                toolCallIds.add(payload.callId);
+            else
+                usage = undefined;
+        }
+        if (usage !== undefined) {
+            if (record.type === 'model.context') {
+                const role = payload.role;
+                if (role === 'tool') {
+                    if (typeof payload.callId !== 'string' || !toolCallIds.has(payload.callId))
+                        usage = undefined;
+                    else
+                        usage = {
+                            ...usage,
+                            appendedMessages: [
+                                ...(usage.appendedMessages ?? []),
+                                payload
+                            ]
+                        };
+                }
+                else if (role !== 'tool_call' && role !== 'assistant' && role !== 'provider')
+                    usage = undefined;
+            }
+            else if (invalidatesUsageCalibration(record.type, payload.type))
+                usage = undefined;
+        }
+        if (payload.type === 'usage.updated' && activeModelId === selectedModelId) {
+            const value = payload.contextInputTokens ?? payload.inputTokens;
+            if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0)
+                usage = {
+                    contextInputTokens: value,
+                    outputTokens: typeof payload.outputTokens === 'number' &&
+                        Number.isSafeInteger(payload.outputTokens) &&
+                        payload.outputTokens >= 0
+                        ? payload.outputTokens
+                        : undefined
+                };
+        }
+    }
+    return usage;
+}
+export function reasoningEffortBaseline(records, modelId) {
+    let baseline;
+    for (let index = records.length - 1; index >= 0; index--) {
+        const record = records[index];
+        if (compactSummaryFromCheckpoint(record) !== undefined)
+            break;
+        if (record.type !== 'execution.header')
+            continue;
+        const payload = record.payload;
+        if (payload.modelId !== modelId)
+            break;
+        const effort = marAgentReasoningEffortSchema.safeParse(payload.reasoningEffort);
+        if (effort.success)
+            baseline = effort.data;
+    }
+    return baseline;
+}
+export function lastConfigurationEffort(messages, modelId) {
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        if (message.role !== 'provider' ||
+            message.provider !== 'OPENAI_RESPONSES' ||
+            message.providerModelId !== modelId ||
+            message.item?.type !== 'configuration_update')
+            continue;
+        const reasoning = message.item.reasoning;
+        const effort = marAgentReasoningEffortSchema.safeParse(reasoning?.effort);
+        if (effort.success)
+            return effort.data;
+    }
+    return undefined;
+}
+export function shouldUseNativeCompaction(input) {
+    if (input.estimatedRequestTokens <= input.contextWindowTokens)
+        return true;
+    if (input.latestUsage === undefined || input.latestUsage.outputTokens === undefined)
+        return false;
+    const historyDelta = appendOnlyUsageDelta(input.latestUsage, input.historyMessages);
+    if (historyDelta === undefined)
+        return false;
+    const appendedTokens = countModelTokens(stableJson([...historyDelta, ...input.appendedMessages]));
+    return (input.latestUsage.contextInputTokens + input.latestUsage.outputTokens + appendedTokens <=
+        input.contextWindowTokens);
+}
+function appendOnlyUsageDelta(usage, historyMessages) {
+    if (usage.historyMessages === undefined)
+        return usage.appendedMessages ?? [];
+    if (historyMessages.length < usage.historyMessages.length)
+        return undefined;
+    for (let index = 0; index < usage.historyMessages.length; index++)
+        if (!isDeepStrictEqual(usage.historyMessages[index], historyMessages[index]))
+            return undefined;
+    const appended = historyMessages.slice(usage.historyMessages.length);
+    const toolCallIds = new Set(usage.historyMessages
+        .filter((message) => message.role === 'tool_call')
+        .map((message) => message.callId));
+    return appended.every((message) => (message.role === 'tool' && toolCallIds.has(message.callId)) ||
+        (message.role === 'user' && message.contextKind === 'environment'))
+        ? appended
+        : undefined;
+}
+function invalidatesUsageCalibration(recordType, payloadType) {
+    if (recordType === 'turn.user' ||
+        recordType === 'context.environment' ||
+        recordType === 'context.gc.completed')
+        return true;
+    return payloadType === 'message.completed';
+}
+function modelIdFromPayload(payload, key = 'modelId') {
+    const value = payload[key];
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}

package/dist/agent-core/runtime/context/world-state.d.ts

@@ -0,0 +1,35 @@
+import type { ModelMessage } from '../../model/contracts.js';
+export interface ContextualWorldState {
+    generation: string | undefined;
+    initialized: boolean;
+    instructionSnapshot: string | undefined;
+    resourceSnapshot: string | undefined;
+    mcpSnapshot?: string | undefined;
+    entries: Array<{
+        index: number;
+        kind: 'instructions' | 'resources' | 'mcp';
+        content: string;
+    }>;
+}
+export declare function insertContextualWorldState(messages: readonly ModelMessage[], entries: readonly {
+    index: number;
+    kind: 'instructions' | 'resources' | 'mcp';
+    content: string;
+}[]): ModelMessage[];
+export declare function latestContextualWorldStateGeneration(records: readonly import('../../session/jsonl-store.js').SessionRecord[]): string | undefined;
+export declare function parsePersistedContextualWorldState(payload: unknown): ContextualWorldState | undefined;
+export declare function persistContextualWorldState(store: import('../../session/jsonl-store.js').JsonlSessionStore, sessionId: string, state: ContextualWorldState): Promise<void>;
+export declare function compactHistoryMayContainRetainedResources(records: readonly import('../../session/jsonl-store.js').SessionRecord[]): boolean;
+export declare function updateContextualWorldState(state: ContextualWorldState, index: number, current: {
+    instructionSnapshot: string | undefined;
+    instructionContent: string | undefined;
+    resourceSnapshot: string | undefined;
+    previousMayContainResources?: boolean;
+}): ContextualWorldState;
+export declare function resetContextualWorldState(generation: string | undefined, index: number, current: {
+    instructionSnapshot: string | undefined;
+    instructionContent: string | undefined;
+    resourceSnapshot: string | undefined;
+    previousMayContainResources?: boolean;
+}): ContextualWorldState;
+export declare function contextualInstructionInsertIndex(messages: readonly ModelMessage[]): number;