@myagentroam/agent 0.11.33 → 0.11.35

package/dist/runtime/context/gc-candidates-exec.js

@@ -0,0 +1,131 @@
+import { contextGcTargetKey } from '../../session/context-gc-checkpoint.js';
+import { contextGcExecInputReplacement, contextGcExecOutputReplacement, normalizeContextGcExecResult } from '../../session/context-gc-replacements.js';
+import { CONTEXT_GC_POLICY } from './gc-economics.js';
+import { successfulRolloutsAfter, targetFor, isRecord } from './gc-candidates.js';
+export function collectExecCandidates(input, groups, existingTargets, candidateSavings) {
+    const eligible = [];
+    let protectedTokens = 0;
+    let retryAfterRollouts = Infinity;
+    const execGroups = [...groups.values()]
+        .filter((group) => group.toolName === 'exec' || group.toolName === 'exec_wait')
+        .sort((left, right) => (left.call?.record.sequence ?? Number.MAX_SAFE_INTEGER) -
+        (right.call?.record.sequence ?? Number.MAX_SAFE_INTEGER));
+    const invocations = new Map();
+    for (const group of execGroups) {
+        if (!group.call ||
+            !group.result ||
+            group.failed ||
+            !group.completed ||
+            group.call.message.role !== 'tool_call' ||
+            group.result.message.role !== 'tool' ||
+            !isRecord(group.call.message.arguments))
+            continue;
+        const result = normalizeContextGcExecResult(group.result.message.content, group.completed.payload);
+        if (result)
+            invocations.set(group.callId, {
+                group,
+                input: group.call.message.arguments,
+                result
+            });
+    }
+    for (const startGroup of execGroups) {
+        const start = invocations.get(startGroup.callId);
+        if (!start)
+            continue;
+        const isStart = start.group.toolName === 'exec' &&
+            (start.input.action === 'start' ||
+                (start.input.action == null && typeof start.input.command === 'string'));
+        const processId = typeof start.input.processId === 'string'
+            ? start.input.processId
+            : typeof start.result.processId === 'string'
+                ? start.result.processId
+                : undefined;
+        if (!isStart) {
+            if (start.group.toolName !== 'exec_wait' || !processId)
+                continue;
+            // A process may start inside a cell or before the visible history boundary.
+            // Begin with its first visible wait, but never split an unfinished lifecycle.
+            const previous = execGroups.findLast((group) => (group.call?.record.sequence ?? Infinity) < start.group.call.record.sequence &&
+                ((isRecord(group.call?.message.arguments) &&
+                    group.call.message.arguments.processId === processId) ||
+                    invocations.get(group.callId)?.result.processId === processId));
+            const previousStatus = previous && invocations.get(previous.callId)?.result.status;
+            if (previous && previousStatus !== 'completed' && previousStatus !== 'cancelled')
+                continue;
+        }
+        const lifecycle = [start];
+        let terminal = start.result.status !== 'running';
+        if (!terminal) {
+            if (!processId)
+                continue;
+            const relatedGroups = execGroups.filter((group) => (group.call?.record.sequence ?? 0) > start.group.call.record.sequence &&
+                isRecord(group.call?.message.arguments) &&
+                group.call.message.arguments.processId === processId);
+            if (relatedGroups.some((group) => !invocations.has(group.callId)) ||
+                relatedGroups.length === 0)
+                continue;
+            for (const relatedGroup of relatedGroups) {
+                const invocation = invocations.get(relatedGroup.callId);
+                lifecycle.push(invocation);
+                if (invocation.result.status !== 'running') {
+                    terminal = true;
+                    break;
+                }
+            }
+        }
+        if (!terminal || (processId && input.activeProcessIds.has(processId)))
+            continue;
+        const final = lifecycle.at(-1);
+        const evidenceSequence = final.group.result.record.sequence;
+        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 (!resultTarget) {
+                replacements.splice(0);
+                break;
+            }
+            if (callTarget && !existingTargets.has(contextGcTargetKey(callTarget)))
+                replacements.push({
+                    kind: 'TOOL_CALL_INPUT',
+                    toolName: invocation.group.toolName,
+                    callId: invocation.group.callId,
+                    target: callTarget,
+                    replacementArguments: contextGcExecInputReplacement(invocation.input, invocation.group.toolName),
+                    providerAliasTargets: invocation.group.aliases
+                        .map(({ record, message }) => targetFor(record, message))
+                        .filter((target) => target !== undefined),
+                    evidenceSequence
+                });
+            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),
+                    evidenceSequence
+                });
+        }
+        if (replacements.length === 0)
+            continue;
+        const candidate = {
+            replacements,
+            observedRollouts,
+            evidenceSequence
+        };
+        const reclaimedTokens = candidateSavings(candidate);
+        if (reclaimedTokens <= 0)
+            continue;
+        if (observedRollouts >= CONTEXT_GC_POLICY.largeExecProtectionRollouts)
+            eligible.push(candidate);
+        else {
+            protectedTokens += reclaimedTokens;
+            retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.largeExecProtectionRollouts - observedRollouts);
+        }
+    }
+    return { eligible, protectedTokens, retryAfterRollouts };
+}

package/dist/runtime/context/gc-candidates-read-patch.d.ts

@@ -0,0 +1,7 @@
+import { type ContextGcReplacement } from '../../session/context-gc-checkpoint.js';
+import { type ContextGcPlannerInput, type ContextCandidate, type CandidateSavings, type ToolGroup } from './gc-contracts.js';
+export declare function collectStageACandidates(input: ContextGcPlannerInput, groups: ReadonlyMap<string, ToolGroup>, existingReplacements: readonly ContextGcReplacement[], existingTargets: ReadonlySet<string>, candidateSavings: CandidateSavings): {
+    eligible: ContextCandidate[];
+    protectedTokens: number;
+    retryAfterRollouts: number;
+};

package/dist/runtime/context/gc-candidates-read-patch.js

@@ -0,0 +1,118 @@
+import { contextGcLogicalPathKey, contextGcTargetKey } from '../../session/context-gc-checkpoint.js';
+import { contextGcApplyPatchInputReplacement, contextGcPatchResultFromCompletedPayload, contextGcPatchResultFromFailedPayload, contextGcStaleReadReplacement } from '../../session/context-gc-replacements.js';
+import { parseReadContextOutput } from '../../prompts/read-context.js';
+import { CONTEXT_GC_POLICY } from './gc-economics.js';
+import { successfulRolloutsAfter, targetFor } from './gc-candidates.js';
+export function collectStageACandidates(input, groups, existingReplacements, existingTargets, candidateSavings) {
+    const eligible = [];
+    let protectedTokens = 0;
+    let retryAfterRollouts = Infinity;
+    const existingReadReplacements = new Map(existingReplacements.flatMap((replacement) => replacement.kind === 'READ_OUTPUT_ITEMS'
+        ? [[contextGcTargetKey(replacement.target), replacement]]
+        : []));
+    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}:${replacement.target.observationId ?? ''}:${item.index}`)));
+    const patches = [...groups.values()]
+        .flatMap((patch) => {
+        if (patch.toolName !== 'apply_patch' || !patch.call || !patch.result)
+            return [];
+        const terminal = patch.failed ?? patch.completed;
+        if (!terminal)
+            return [];
+        const result = patch.failed
+            ? contextGcPatchResultFromFailedPayload(terminal.payload)
+            : contextGcPatchResultFromCompletedPayload(terminal.payload);
+        return result
+            ? [{ patch, result, terminal, evidenceSequence: patch.result.record.sequence }]
+            : [];
+    })
+        .sort((left, right) => left.evidenceSequence - right.evidenceSequence);
+    for (const { patch, result, terminal, evidenceSequence } of patches) {
+        const patchCall = patch.call;
+        const observedRollouts = successfulRolloutsAfter(input.records, evidenceSequence, input.modelId, input.contextWindowTokens);
+        const replacements = [];
+        const candidateReadItems = new Set();
+        const patchTarget = targetFor(patchCall.record, patchCall.message);
+        if (!patch.failed && patchTarget && !existingTargets.has(contextGcTargetKey(patchTarget)))
+            replacements.push({
+                kind: 'TOOL_CALL_INPUT',
+                toolName: 'apply_patch',
+                callId: patch.callId,
+                target: patchTarget,
+                replacementArguments: contextGcApplyPatchInputReplacement(patchCall.message.arguments, result),
+                providerAliasTargets: patch.aliases
+                    .map(({ record, message }) => targetFor(record, message))
+                    .filter((target) => target !== undefined),
+                evidenceSequence
+            });
+        for (const read of reads) {
+            if ((read.completed?.sequence ?? read.result.record.sequence) >= terminal.sequence)
+                continue;
+            const parsed = parseReadContextOutput(read.result.message.content);
+            if (!parsed)
+                continue;
+            const selected = parsed.items.flatMap((item) => {
+                if (item.pathTruncated)
+                    return [];
+                const itemKey = `${read.result.record.recordId}:${read.result.message.observationId ?? ''}:${item.index}`;
+                if (claimedReadItems.has(itemKey) || candidateReadItems.has(itemKey))
+                    return [];
+                const pathKey = contextGcLogicalPathKey(item.path, input.workspace, input.platform);
+                const matched = result.files.find((file) => file.operation !== 'added' &&
+                    contextGcLogicalPathKey(file.path, input.workspace, input.platform) === pathKey);
+                if (!pathKey || !matched || matched.operation === 'added')
+                    return [];
+                candidateReadItems.add(itemKey);
+                return [
+                    {
+                        index: item.index,
+                        path: item.path,
+                        replacement: contextGcStaleReadReplacement({
+                            path: item.path,
+                            content: item.content,
+                            operation: matched.operation
+                        }),
+                        evidenceSequence,
+                        ...(read.result.message.observationId ? { supersededByCallId: patch.callId } : {})
+                    }
+                ];
+            });
+            if (selected.length === 0)
+                continue;
+            const target = targetFor(read.result.record, read.result.message);
+            if (!target)
+                continue;
+            const existingRead = existingReadReplacements.get(contextGcTargetKey(target));
+            replacements.push({
+                kind: 'READ_OUTPUT_ITEMS',
+                callId: read.callId,
+                target,
+                items: [...(existingRead?.items ?? []), ...selected],
+                evidenceSequences: [
+                    ...new Set([...(existingRead?.evidenceSequences ?? []), evidenceSequence])
+                ]
+            });
+        }
+        if (replacements.length === 0)
+            continue;
+        const candidate = {
+            replacements,
+            observedRollouts,
+            evidenceSequence
+        };
+        const reclaimedTokens = candidateSavings(candidate);
+        if (reclaimedTokens <= 0)
+            continue;
+        for (const itemKey of candidateReadItems)
+            claimedReadItems.add(itemKey);
+        if (observedRollouts >= CONTEXT_GC_POLICY.stageAProtectionRollouts)
+            eligible.push(candidate);
+        else {
+            protectedTokens += reclaimedTokens;
+            retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.stageAProtectionRollouts - observedRollouts);
+        }
+    }
+    return { eligible, protectedTokens, retryAfterRollouts };
+}

package/dist/runtime/context/gc-candidates-subagent.d.ts

@@ -0,0 +1,6 @@
+import { type ContextGcPlannerInput, type ContextCandidate, type CandidateSavings, type ToolGroup } from './gc-contracts.js';
+export declare function collectSubagentCandidates(input: ContextGcPlannerInput, groups: ReadonlyMap<string, ToolGroup>, existingTargets: ReadonlySet<string>, candidateSavings: CandidateSavings): {
+    eligible: ContextCandidate[];
+    protectedTokens: number;
+    retryAfterRollouts: number;
+};

package/dist/runtime/context/gc-candidates-subagent.js

@@ -0,0 +1,100 @@
+import { contextGcTargetKey } from '../../session/context-gc-checkpoint.js';
+import { contextGcSubagentNeedsRetainedPriorFinal, contextGcSubagentOutputReplacement, contextGcSubagentPriorFinalIsRetained, contextGcSubagentSnapshotIsPreciselyCovered, contextGcSubagentSnapshotIsSuperseded, contextGcSubagentSnapshotTurnId, normalizeContextGcSubagentSnapshot } from '../../session/context-gc-subagent.js';
+import { CONTEXT_GC_POLICY } from './gc-economics.js';
+import { successfulRolloutsAfter, targetFor } from './gc-candidates.js';
+export function collectSubagentCandidates(input, groups, existingTargets, candidateSavings) {
+    const eligible = [];
+    let protectedTokens = 0;
+    let retryAfterRollouts = Infinity;
+    const invocations = [...groups.values()]
+        .flatMap((group) => {
+        if (!isContextGcSubagentToolName(group.toolName) ||
+            !group.call ||
+            !group.result ||
+            group.failed ||
+            !group.completed ||
+            group.call.message.role !== 'tool_call' ||
+            group.result.message.role !== 'tool')
+            return [];
+        const snapshot = normalizeContextGcSubagentSnapshot(group.result.message.content, group.completed.payload, group.toolName);
+        const turnId = snapshot && contextGcSubagentSnapshotTurnId(snapshot);
+        return snapshot && turnId ? [{ group, snapshot, turnId }] : [];
+    })
+        .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')
+            continue;
+        const sourceTarget = targetFor(source.group.result.record, source.group.result.message);
+        if (!sourceTarget || existingTargets.has(contextGcTargetKey(sourceTarget)))
+            continue;
+        const needsRetainedPriorFinal = contextGcSubagentNeedsRetainedPriorFinal(source.snapshot);
+        const retainedPriorFinal = needsRetainedPriorFinal
+            ? invocations
+                .slice(0, index)
+                .findLast((candidate) => contextGcSubagentPriorFinalIsRetained(source.snapshot, candidate.snapshot))
+            : undefined;
+        if (needsRetainedPriorFinal && retainedPriorFinal === undefined)
+            continue;
+        const terminal = invocations
+            .slice(index + 1)
+            .find((candidate) => candidate.snapshot.agentId === source.snapshot.agentId &&
+            candidate.turnId === source.turnId &&
+            (contextGcSubagentSnapshotIsSuperseded(source.snapshot, candidate.snapshot, retainedPriorFinal?.snapshot) ||
+                contextGcSubagentSnapshotIsPreciselyCovered(source.snapshot, candidate.snapshot)));
+        if (!terminal)
+            continue;
+        const sourceContent = source.group.result.message.content;
+        if (typeof sourceContent !== 'string')
+            continue;
+        const evidenceSequence = terminal.group.result.record.sequence;
+        const observedRollouts = successfulRolloutsAfter(input.records, evidenceSequence, input.modelId, input.contextWindowTokens);
+        const replacement = {
+            kind: 'SUBAGENT_OUTPUT',
+            toolName: source.group.toolName,
+            callId: source.group.callId,
+            target: sourceTarget,
+            replacementContent: contextGcSubagentOutputReplacement({
+                sourceContent,
+                source: source.snapshot,
+                terminal: terminal.snapshot
+            }),
+            terminalToolName: terminal.group.toolName,
+            terminalCallId: terminal.group.callId,
+            evidenceSequence,
+            ...(retainedPriorFinal === undefined
+                ? {}
+                : {
+                    retainedPriorFinal: {
+                        toolName: retainedPriorFinal.group.toolName,
+                        callId: retainedPriorFinal.group.callId,
+                        evidenceSequence: retainedPriorFinal.group.result.record.sequence
+                    }
+                })
+        };
+        const candidate = {
+            replacements: [replacement],
+            observedRollouts,
+            evidenceSequence
+        };
+        const reclaimedTokens = candidateSavings(candidate);
+        if (reclaimedTokens <= 0)
+            continue;
+        if (observedRollouts >= CONTEXT_GC_POLICY.stageAProtectionRollouts)
+            eligible.push(candidate);
+        else {
+            protectedTokens += reclaimedTokens;
+            retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.stageAProtectionRollouts - observedRollouts);
+        }
+    }
+    return { eligible, protectedTokens, retryAfterRollouts };
+}
+function isContextGcSubagentToolName(value) {
+    return (value === 'agent_start' ||
+        value === 'agent_wait' ||
+        value === 'agent_message' ||
+        value === 'agent_cancel');
+}

package/dist/runtime/context/gc-candidates-web.d.ts

@@ -0,0 +1,6 @@
+import { type ContextGcPlannerInput, type ContextCandidate, type CandidateSavings, type ToolGroup } from './gc-contracts.js';
+export declare function collectWebCandidates(input: ContextGcPlannerInput, groups: ReadonlyMap<string, ToolGroup>, existingTargets: ReadonlySet<string>, candidateSavings: CandidateSavings): {
+    eligible: ContextCandidate[];
+    protectedTokens: number;
+    retryAfterRollouts: number;
+};

package/dist/runtime/context/gc-candidates-web.js

@@ -0,0 +1,58 @@
+import { contextGcTargetKey } from '../../session/context-gc-checkpoint.js';
+import { contextGcWebOutputReplacement } from '../../session/context-gc-replacements.js';
+import { CONTEXT_GC_POLICY } from './gc-economics.js';
+import { successfulRolloutsAfter, targetFor, isRecord } from './gc-candidates.js';
+export function collectWebCandidates(input, groups, existingTargets, candidateSavings) {
+    const eligible = [];
+    let protectedTokens = 0;
+    let retryAfterRollouts = Infinity;
+    for (const group of [...groups.values()].sort((left, right) => (left.result?.record.sequence ?? Number.MAX_SAFE_INTEGER) -
+        (right.result?.record.sequence ?? Number.MAX_SAFE_INTEGER))) {
+        if (!isContextGcWebToolName(group.toolName) ||
+            !group.call ||
+            !group.result ||
+            group.failed ||
+            !group.completed ||
+            group.call.message.role !== 'tool_call' ||
+            group.result.message.role !== 'tool' ||
+            typeof group.result.message.content !== 'string' ||
+            !isRecord(group.completed.payload) ||
+            group.completed.payload.type !== 'tool.completed' ||
+            group.completed.payload.callId !== group.callId ||
+            group.completed.payload.toolName !== group.toolName ||
+            typeof group.completed.payload.truncated !== 'boolean')
+            continue;
+        const target = targetFor(group.result.record, group.result.message);
+        if (!target || existingTargets.has(contextGcTargetKey(target)))
+            continue;
+        const evidenceSequence = group.result.record.sequence;
+        const observedRollouts = successfulRolloutsAfter(input.records, evidenceSequence, input.modelId, input.contextWindowTokens);
+        const candidate = {
+            replacements: [
+                {
+                    kind: 'WEB_OUTPUT',
+                    toolName: group.toolName,
+                    callId: group.callId,
+                    target,
+                    replacementContent: contextGcWebOutputReplacement(group.toolName, group.result.message.content, group.completed.payload.truncated),
+                    evidenceSequence
+                }
+            ],
+            observedRollouts,
+            evidenceSequence
+        };
+        const reclaimedTokens = candidateSavings(candidate);
+        if (reclaimedTokens <= 0)
+            continue;
+        if (observedRollouts >= CONTEXT_GC_POLICY.largeExecProtectionRollouts)
+            eligible.push(candidate);
+        else {
+            protectedTokens += reclaimedTokens;
+            retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.largeExecProtectionRollouts - observedRollouts);
+        }
+    }
+    return { eligible, protectedTokens, retryAfterRollouts };
+}
+function isContextGcWebToolName(value) {
+    return value === 'web_search' || value === 'web_fetch';
+}

package/dist/runtime/context/gc-candidates.d.ts

@@ -0,0 +1,12 @@
+import type { SessionModelMessage as ModelMessage } from '../../session/model-request.js';
+import { type ContextGcTarget } from '../../session/context-gc-checkpoint.js';
+import type { SessionRecord } from '../../session/record-contract.js';
+import { type ToolGroup } from './gc-contracts.js';
+export declare function buildToolGroups(records: readonly SessionRecord[], messages: readonly ModelMessage[], sources: readonly SessionRecord[]): Map<string, ToolGroup>;
+export declare function successfulRolloutsAfter(records: readonly SessionRecord[], evidenceSequence: number, modelId: string, contextWindowTokens: number): number;
+export declare function countSuccessfulNormalRollouts(records: readonly SessionRecord[], modelId: string, contextWindowTokens: number, initial?: {
+    modelId: string;
+    contextWindowTokens: number;
+}): number;
+export declare function targetFor(record: SessionRecord, message: ModelMessage): ContextGcTarget | undefined;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/runtime/context/gc-candidates.js

@@ -0,0 +1,192 @@
+import { codeCallEvidence, codePartialPatchCallEvidence, codeObservationEvidence } from '../../session/context-gc-observations.js';
+import { providerToolCallId, providerToolName } from './projection.js';
+export function buildToolGroups(records, messages, sources) {
+    const groups = new Map();
+    const group = (callId, toolName = '') => {
+        const current = groups.get(callId);
+        if (current) {
+            if (!current.toolName && toolName)
+                current.toolName = toolName;
+            return current;
+        }
+        const created = { callId, toolName, aliases: [] };
+        groups.set(callId, created);
+        return created;
+    };
+    for (const [index, message] of messages.entries()) {
+        const record = sources[index];
+        if (message.role === 'tool_call' && message.callId && message.name)
+            group(message.callId, message.name).call = { message, record };
+        else if (message.role === 'tool' && message.callId)
+            group(message.callId).result = { message, record };
+        else if (message.role === 'provider') {
+            const callId = providerToolCallId(message);
+            if (callId)
+                group(callId, providerToolName(message)).aliases.push({ message, record });
+        }
+    }
+    for (const record of records) {
+        if (!isRecord(record.payload))
+            continue;
+        const type = record.payload.type;
+        const callId = record.payload.callId;
+        const toolName = record.payload.toolName;
+        if (typeof callId !== 'string' || typeof toolName !== 'string')
+            continue;
+        const current = group(callId, toolName);
+        if (type === 'tool.completed')
+            current.completed = record;
+        else if (type === 'tool.failed')
+            current.failed = record;
+    }
+    for (const [index, message] of messages.entries()) {
+        if (!message.observations || message.role !== 'tool')
+            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) ||
+                (entry.status === 'completed' &&
+                    message.observations.some((value) => value.type === 'tool_result' && value.source.callId === entry.callId)))
+                continue;
+            const evidence = codeCallEvidence(records, record, entry) ??
+                codePartialPatchCallEvidence(records, record, entry);
+            if (!evidence)
+                continue;
+            groups.set(`execution:${evidence.callId}`, {
+                evidenceOnly: true,
+                callId: evidence.callId,
+                toolName: entry.toolName,
+                aliases: [],
+                ...('completed' in evidence
+                    ? { completed: evidence.completed }
+                    : { failed: evidence.failed }),
+                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;
+}
+export function successfulRolloutsAfter(records, evidenceSequence, modelId, contextWindowTokens) {
+    return countSuccessfulNormalRollouts(records.filter((record) => record.sequence > evidenceSequence), modelId, contextWindowTokens, modelConfigurationAt(records, evidenceSequence, modelId, contextWindowTokens));
+}
+export function countSuccessfulNormalRollouts(records, modelId, contextWindowTokens, initial = {
+    modelId,
+    contextWindowTokens
+}) {
+    let activeModelId = initial.modelId;
+    let activeContextWindowTokens = initial.contextWindowTokens;
+    let count = 0;
+    for (const record of records) {
+        if (record.type === 'execution.header' && isRecord(record.payload)) {
+            activeModelId =
+                typeof record.payload.modelId === 'string' ? record.payload.modelId : activeModelId;
+            activeContextWindowTokens =
+                typeof record.payload.contextWindowTokens === 'number' &&
+                    Number.isSafeInteger(record.payload.contextWindowTokens) &&
+                    record.payload.contextWindowTokens > 0
+                    ? record.payload.contextWindowTokens
+                    : activeContextWindowTokens;
+            continue;
+        }
+        if (activeModelId === modelId &&
+            activeContextWindowTokens === contextWindowTokens &&
+            record.type === 'model.attempt' &&
+            isRecord(record.payload) &&
+            record.payload.purpose === 'EXECUTION' &&
+            record.payload.state === 'SUCCEEDED')
+            count++;
+    }
+    return count;
+}
+function modelConfigurationAt(records, boundarySequence, fallbackModelId, fallbackContextWindowTokens) {
+    let modelId = fallbackModelId;
+    let contextWindowTokens = fallbackContextWindowTokens;
+    for (const record of records) {
+        if (record.sequence > boundarySequence)
+            break;
+        if (record.type !== 'execution.header' || !isRecord(record.payload))
+            continue;
+        if (typeof record.payload.modelId === 'string')
+            modelId = record.payload.modelId;
+        if (typeof record.payload.contextWindowTokens === 'number' &&
+            Number.isSafeInteger(record.payload.contextWindowTokens) &&
+            record.payload.contextWindowTokens > 0)
+            contextWindowTokens = record.payload.contextWindowTokens;
+    }
+    return { modelId, contextWindowTokens };
+}
+export function targetFor(record, message) {
+    if (record.type !== 'model.context' ||
+        (message.role !== 'tool_call' && message.role !== 'tool' && message.role !== 'provider'))
+        return undefined;
+    const callId = message.role === 'provider' ? providerToolCallId(message) : message.callId;
+    const toolName = message.role === 'provider' ? providerToolName(message) : message.name;
+    return {
+        sequence: record.sequence,
+        recordId: record.recordId,
+        role: message.role,
+        ...(callId === undefined ? {} : { callId }),
+        ...(toolName === undefined ? {} : { toolName }),
+        ...(message.observationId ? { observationId: message.observationId } : {})
+    };
+}
+export function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}