@myagentroam/agent 0.9.141 → 0.9.143

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) => ({
@@ -14,8 +14,10 @@ function serializedEntries(input, messages) {
             (input.messages ?? messages).some((message) => message.provider === 'OPENAI_RESPONSES'));
     const values = responses
         ? openAiInput(messages, undefined, input.modelId, true, true, input.responsesConfigurationUpdates !== false)
-        : messages.filter((message) => message.role !== 'provider' ||
-            (message.provider === 'ANTHROPIC_MESSAGES' && message.providerModelId === input.modelId));
+        : messages
+            .filter((message) => message.role !== 'provider' ||
+            (message.provider === 'ANTHROPIC_MESSAGES' && message.providerModelId === input.modelId))
+            .map(({ observations: _observations, observationId: _observationId, ...message }) => message);
     return values.map((value, index) => {
         const item = value;
         const callId = item.call_id ?? item.callId;

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,12 @@
-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 { countModelTokens } from '../token-budget.js';
+import { renderObservations } from '../../tools/code-mode/observations.js';
+import { codeCallEvidence, codeObservationEvidence, retainedCodeInputs } from '../../session/context-gc-observations.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,
@@ -258,6 +261,37 @@ function collectCodeModeCandidates(input, groups, existingTargets, usageRatio) {
             : LARGE_TERMINAL_OUTPUT_TOKENS;
         if (visibleTokens < minimumVisibleTokens)
             continue;
+        for (const observation of group.result.message.observations ?? []) {
+            if (observation.type !== 'value' ||
+                countModelTokens(observation.value) < minimumVisibleTokens)
+                continue;
+            const target = targetFor(group.result.record, {
+                ...group.result.message,
+                observationId: observation.id
+            });
+            if (!target || existingTargets.has(contextGcTargetKey(target)))
+                continue;
+            const evidenceSequence = group.result.record.sequence;
+            const candidate = {
+                replacements: [
+                    {
+                        kind: 'CODE_MODE_OUTPUT',
+                        callId: group.callId,
+                        target,
+                        replacementContent: contextGcCodeModeOutputReplacement(observation.value, observation.truncated === true),
+                        evidenceSequence
+                    }
+                ],
+                observedRollouts: successfulRolloutsAfter(input.records, Math.max(evidenceSequence, completionSequence), input.modelId, input.contextWindowTokens),
+                evidenceSequence
+            };
+            if (candidate.observedRollouts >= CONTEXT_GC_POLICY.largeExecProtectionRollouts)
+                eligible.push(candidate);
+            else {
+                protectedTokens += candidateTokens(input, candidate);
+                retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.largeExecProtectionRollouts - candidate.observedRollouts);
+            }
+        }
         const callTarget = targetFor(group.call.record, group.call.message);
         const resultTarget = targetFor(group.result.record, group.result.message);
         if (!callTarget || !resultTarget)
@@ -270,13 +304,14 @@ function collectCodeModeCandidates(input, groups, existingTargets, usageRatio) {
                 toolName: group.toolName,
                 callId: group.callId,
                 target: callTarget,
-                replacementArguments: contextGcCodeModeInputReplacement(code),
+                replacementArguments: contextGcCodeModeInputReplacement(code, group.result.message.observations ? retainedCodeInputs(input.records, group.callId) : []),
                 providerAliasTargets: group.aliases
                     .map(({ record, message }) => targetFor(record, message))
                     .filter((target) => target !== undefined),
                 evidenceSequence
             });
-        if (!existingTargets.has(contextGcTargetKey(resultTarget)))
+        if (!group.result.message.observations &&
+            !existingTargets.has(contextGcTargetKey(resultTarget)))
             replacements.push({
                 kind: 'CODE_MODE_OUTPUT',
                 callId: group.callId,
@@ -503,7 +538,7 @@ function collectStageACandidates(input, groups, existingReplacements, existingTa
     const reads = [...groups.values()].filter((group) => group.toolName === 'read' &&
         group.call?.message.role === 'tool_call' &&
         group.result?.message.role === 'tool');
-    const claimedReadItems = new Set([...existingReadReplacements.values()].flatMap((replacement) => replacement.items.map((item) => `${replacement.target.recordId}:${item.index}`)));
+    const claimedReadItems = new Set([...existingReadReplacements.values()].flatMap((replacement) => replacement.items.map((item) => `${replacement.target.recordId}:${replacement.target.observationId ?? ''}:${item.index}`)));
     const patches = [...groups.values()]
         .flatMap((patch) => {
         if (patch.toolName !== 'apply_patch' ||
@@ -534,7 +569,7 @@ function collectStageACandidates(input, groups, existingReplacements, existingTa
                 evidenceSequence
             });
         for (const read of reads) {
-            if (read.result.record.sequence >= evidenceSequence)
+            if ((read.completed?.sequence ?? read.result.record.sequence) >= patch.completed.sequence)
                 continue;
             const parsed = parseReadContextOutput(read.result.message.content);
             if (!parsed)
@@ -542,7 +577,7 @@ function collectStageACandidates(input, groups, existingReplacements, existingTa
             const selected = parsed.items.flatMap((item) => {
                 if (item.pathTruncated)
                     return [];
-                const itemKey = `${read.result.record.recordId}:${item.index}`;
+                const itemKey = `${read.result.record.recordId}:${read.result.message.observationId ?? ''}:${item.index}`;
                 if (claimedReadItems.has(itemKey))
                     return [];
                 const pathKey = contextGcLogicalPathKey(item.path, input.workspace, input.platform);
@@ -562,7 +597,8 @@ function collectStageACandidates(input, groups, existingReplacements, existingTa
                             supersededByCallId: patch.callId,
                             operation: matched.operation
                         }),
-                        evidenceSequence
+                        evidenceSequence,
+                        ...(read.result.message.observationId ? { supersededByCallId: patch.callId } : {})
                     }
                 ];
             });
@@ -616,8 +652,10 @@ function collectSubagentCandidates(input, groups, existingTargets) {
         const turnId = snapshot && contextGcSubagentSnapshotTurnId(snapshot);
         return snapshot && turnId ? [{ group, snapshot, turnId }] : [];
     })
-        .sort((left, right) => left.group.result.record.sequence - right.group.result.record.sequence);
+        .sort((left, right) => left.group.completed.sequence - right.group.completed.sequence);
     for (const [index, source] of invocations.entries()) {
+        if (source.group.evidenceOnly)
+            continue;
         if (source.group.toolName !== 'agent_wait' &&
             source.group.toolName !== 'agent_message' &&
             source.group.toolName !== 'agent_cancel')
@@ -759,7 +797,9 @@ function collectExecCandidates(input, groups, existingTargets, usageRatio) {
         if (!terminal || (processId && input.activeProcessIds.has(processId)))
             continue;
         const final = lifecycle.at(-1);
-        const visibleTokens = contextGcMessageTokens(input, lifecycle.flatMap((invocation) => [
+        const visibleTokens = contextGcMessageTokens(input, lifecycle
+            .filter((invocation) => !invocation.group.evidenceOnly)
+            .flatMap((invocation) => [
             invocation.group.call.message,
             invocation.group.result.message,
             ...invocation.group.aliases.map((alias) => alias.message)
@@ -773,13 +813,15 @@ function collectExecCandidates(input, groups, existingTargets, usageRatio) {
         const observedRollouts = successfulRolloutsAfter(input.records, evidenceSequence, input.modelId, input.contextWindowTokens);
         const replacements = [];
         for (const invocation of lifecycle) {
+            if (invocation.group.evidenceOnly)
+                continue;
             const callTarget = targetFor(invocation.group.call.record, invocation.group.call.message);
             const resultTarget = targetFor(invocation.group.result.record, invocation.group.result.message);
-            if (!callTarget || !resultTarget) {
+            if (!resultTarget) {
                 replacements.splice(0);
                 break;
             }
-            if (!existingTargets.has(contextGcTargetKey(callTarget)))
+            if (callTarget && !existingTargets.has(contextGcTargetKey(callTarget)))
                 replacements.push({
                     kind: 'TOOL_CALL_INPUT',
                     toolName: invocation.group.toolName,
@@ -794,6 +836,7 @@ function collectExecCandidates(input, groups, existingTargets, usageRatio) {
             if (!existingTargets.has(contextGcTargetKey(resultTarget)))
                 replacements.push({
                     kind: 'EXEC_OUTPUT',
+                    ...(resultTarget.observationId ? { terminalCallId: final.group.callId } : {}),
                     callId: invocation.group.callId,
                     target: resultTarget,
                     replacementContent: contextGcExecOutputReplacement(invocation.result),
@@ -918,6 +961,89 @@ function buildToolGroups(records, messages, sources) {
         else if (type === 'tool.failed')
             current.failed = record;
     }
+    for (const [index, message] of messages.entries()) {
+        if (!message.observations || message.role !== 'tool')
+            continue;
+        const outer = message.callId ? groups.get(message.callId) : undefined;
+        if (!outer?.completed ||
+            outer.failed ||
+            codeCellCompletionSequence(records, outer.completed) === undefined)
+            continue;
+        const record = sources[index];
+        for (const entry of message.calls ?? []) {
+            if (![
+                'apply_patch',
+                'exec',
+                'exec_wait',
+                'agent_start',
+                'agent_wait',
+                'agent_message',
+                'agent_cancel'
+            ].includes(entry.toolName) ||
+                message.observations.some((value) => value.type === 'tool_result' && value.source.callId === entry.callId))
+                continue;
+            const evidence = codeCallEvidence(records, record, entry);
+            if (!evidence)
+                continue;
+            groups.set(`execution:${evidence.callId}`, {
+                evidenceOnly: true,
+                callId: evidence.callId,
+                toolName: entry.toolName,
+                aliases: [],
+                completed: evidence.completed,
+                call: {
+                    record: evidence.call,
+                    message: {
+                        role: 'tool_call',
+                        callId: evidence.callId,
+                        name: entry.toolName,
+                        content: '',
+                        arguments: entry.input
+                    }
+                },
+                result: {
+                    record,
+                    message: {
+                        role: 'tool',
+                        callId: message.callId,
+                        content: evidence.result.payload.content
+                    }
+                }
+            });
+        }
+        for (const observation of message.observations) {
+            if (observation.type !== 'tool_result')
+                continue;
+            const evidence = codeObservationEvidence(records, record, observation);
+            if (!evidence)
+                continue;
+            groups.set(`${evidence.callId}:${observation.id}`, {
+                callId: evidence.callId,
+                toolName: observation.source.toolName,
+                aliases: [],
+                completed: evidence.completed,
+                call: {
+                    record: evidence.call,
+                    message: {
+                        role: 'tool_call',
+                        callId: evidence.callId,
+                        name: observation.source.toolName,
+                        content: '',
+                        arguments: observation.source.input
+                    }
+                },
+                result: {
+                    record,
+                    message: {
+                        role: 'tool',
+                        callId: message.callId,
+                        content: observation.result.content,
+                        observationId: observation.id
+                    }
+                }
+            });
+        }
+    }
     return groups;
 }
 function successfulRolloutsAfter(records, evidenceSequence, modelId, contextWindowTokens) {
@@ -1111,9 +1237,15 @@ function candidateTokens(input, candidate) {
             ? replacement.providerAliasTargets.map(contextGcTargetKey)
             : [])
     ]));
-    return contextGcMessageTokens(input, input.messages.filter((message, index) => {
+    return contextGcMessageTokens(input, input.messages.flatMap((message, index) => {
         const target = targetFor(input.messageSources[index], message);
-        return target !== undefined && targets.has(contextGcTargetKey(target));
+        if (target && targets.has(contextGcTargetKey(target)))
+            return [message];
+        const selected = target &&
+            message.observations?.filter((value) => targets.has(contextGcTargetKey({ ...target, observationId: value.id })));
+        return selected?.length
+            ? [{ ...message, observations: selected, content: renderObservations(selected) }]
+            : [];
     }));
 }
 function targetFor(record, message) {
@@ -1128,7 +1260,8 @@ function targetFor(record, message) {
         role: message.role,
         ...(callId === undefined ? {} : { callId }),
         ...(toolName === undefined ? {} : { toolName }),
-        sourceHash: contextGcRecordSourceHash(record)
+        sourceHash: contextGcRecordSourceHash(record),
+        ...(message.observationId ? { observationId: message.observationId } : {})
     };
 }
 function modelContextUsage(value) {

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,8 @@
-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';
+import { parseCodeCalls, parseObservations, renderObservationResult } from '../../tools/code-mode/observations.js';
 const MAX_MODEL_CONTEXT_BYTES = 1024 * 1024;
 export function buildContextProjection(records, workspace, checkpointCache) {
     let activeModelId;
@@ -50,6 +51,32 @@ export function applyContextGcReplacementsToMessages(messages, messageSources, r
             continue;
         const replacement = target ? direct.get(contextGcTargetKey(target)) : undefined;
         let next = cloneMessage(message);
+        if (next.observations && target) {
+            const observations = next.observations.map((value) => {
+                const itemTarget = { ...target, observationId: value.id };
+                const item = direct.get(contextGcTargetKey(itemTarget));
+                if (!item || !targetMatchesReplacement(itemTarget, item.target))
+                    return value;
+                if (item.kind === 'READ_OUTPUT_ITEMS' && value.type === 'tool_result')
+                    return {
+                        ...value,
+                        result: {
+                            ...value.result,
+                            content: replaceReadContextItems(value.result.content, item.items)
+                        }
+                    };
+                if ('replacementContent' in item)
+                    return value.type === 'tool_result'
+                        ? { ...value, result: { ...value.result, content: item.replacementContent } }
+                        : { ...value, value: item.replacementContent };
+                return value;
+            });
+            next = {
+                ...next,
+                observations,
+                content: renderObservationResult(observations, next.content)
+            };
+        }
         if (replacement && target && targetMatchesReplacement(target, replacement.target)) {
             if (replacement.kind === 'READ_OUTPUT_ITEMS' &&
                 next.role === 'tool' &&
@@ -122,6 +149,10 @@ export function restoreModelContext(payload, providerModelId) {
             role: 'tool',
             content: payload.content,
             callId: payload.callId,
+            ...(parseCodeCalls(payload.calls) ? { calls: parseCodeCalls(payload.calls) } : {}),
+            ...(parseObservations(payload.observations)
+                ? { observations: parseObservations(payload.observations) }
+                : {}),
             ...(Array.isArray(payload.toolSearchTools)
                 ? {
                     toolSearchTools: payload.toolSearchTools.filter((tool) => isRecord(tool) &&

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;