@myagentroam/agent 0.9.142 → 0.9.143

package/dist/agent-core/model/anthropic-messages.js

@@ -1,3 +1,4 @@
+import { observationModelParts } from '../tools/code-mode/observations.js';
 import { randomUUID } from 'node:crypto';
 import { MarAgentError } from '../error.js';
 import { resolveModelDefaultReasoningEffort } from './configuration.js';
@@ -475,19 +476,29 @@ function anthropicMessages(messages, images, tools = [], modelId) {
             const block = {
                 type: 'tool_result',
                 tool_use_id: message.callId,
-                content: message.images?.length
-                    ? [
-                        { type: 'text', text: message.content },
-                        ...message.images.map((image) => ({
-                            type: 'image',
-                            source: {
-                                type: 'base64',
-                                media_type: image.mimeType,
-                                data: image.dataBase64
-                            }
-                        }))
-                    ]
-                    : message.content
+                content: observationModelParts(message)?.map((part) => part.type === 'text'
+                    ? { type: 'text', text: part.text }
+                    : {
+                        type: 'image',
+                        source: {
+                            type: 'base64',
+                            media_type: part.image.mimeType,
+                            data: part.image.dataBase64
+                        }
+                    }) ??
+                    (message.images?.length
+                        ? [
+                            { type: 'text', text: message.content },
+                            ...message.images.map((image) => ({
+                                type: 'image',
+                                source: {
+                                    type: 'base64',
+                                    media_type: image.mimeType,
+                                    data: image.dataBase64
+                                }
+                            }))
+                        ]
+                        : message.content)
             };
             const previous = result.at(-1);
             if (previous?.role === 'user' && Array.isArray(previous.content))

package/dist/agent-core/model/contracts.d.ts

@@ -2,6 +2,7 @@ import type { ClientToolDefinition } from '../tools/contracts.js';
 import type { MarAgentModelConfiguration, MarAgentReasoningEffort, ModelCredentialAcquireReason } from './configuration.js';
 export type { ClientToolDefinition, ToolCaller } from '../tools/contracts.js';
 export interface ModelMessage {
+    calls?: readonly import('../tools/code-mode/observations.js').CodeToolCallRecord[];
     role: 'user' | 'assistant' | 'tool' | 'tool_call' | 'provider';
     content: string;
     contextKind?: 'environment' | 'private';
@@ -18,6 +19,9 @@ export interface ModelMessage {
         mimeType: string;
         dataBase64: string;
     }[];
+    observations?: readonly import('../tools/code-mode/observations.js').CodeObservation[];
+    /** Runtime-only location used by the GC evidence adapter, never a Provider call. */
+    observationId?: string;
 }
 export interface ModelAttemptDiagnostic {
     protocol: MarAgentModelConfiguration['protocol'];

package/dist/agent-core/model/openai-responses.js

@@ -1,3 +1,4 @@
+import { observationModelParts } from '../tools/code-mode/observations.js';
 import { isDeepStrictEqual } from 'node:util';
 import { createHash, randomUUID } from 'node:crypto';
 import { describeMarAgentError, MarAgentError } from '../error.js';
@@ -1811,15 +1812,21 @@ function openAiInputItem(message, images, customCallIds = new Set(), nativeToolS
                 ? 'custom_tool_call_output'
                 : 'function_call_output',
             call_id: message.callId,
-            output: message.images?.length
-                ? [
-                    { type: 'input_text', text: message.content },
-                    ...message.images.map((image) => ({
-                        type: 'input_image',
-                        image_url: `data:${image.mimeType};base64,${image.dataBase64}`
-                    }))
-                ]
-                : message.content
+            output: observationModelParts(message)?.map((part) => part.type === 'text'
+                ? { type: 'input_text', text: part.text }
+                : {
+                    type: 'input_image',
+                    image_url: `data:${part.image.mimeType};base64,${part.image.dataBase64}`
+                }) ??
+                (message.images?.length
+                    ? [
+                        { type: 'input_text', text: message.content },
+                        ...message.images.map((image) => ({
+                            type: 'input_image',
+                            image_url: `data:${image.mimeType};base64,${image.dataBase64}`
+                        }))
+                    ]
+                    : message.content)
         };
     return {
         role: message.role,

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

@@ -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/agent-core/runtime/context/gc.js

@@ -1,3 +1,6 @@
+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';
@@ -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/agent-core/runtime/context/projection.js

@@ -2,6 +2,7 @@ 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/events.d.ts

@@ -82,6 +82,7 @@ export type MarAgentEvent = MarAgentEventBase & ({
     data?: CodeCellEventData | import('../tools/contracts.js').ExecResult | Omit<import('../tools/contracts.js').ExecResult, 'stdout' | 'stderr'> | import('../tools/contracts.js').ApplyPatchResult | import('../tools/contracts.js').ReadEventData | import('../tools/contracts.js').ViewImageResult | import('../subagent/contracts.js').SubagentTaskSnapshot;
 } | {
     type: 'tool.failed';
+    data?: import('../tools/contracts.js').CodeCellEventData;
     toolName: string;
     callId: string;
     parentCallId?: string;

package/dist/agent-core/runtime/execution.js

@@ -312,6 +312,8 @@ export class ExecutionLoop {
                     role: 'tool',
                     callId: result.call.callId,
                     content: result.content,
+                    ...(result.calls ? { calls: result.calls } : {}),
+                    ...(result.observations ? { observations: result.observations } : {}),
                     ...(toolSearchTools === undefined ? {} : { toolSearchTools }),
                     ...('images' in result && result.images?.length ? { images: result.images } : {})
                 };
@@ -320,6 +322,8 @@ export class ExecutionLoop {
                     role: message.role,
                     callId: result.call.callId,
                     content: message.content,
+                    ...(message.calls ? { calls: message.calls } : {}),
+                    ...(message.observations ? { observations: message.observations } : {}),
                     ...(message.toolSearchTools === undefined
                         ? {}
                         : { toolSearchTools: message.toolSearchTools })

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

@@ -29,6 +29,7 @@ export type ContextGcBase = {
     readonly recordId: string;
 };
 export interface ContextGcTarget {
+    readonly observationId?: string;
     readonly sequence: number;
     readonly recordId: string;
     readonly role: 'tool_call' | 'tool' | 'provider';
@@ -37,6 +38,7 @@ export interface ContextGcTarget {
     readonly sourceHash: string;
 }
 export interface ContextGcReadItemReplacement {
+    readonly supersededByCallId?: string;
     readonly index: number;
     readonly path: string;
     readonly replacement: string;
@@ -58,6 +60,7 @@ export type ContextGcReplacement = {
     readonly evidenceSequence: number;
 } | {
     readonly kind: 'EXEC_OUTPUT';
+    readonly terminalCallId?: string;
     readonly callId: string;
     readonly target: ContextGcTarget;
     readonly replacementContent: string;