@myagentroam/agent 0.9.64 → 0.9.66

package/dist/sdk/agent.js

@@ -17,6 +17,7 @@ import { TOOL_EXECUTION_LIMITS } from '../tools/execution-limits.js';
 import { DEFAULT_COMPACTION_FOCUS, CompactionOperation, buildCompactionInput, buildCompactionMessages, buildCompactedHistory, compactedHistoryMessages, continuationMessage } from '../runtime/compact.js';
 import { buildSystemPrompt, MAR_AGENT_PROMPT_VERSION } from '../prompts/index.js';
 import { buildEnvironmentContext } from '../prompts/core.js';
+import { modelOutputContinuationMessage } from '../prompts/output.js';
 import { environmentContextUpdate, restoreEnvironmentState } from '../runtime/environment-context.js';
 import { childSubagentInstruction } from '../prompts/subagent.js';
 import { sessionTitlePrompt } from '../prompts/title.js';
@@ -46,6 +47,7 @@ export async function createMarAgent(options) {
     const generatedImageDisplayDirectory = normalizeGeneratedImageDisplayDirectory(options.generatedImageDisplayDirectory);
     const resolvedModels = resolveAgentModels(options.models);
     let { models, defaultModelId } = resolvedModels;
+    let modelGeneration = 0;
     const { credentialProviders } = resolvedModels;
     const description = negotiateHost(await options.host.describe());
     if (description.mode !== options.mode)
@@ -65,6 +67,15 @@ export async function createMarAgent(options) {
                 ? new OpenAiResponsesAdapter(configuration)
                 : new AnthropicMessagesAdapter(configuration)));
     };
+    const activeSessionIds = () => new Set([...active.keys()].map((key) => key.slice(0, key.indexOf(':'))));
+    const activeAdaptersExcept = (sessionId) => {
+        const activeAdapters = new Set();
+        for (const [candidateSessionId, runtime] of sessionRuntimes)
+            if (candidateSessionId !== sessionId && activeSessionIds().has(candidateSessionId))
+                for (const adapter of runtime.adapters.values())
+                    activeAdapters.add(adapter);
+        return activeAdapters;
+    };
     const openSession = async (sessionId, workspace) => {
         const storedSession = await store.getSession(sessionId);
         const storedWorkspace = storedSession.workspace;
@@ -85,7 +96,12 @@ export async function createMarAgent(options) {
         const environmentContext = buildEnvironmentContext(currentEnvironment);
         let sessionRuntime = sessionRuntimes.get(sessionId);
         if (sessionRuntime === undefined) {
-            sessionRuntime = { responsesChain: undefined, adapters: new Map() };
+            sessionRuntime = {
+                sourceType: sessionSource.type,
+                adapterGeneration: modelGeneration,
+                responsesChain: undefined,
+                adapters: new Map()
+            };
             sessionRuntimes.set(sessionId, sessionRuntime);
         }
         if (sessionSource.type === 'user' && sessionRuntime.subagents === undefined) {
@@ -110,6 +126,15 @@ export async function createMarAgent(options) {
             }
             return selected;
         };
+        const refreshSessionAdapters = async (generation) => {
+            if (sessionRuntime.adapterGeneration === generation)
+                return;
+            const retainedByActiveSessions = activeAdaptersExcept(sessionId);
+            await closeModelAdapters([...sessionRuntime.adapters.values()].filter((adapter) => !retainedByActiveSessions.has(adapter)));
+            sessionRuntime.responsesChain = undefined;
+            sessionRuntime.adapters.clear();
+            sessionRuntime.adapterGeneration = generation;
+        };
         const execution = (mode, input, internal = {}) => {
             if (disposed)
                 throw new MarAgentError('MAR_AGENT_DISPOSED', 'Agent is disposed.');
@@ -120,6 +145,7 @@ export async function createMarAgent(options) {
             const executionId = randomUUID(), turnId = internal.turnId ?? randomUUID(), queue = new AsyncQueue(), controller = new AbortController();
             const executionModels = models;
             const executionDefaultModelId = defaultModelId;
+            const executionModelGeneration = modelGeneration;
             const manualCompactionId = mode === 'compact' ? randomUUID() : undefined;
             active.set(`${sessionId}:${executionId}`, controller);
             const mailbox = [...(internal.initialMailbox ?? [])];
@@ -219,6 +245,7 @@ export async function createMarAgent(options) {
                 const subagents = sessionSource.type === 'user' ? sessionRuntime.subagents : undefined;
                 try {
                     releaseSession = await store.acquireSessionLease(sessionId);
+                    await refreshSessionAdapters(executionModelGeneration);
                     const sessionState = await store.readExecutionState(sessionId);
                     const todo = TodoStore.restore(sessionState.todo);
                     const contextRecords = sessionState.contextRecords;
@@ -350,6 +377,9 @@ export async function createMarAgent(options) {
                                 ...(task.latestMessage === undefined
                                     ? {}
                                     : { latestMessage: task.latestMessage }),
+                                ...(task.latestActivity === undefined
+                                    ? {}
+                                    : { latestActivity: task.latestActivity }),
                                 ...(task.errorCode === undefined ? {} : { errorCode: task.errorCode }),
                                 ...(task.errorMessage === undefined ? {} : { errorMessage: task.errorMessage })
                             }),
@@ -599,6 +629,8 @@ export async function createMarAgent(options) {
                             throw new MarAgentError('MAR_AGENT_CONTEXT_LIMIT', 'Provider usage reached the compaction threshold but no history can be compacted.');
                     };
                     let recoveringFromContextOverflow = false;
+                    let maxOutputContinuationUsed = false;
+                    let pendingOutputContinuation;
                     const modelRetryState = { attempts: 0 };
                     while (true) {
                         await appendMailboxMessages();
@@ -607,6 +639,7 @@ export async function createMarAgent(options) {
                         let responseId;
                         let latestUsage;
                         const pendingTools = [];
+                        let incompleteToolCall = false;
                         await ensureContextBudget();
                         const toolsAllowed = mode !== 'compact' && (!rolloutBudget?.active || rolloutBudget.stage !== 'exhausted');
                         const roundTools = toolsAllowed ? executionTools : [];
@@ -620,17 +653,42 @@ export async function createMarAgent(options) {
                             reasoningEffort
                         }))
                             .digest('hex');
+                        const requestContextMessages = pendingOutputContinuation === undefined
+                            ? messages
+                            : [...messages, pendingOutputContinuation];
                         const continuation = selectedModel.responsesPreviousResponseId &&
                             sessionRuntime.responsesChain?.modelId === selectedModel.id &&
                             sessionRuntime.responsesChain.requestSignature === requestSignature &&
-                            sessionRuntime.responsesChain.messageCount <= messages.length
+                            sessionRuntime.responsesChain.messageCount <= requestContextMessages.length
                             ? {
                                 previousResponseId: sessionRuntime.responsesChain.responseId,
-                                deltaMessages: messages.slice(sessionRuntime.responsesChain.messageCount)
+                                deltaMessages: requestContextMessages.slice(sessionRuntime.responsesChain.messageCount)
                             }
                             : undefined;
+                        const modelMessages = normalizeMessagesForModel(insertContextualInstructions(requestContextMessages, agentInstructionInsertIndex, agentInstructionMessage), {
+                            supportsImages: selectedModel.inputCapabilities.includes('IMAGE')
+                        });
                         let sawModelSemanticEvent = false;
                         const roundMessageCount = messages.length;
+                        const persistToolCalls = async (calls) => {
+                            for (const call of calls) {
+                                const message = {
+                                    role: 'tool_call',
+                                    callId: call.callId,
+                                    name: call.name,
+                                    arguments: call.arguments,
+                                    ...(call.inputMode ? { inputMode: call.inputMode } : {}),
+                                    content: ''
+                                };
+                                messages.push(message);
+                                await store.append(sessionId, {
+                                    type: 'model.context',
+                                    payload: message,
+                                    executionId,
+                                    turnId
+                                });
+                            }
+                        };
                         try {
                             if (manualCompactionId !== undefined && !manualCompactionStarted) {
                                 manualCompactionStarted = true;
@@ -643,9 +701,7 @@ export async function createMarAgent(options) {
                             for await (const event of startModel({
                                 retryState: modelRetryState,
                                 system: systemPrompt,
-                                messages: normalizeMessagesForModel(insertContextualInstructions(messages, agentInstructionInsertIndex, agentInstructionMessage), {
-                                    supportsImages: selectedModel.inputCapabilities.includes('IMAGE')
-                                }),
+                                messages: modelMessages,
                                 tools: roundTools,
                                 ...(toolsAllowed ? {} : { allowTools: false }),
                                 promptCacheKey: sessionId,
@@ -764,26 +820,18 @@ export async function createMarAgent(options) {
                                 }
                                 else if (event.type === 'client_tool.call') {
                                     sawTool = true;
-                                    const message = {
-                                        role: 'tool_call',
-                                        callId: event.callId,
-                                        name: event.name,
-                                        arguments: event.arguments,
-                                        ...(event.inputMode ? { inputMode: event.inputMode } : {}),
-                                        content: ''
-                                    };
-                                    messages.push(message);
-                                    await store.append(sessionId, {
-                                        type: 'model.context',
-                                        payload: message,
-                                        executionId,
-                                        turnId
-                                    });
                                     pendingTools.push(event);
                                 }
                                 else if (event.type === 'completed')
                                     stop = event.reason;
                             }
+                            pendingOutputContinuation = undefined;
+                            incompleteToolCall = pendingTools.some((call) => call.argumentError !== undefined);
+                            if (!(stop === 'max_output' && incompleteToolCall)) {
+                                await persistToolCalls(pendingTools);
+                            }
+                            else
+                                pendingTools.splice(0, pendingTools.length);
                             modelRetryState.attempts = 0;
                         }
                         catch (error) {
@@ -794,6 +842,10 @@ export async function createMarAgent(options) {
                                 finalAnswer = '';
                                 if (mode === 'compact')
                                     messages.splice(roundMessageCount);
+                                if (pendingTools.some((call) => call.argumentError !== undefined))
+                                    pendingTools.splice(0, pendingTools.length);
+                                else if (pendingTools.length > 0)
+                                    await persistToolCalls(pendingTools);
                                 if (pendingTools.length === 0)
                                     continue;
                             }
@@ -952,6 +1004,24 @@ export async function createMarAgent(options) {
                                 finalAnswer = '';
                         }
                         rolloutBudget?.recordUsage(latestUsage);
+                        if (mode !== 'compact' && stop === 'max_output') {
+                            const needsContinuation = !sawTool || incompleteToolCall;
+                            if (needsContinuation) {
+                                if (maxOutputContinuationUsed ||
+                                    (rolloutBudget?.active && rolloutBudget.stage === 'exhausted'))
+                                    throw new MarAgentError('MAR_AGENT_MODEL_OUTPUT_INCOMPLETE', 'Model output reached its limit before completing.');
+                                maxOutputContinuationUsed = true;
+                                pendingOutputContinuation = {
+                                    role: 'user',
+                                    content: modelOutputContinuationMessage
+                                };
+                                finalAnswer = '';
+                                continue;
+                            }
+                            maxOutputContinuationUsed = false;
+                        }
+                        else
+                            maxOutputContinuationUsed = false;
                         if (mode !== 'compact' && latestUsage !== undefined) {
                             const committed = await contextGc.run({
                                 store,
@@ -1141,12 +1211,21 @@ export async function createMarAgent(options) {
         reconfigureModels: async (input) => {
             if (disposed)
                 throw new MarAgentError('MAR_AGENT_DISPOSED', 'Agent is disposed.');
-            if (active.size > 0 || reconfiguring)
-                throw new MarAgentError('MAR_AGENT_EXECUTION_ACTIVE', 'Models cannot be reconfigured while an execution is active.');
+            if (reconfiguring)
+                throw new MarAgentError('MAR_AGENT_EXECUTION_ACTIVE', 'Models are already being reconfigured for the next execution.');
             const next = resolveAgentModels(input.models, input.defaultModelId);
-            const adapters = [...sessionRuntimes.values()].flatMap((runtime) => [
-                ...runtime.adapters.values()
-            ]);
+            const activeSessions = activeSessionIds();
+            if ([...activeSessions].some((sessionId) => sessionRuntimes.get(sessionId)?.sourceType !== 'subagent'))
+                throw new MarAgentError('MAR_AGENT_EXECUTION_ACTIVE', 'Models cannot be reconfigured while a main execution is active.');
+            const activeAdapters = new Set();
+            for (const [sessionId, runtime] of sessionRuntimes)
+                if (activeSessions.has(sessionId))
+                    for (const adapter of runtime.adapters.values())
+                        activeAdapters.add(adapter);
+            const inactiveRuntimes = [...sessionRuntimes].flatMap(([sessionId, runtime]) => activeSessions.has(sessionId) ? [] : [runtime]);
+            const adapters = inactiveRuntimes
+                .flatMap((runtime) => [...runtime.adapters.values()])
+                .filter((adapter) => !activeAdapters.has(adapter));
             reconfiguring = true;
             try {
                 await closeModelAdapters(adapters);
@@ -1154,11 +1233,13 @@ export async function createMarAgent(options) {
                     throw new MarAgentError('MAR_AGENT_DISPOSED', 'Agent is disposed.');
                 models = next.models;
                 defaultModelId = next.defaultModelId;
+                modelGeneration++;
                 for (const provider of next.credentialProviders)
                     credentialProviders.add(provider);
-                for (const runtime of sessionRuntimes.values()) {
+                for (const runtime of inactiveRuntimes) {
                     runtime.responsesChain = undefined;
                     runtime.adapters.clear();
+                    runtime.adapterGeneration = modelGeneration;
                 }
             }
             finally {
@@ -1228,20 +1309,10 @@ function createSubagentBackend(store, workspace) {
             await store.delete(sessionId);
         },
         listChildren: async (parentSessionId) => {
-            const sessions = [];
-            let cursor;
-            do {
-                const page = await store.list({
-                    source: 'subagent',
-                    parentSessionId,
-                    limit: 200,
-                    ...(cursor === undefined ? {} : { cursor })
-                });
-                sessions.push(...page.sessions);
-                cursor = page.nextCursor;
-            } while (cursor !== undefined);
+            const sessions = await store.listSubagentChildren(parentSessionId);
             return Promise.all(sessions.map(async (session) => ({
                 id: session.id,
+                createdAt: session.createdAt,
                 source: session.source,
                 records: await store.read(session.id)
             })));
@@ -1260,6 +1331,7 @@ function createSubagentBackend(store, workspace) {
                 return undefined;
             return {
                 id: session.id,
+                createdAt: session.createdAt,
                 source: session.source,
                 records: await store.read(session.id)
             };

package/dist/sdk/types.d.ts

@@ -162,6 +162,7 @@ export type MarAgentEvent = MarAgentEventBase & ({
     modelName?: string;
     reasoningEffort?: MarAgentReasoningEffort;
     latestMessage?: import('../subagent/scheduler.js').SubagentLatestMessage;
+    latestActivity?: import('../subagent/scheduler.js').SubagentLatestActivity;
     errorCode?: string;
     errorMessage?: string;
 } | {

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

@@ -1,3 +1,4 @@
+import { type ContextGcWebToolName } from './context-gc-replacements.js';
 import { type ContextGcSubagentToolName } from './context-gc-subagent.js';
 import type { SessionRecord } from './jsonl-store.js';
 export declare const CONTEXT_GC_CHECKPOINT_VERSION: 1;
@@ -63,7 +64,7 @@ export type ContextGcReplacement = {
     readonly evidenceSequence: number;
 } | {
     readonly kind: 'SUBAGENT_OUTPUT';
-    readonly toolName: 'agent_wait' | 'agent_message';
+    readonly toolName: 'agent_wait' | 'agent_message' | 'agent_cancel';
     readonly callId: string;
     readonly target: ContextGcTarget;
     readonly replacementContent: string;
@@ -75,6 +76,13 @@ export type ContextGcReplacement = {
         readonly callId: string;
         readonly evidenceSequence: number;
     };
+} | {
+    readonly kind: 'WEB_OUTPUT';
+    readonly toolName: ContextGcWebToolName;
+    readonly callId: string;
+    readonly target: ContextGcTarget;
+    readonly replacementContent: string;
+    readonly evidenceSequence: number;
 };
 export interface ContextGcMetrics {
     readonly stage: 'STAGE_A' | 'STAGE_A_AND_EXEC';

package/dist/session/context-gc-checkpoint.js

@@ -2,8 +2,8 @@ import { createHash } from 'node:crypto';
 import { posix, win32 } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import { parseReadContextOutput } from '../tools/read-context.js';
-import { contextGcApplyPatchInputReplacement, contextGcExecInputReplacement, contextGcExecOutputReplacement, contextGcPatchResultFromCompletedPayload, contextGcStaleReadReplacement, normalizeContextGcExecResult } from './context-gc-replacements.js';
-import { contextGcSubagentNeedsRetainedPriorFinal, contextGcSubagentOutputReplacement, contextGcSubagentSnapshotIsSuperseded, normalizeContextGcSubagentSnapshot } from './context-gc-subagent.js';
+import { contextGcApplyPatchInputReplacement, contextGcWebOutputReplacement, contextGcExecInputReplacement, contextGcExecOutputReplacement, contextGcPatchResultFromCompletedPayload, contextGcStaleReadReplacement, normalizeContextGcExecResult } from './context-gc-replacements.js';
+import { contextGcSubagentNeedsRetainedPriorFinal, contextGcSubagentOutputReplacement, contextGcSubagentSnapshotIsPreciselyCovered, contextGcSubagentSnapshotIsSuperseded, normalizeContextGcSubagentSnapshot } from './context-gc-subagent.js';
 export const CONTEXT_GC_CHECKPOINT_VERSION = 1;
 export const CONTEXT_GC_MAX_TARGETS = 4_096;
 /** Disposable memoization for one evaluation's immutable record snapshot. */
@@ -251,7 +251,8 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
                         content: original.content,
                         evidenceSequence: item.evidenceSequence,
                         supersededByCallId: evidence.callId,
-                        operation: evidence.file.operation
+                        operation: evidence.file.operation,
+                        formatVersion: staleReadReplacementFormatVersion(item.replacement)
                     }));
         });
     }
@@ -261,7 +262,7 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
         return (evidence?.callId === replacement.callId &&
             evidence.call.sequence === replacement.target.sequence &&
             result !== undefined &&
-            isDeepStrictEqual(replacement.replacementArguments, contextGcApplyPatchInputReplacement(source.payload.arguments, result, replacement.evidenceSequence)));
+            isDeepStrictEqual(replacement.replacementArguments, contextGcApplyPatchInputReplacement(source.payload.arguments, result, replacement.evidenceSequence, applyPatchReplacementFormatVersion(replacement.replacementArguments))));
     }
     if (replacement.kind === 'SUBAGENT_OUTPUT') {
         const retainedPriorFinal = replacement.retainedPriorFinal;
@@ -293,24 +294,79 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
             (retainedPriorFinalEvidence === undefined ||
                 retainedPriorFinalEvidence.result.sequence < sourceEvidence.result.sequence) &&
             sourceEvidence.result.sequence < terminalEvidence.result.sequence &&
-            contextGcSubagentSnapshotIsSuperseded(sourceSnapshot, terminalSnapshot, retainedPriorFinalSnapshot) &&
+            (contextGcSubagentSnapshotIsSuperseded(sourceSnapshot, terminalSnapshot, retainedPriorFinalSnapshot) ||
+                contextGcSubagentSnapshotIsPreciselyCovered(sourceSnapshot, terminalSnapshot)) &&
             replacement.replacementContent ===
                 contextGcSubagentOutputReplacement({
                     sourceContent: sourceEvidence.result.payload.content,
                     source: sourceSnapshot,
                     terminal: terminalSnapshot,
                     terminalCallId: replacement.terminalCallId,
-                    evidenceSequence: replacement.evidenceSequence
+                    evidenceSequence: replacement.evidenceSequence,
+                    formatVersion: subagentReplacementFormatVersion(replacement.replacementContent)
                 }));
     }
+    if (replacement.kind === 'WEB_OUTPUT') {
+        const sourceEvidence = successfulToolEvidence(records, recordsBySequence, source.sequence, replacement.toolName);
+        if (!sourceEvidence ||
+            sourceEvidence.callId !== replacement.callId ||
+            hasFailedToolEvidence(records, sourceEvidence.call, sourceEvidence.result, replacement.toolName) ||
+            !completeWebToolEvidence(sourceEvidence.completed, sourceEvidence.result) ||
+            !isRecord(sourceEvidence.result.payload) ||
+            typeof sourceEvidence.result.payload.content !== 'string' ||
+            sourceEvidence.result.sequence !== replacement.evidenceSequence ||
+            !isRecord(sourceEvidence.completed.payload) ||
+            typeof sourceEvidence.completed.payload.truncated !== 'boolean')
+            return false;
+        return (replacement.replacementContent ===
+            contextGcWebOutputReplacement(replacement.toolName, sourceEvidence.result.payload.content, sourceEvidence.completed.payload.truncated));
+    }
     if (!isSuccessfulExecLifecycleEvidence(replacement, source, records, recordsBySequence))
         return false;
     if (replacement.kind === 'TOOL_CALL_INPUT')
-        return isDeepStrictEqual(replacement.replacementArguments, contextGcExecInputReplacement(source.payload.arguments));
+        return isDeepStrictEqual(replacement.replacementArguments, contextGcExecInputReplacement(source.payload.arguments, execInputReplacementFormatVersion(replacement.replacementArguments)));
     const targetEvidence = successfulToolEvidence(records, recordsBySequence, source.sequence, 'exec');
     const result = normalizeContextGcExecResult(source.payload.content, targetEvidence?.completed.payload);
     return (result !== undefined &&
-        replacement.replacementContent === contextGcExecOutputReplacement(result));
+        replacement.replacementContent ===
+            contextGcExecOutputReplacement(result, execOutputReplacementFormatVersion(replacement.replacementContent)));
+}
+function staleReadReplacementFormatVersion(value) {
+    return value.includes(' formatVersion="2"') ? 2 : 1;
+}
+function applyPatchReplacementFormatVersion(value) {
+    return typeof value === 'string' && value.includes(' formatVersion="2"') ? 2 : 1;
+}
+function subagentReplacementFormatVersion(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return isRecord(parsed) && isRecord(parsed.contextGc) && parsed.contextGc.formatVersion === 2
+            ? 2
+            : 1;
+    }
+    catch {
+        return 1;
+    }
+}
+function execInputReplacementFormatVersion(value) {
+    if (typeof value === 'string' && value.includes(' formatVersion="3"'))
+        return 3;
+    if (!isRecord(value) || !isRecord(value.contextGc))
+        return 1;
+    return value.contextGc.formatVersion === 3 ? 3 : value.contextGc.formatVersion === 2 ? 2 : 1;
+}
+function execOutputReplacementFormatVersion(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return isRecord(parsed) && parsed.contextGcFormatVersion === 3
+            ? 3
+            : isRecord(parsed) && parsed.contextGcFormatVersion === 2
+                ? 2
+                : 1;
+    }
+    catch {
+        return 1;
+    }
 }
 function toolNameForCallId(records, callId, beforeSequence) {
     const call = modelToolCallForCallId(records, callId, beforeSequence);
@@ -338,6 +394,25 @@ function successfulToolEvidence(records, recordsBySequence, evidenceSequence, to
         record.payload.toolName === toolName);
     return completed ? { callId, call, completed, result } : undefined;
 }
+function completeWebToolEvidence(completed, result) {
+    return (isRecord(completed.payload) &&
+        completed.payload.type === 'tool.completed' &&
+        typeof completed.payload.truncated === 'boolean' &&
+        isRecord(result.payload) &&
+        typeof result.payload.content === 'string');
+}
+function hasFailedToolEvidence(records, call, result, toolName) {
+    if (!isRecord(result.payload) || typeof result.payload.callId !== 'string')
+        return true;
+    const callId = result.payload.callId;
+    return records.some((record) => record.sequence > call.sequence &&
+        record.sequence < result.sequence &&
+        record.type === 'tool.failed' &&
+        isRecord(record.payload) &&
+        record.payload.type === 'tool.failed' &&
+        record.payload.callId === callId &&
+        record.payload.toolName === toolName);
+}
 function modelToolCallForCallId(records, callId, beforeSequence) {
     return records.findLast((record) => record.sequence < beforeSequence &&
         record.type === 'model.context' &&
@@ -499,10 +574,12 @@ function isContextGcReplacement(value) {
     if (value.kind === 'READ_OUTPUT_ITEMS') {
         const items = value.items;
         const evidenceSequences = value.evidenceSequences;
-        return (value.target.role === 'tool' &&
+        return (hasOnlyKeys(value, ['kind', 'callId', 'target', 'items', 'evidenceSequences']) &&
+            value.target.role === 'tool' &&
             Array.isArray(items) &&
             items.length > 0 &&
             items.every((item) => isRecord(item) &&
+                hasOnlyKeys(item, ['index', 'path', 'replacement', 'evidenceSequence']) &&
                 isNonnegativeInteger(item.index) &&
                 isNonemptyString(item.path) &&
                 isNonemptyString(item.replacement) &&
@@ -516,7 +593,16 @@ function isContextGcReplacement(value) {
             evidenceSequences.every((sequence) => items.some((item) => item.evidenceSequence === sequence)));
     }
     if (value.kind === 'TOOL_CALL_INPUT')
-        return (value.target.role === 'tool_call' &&
+        return (hasOnlyKeys(value, [
+            'kind',
+            'toolName',
+            'callId',
+            'target',
+            'replacementArguments',
+            'providerAliasTargets',
+            'evidenceSequence'
+        ]) &&
+            value.target.role === 'tool_call' &&
             (value.toolName === 'apply_patch' || value.toolName === 'exec') &&
             value.target.toolName === value.toolName &&
             Array.isArray(value.providerAliasTargets) &&
@@ -527,8 +613,21 @@ function isContextGcReplacement(value) {
             isPositiveInteger(value.evidenceSequence) &&
             value.replacementArguments !== undefined);
     if (value.kind === 'SUBAGENT_OUTPUT')
-        return (value.target.role === 'tool' &&
-            (value.toolName === 'agent_wait' || value.toolName === 'agent_message') &&
+        return (hasOnlyKeys(value, [
+            'kind',
+            'toolName',
+            'callId',
+            'target',
+            'replacementContent',
+            'terminalToolName',
+            'terminalCallId',
+            'evidenceSequence',
+            'retainedPriorFinal'
+        ]) &&
+            value.target.role === 'tool' &&
+            (value.toolName === 'agent_wait' ||
+                value.toolName === 'agent_message' ||
+                value.toolName === 'agent_cancel') &&
             (value.target.toolName === undefined || value.target.toolName === value.toolName) &&
             isNonemptyString(value.replacementContent) &&
             (value.terminalToolName === 'agent_start' ||
@@ -546,13 +645,29 @@ function isContextGcReplacement(value) {
                         value.retainedPriorFinal.toolName === 'agent_cancel') &&
                     isNonemptyString(value.retainedPriorFinal.callId) &&
                     isPositiveInteger(value.retainedPriorFinal.evidenceSequence))));
+    if (value.kind === 'WEB_OUTPUT')
+        return (hasOnlyKeys(value, [
+            'kind',
+            'toolName',
+            'callId',
+            'target',
+            'replacementContent',
+            'evidenceSequence'
+        ]) &&
+            value.target.role === 'tool' &&
+            (value.toolName === 'web_search' || value.toolName === 'web_fetch') &&
+            (value.target.toolName === undefined || value.target.toolName === value.toolName) &&
+            isNonemptyString(value.replacementContent) &&
+            isPositiveInteger(value.evidenceSequence));
     return (value.kind === 'EXEC_OUTPUT' &&
+        hasOnlyKeys(value, ['kind', 'callId', 'target', 'replacementContent', 'evidenceSequence']) &&
         value.target.role === 'tool' &&
         isNonemptyString(value.replacementContent) &&
         isPositiveInteger(value.evidenceSequence));
 }
 function isContextGcTarget(value) {
     return (isRecord(value) &&
+        hasOnlyKeys(value, ['sequence', 'recordId', 'role', 'callId', 'toolName', 'sourceHash']) &&
         isPositiveInteger(value.sequence) &&
         isNonemptyString(value.recordId) &&
         (value.role === 'tool_call' || value.role === 'tool' || value.role === 'provider') &&
@@ -635,6 +750,9 @@ function isContextGcMetrics(value) {
 function isRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
+function hasOnlyKeys(value, keys) {
+    return Object.keys(value).every((key) => keys.includes(key));
+}
 function isNonemptyString(value) {
     return typeof value === 'string' && value.length > 0;
 }

package/dist/session/context-gc-replacements.d.ts

@@ -1,3 +1,4 @@
+export type ContextGcWebToolName = 'web_search' | 'web_fetch';
 export interface ContextGcPatchFile {
     readonly path: string;
     readonly targetPath?: string;
@@ -38,15 +39,17 @@ export type ContextGcExecResult = {
     readonly modelContextContent: string;
 };
 export declare function contextGcPatchResultFromCompletedPayload(payload: unknown): ContextGcPatchResult | undefined;
-export declare function contextGcApplyPatchInputReplacement(arguments_: unknown, result: ContextGcPatchResult, evidenceSequence: number): string;
+export declare function contextGcApplyPatchInputReplacement(arguments_: unknown, result: ContextGcPatchResult, evidenceSequence: number, formatVersion?: 1 | 2): string;
 export declare function contextGcStaleReadReplacement(input: {
     readonly path: string;
     readonly content: string;
     readonly evidenceSequence: number;
     readonly supersededByCallId: string;
     readonly operation: Exclude<ContextGcPatchFile['operation'], 'added'>;
+    readonly formatVersion?: 1 | 2;
 }): string;
-export declare function contextGcExecInputReplacement(arguments_: unknown): unknown;
-export declare function contextGcExecOutputReplacement(result: ContextGcExecResult): string;
+export declare function contextGcWebOutputReplacement(toolName: ContextGcWebToolName, originalContent: string, truncated: boolean): string;
+export declare function contextGcExecInputReplacement(arguments_: unknown, formatVersion?: 1 | 2 | 3): unknown;
+export declare function contextGcExecOutputReplacement(result: ContextGcExecResult, formatVersion?: 1 | 2 | 3): string;
 export declare function normalizeContextGcExecResult(modelContent: unknown, completedPayload: unknown): ContextGcExecResult | undefined;
 export declare function parseContextGcExecResult(value: unknown): ContextGcExecResult | undefined;