@myagentroam/agent 0.9.62 → 0.9.65

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

@@ -0,0 +1,52 @@
+export interface ContextGcPatchFile {
+    readonly path: string;
+    readonly targetPath?: string;
+    readonly operation: 'added' | 'modified' | 'deleted' | 'moved';
+    readonly addedLines: number;
+    readonly deletedLines: number;
+}
+export interface ContextGcPatchResult {
+    readonly files: readonly ContextGcPatchFile[];
+    readonly totals: {
+        readonly files: number;
+        readonly addedLines: number;
+        readonly deletedLines: number;
+    };
+}
+export type ContextGcExecResult = {
+    readonly source: 'STRUCTURED';
+    readonly status: 'running' | 'completed' | 'cancelled';
+    readonly processId?: string;
+    readonly exitCode?: number | null;
+    readonly truncated: boolean;
+    readonly stdoutBytes: number;
+    readonly stderrBytes: number;
+    readonly stdoutDroppedBytes: number;
+    readonly stderrDroppedBytes: number;
+    readonly stdout: string;
+    readonly stderr: string;
+} | {
+    readonly source: 'MODEL_CONTEXT_TRUNCATED';
+    readonly status: 'completed' | 'cancelled';
+    readonly processId?: string;
+    readonly exitCode?: number | null;
+    readonly truncated: boolean;
+    readonly stdoutBytes: number;
+    readonly stderrBytes: number;
+    readonly stdoutDroppedBytes: number;
+    readonly stderrDroppedBytes: number;
+    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 contextGcStaleReadReplacement(input: {
+    readonly path: string;
+    readonly content: string;
+    readonly evidenceSequence: number;
+    readonly supersededByCallId: string;
+    readonly operation: Exclude<ContextGcPatchFile['operation'], 'added'>;
+}): string;
+export declare function contextGcExecInputReplacement(arguments_: unknown): unknown;
+export declare function contextGcExecOutputReplacement(result: ContextGcExecResult): string;
+export declare function normalizeContextGcExecResult(modelContent: unknown, completedPayload: unknown): ContextGcExecResult | undefined;
+export declare function parseContextGcExecResult(value: unknown): ContextGcExecResult | undefined;

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

@@ -0,0 +1,226 @@
+import { createHash } from 'node:crypto';
+const RAW_MODEL_CONTEXT_PREVIEW_CHARACTERS = 256;
+export function contextGcPatchResultFromCompletedPayload(payload) {
+    if (!isRecord(payload) || payload.type !== 'tool.completed')
+        return undefined;
+    const data = payload.data;
+    if (!isRecord(data) || !Array.isArray(data.files) || !isRecord(data.totals))
+        return undefined;
+    const files = data.files.flatMap((file) => isRecord(file) &&
+        isNonemptyString(file.path) &&
+        (file.operation === 'added' ||
+            file.operation === 'modified' ||
+            file.operation === 'deleted' ||
+            file.operation === 'moved') &&
+        (file.targetPath === undefined || isNonemptyString(file.targetPath)) &&
+        isNonnegativeInteger(file.addedLines) &&
+        isNonnegativeInteger(file.deletedLines)
+        ? [
+            {
+                path: file.path,
+                ...(typeof file.targetPath === 'string' ? { targetPath: file.targetPath } : {}),
+                operation: file.operation,
+                addedLines: file.addedLines,
+                deletedLines: file.deletedLines
+            }
+        ]
+        : []);
+    if (files.length !== data.files.length ||
+        files.length === 0 ||
+        !isNonnegativeInteger(data.totals.files) ||
+        !isNonnegativeInteger(data.totals.addedLines) ||
+        !isNonnegativeInteger(data.totals.deletedLines) ||
+        data.totals.files !== files.length ||
+        data.totals.addedLines !== files.reduce((total, file) => total + file.addedLines, 0) ||
+        data.totals.deletedLines !== files.reduce((total, file) => total + file.deletedLines, 0))
+        return undefined;
+    return {
+        files,
+        totals: {
+            files: data.totals.files,
+            addedLines: data.totals.addedLines,
+            deletedLines: data.totals.deletedLines
+        }
+    };
+}
+export function contextGcApplyPatchInputReplacement(arguments_, result, evidenceSequence) {
+    const original = typeof arguments_ === 'string' ? arguments_ : stableJson(arguments_);
+    const summary = result.files
+        .map((file) => `${file.operation} ${file.path}${file.targetPath ? ` -> ${file.targetPath}` : ''} (+${file.addedLines}/-${file.deletedLines})`)
+        .join('; ');
+    return `<context_gc kind="successful_apply_patch_input" originalBytes="${Buffer.byteLength(original)}" originalSha256="${sha256(original)}" evidenceSequence="${evidenceSequence}">Applied successfully: ${escapeXml(summary)}. Totals: ${result.totals.files} files, +${result.totals.addedLines}/-${result.totals.deletedLines}. The original patch body was reclaimed.</context_gc>`;
+}
+export function contextGcStaleReadReplacement(input) {
+    return `<context_gc kind="stale_read" path="${escapeXml(input.path)}" originalBytes="${Buffer.byteLength(input.content)}" originalSha256="${sha256(input.content)}" supersededByCallId="${escapeXml(input.supersededByCallId)}" operation="${input.operation}" evidenceSequence="${input.evidenceSequence}">This read predates a successful apply_patch. Re-read the path before relying on its contents.</context_gc>`;
+}
+export function contextGcExecInputReplacement(arguments_) {
+    if (!isRecord(arguments_))
+        return `<context_gc kind="terminal_exec_input" originalSha256="${sha256(stableJson(arguments_))}" />`;
+    const action = typeof arguments_.action === 'string' ? arguments_.action : 'unknown';
+    const original = stableJson(arguments_);
+    const retained = {
+        action,
+        contextGc: {
+            kind: 'terminal_exec_input',
+            originalBytes: Buffer.byteLength(original),
+            originalSha256: sha256(original)
+        }
+    };
+    for (const key of ['cwd', 'processId', 'timeoutMs', 'yieldMs'])
+        if (arguments_[key] !== undefined)
+            retained[key] = arguments_[key];
+    if (typeof arguments_.command === 'string')
+        retained.commandPrefix = [...arguments_.command].slice(0, 256).join('');
+    if (typeof arguments_.data === 'string')
+        retained.dataPrefix = [...arguments_.data].slice(0, 256).join('');
+    return retained;
+}
+export function contextGcExecOutputReplacement(result) {
+    if (result.source === 'MODEL_CONTEXT_TRUNCATED')
+        return JSON.stringify({
+            status: result.status,
+            ...(result.processId === undefined ? {} : { processId: result.processId }),
+            ...(result.exitCode === undefined ? {} : { exitCode: result.exitCode }),
+            truncated: result.truncated,
+            stdoutBytes: result.stdoutBytes,
+            stderrBytes: result.stderrBytes,
+            stdoutDroppedBytes: result.stdoutDroppedBytes,
+            stderrDroppedBytes: result.stderrDroppedBytes,
+            modelContextTruncated: true,
+            modelContextBytes: Buffer.byteLength(result.modelContextContent),
+            modelContextSha256: sha256(result.modelContextContent),
+            modelContextPreview: unicodeHeadTail(result.modelContextContent, RAW_MODEL_CONTEXT_PREVIEW_CHARACTERS),
+            contextGc: 'The model-visible terminal result was truncated after execution and is no longer valid JSON. Detailed terminal input/output was reclaimed after the process reached a stable terminal state. Re-run the command if full output is required.'
+        });
+    const stdout = result.stdout;
+    const stderr = result.stderr;
+    return JSON.stringify({
+        status: result.status,
+        ...(result.processId === undefined ? {} : { processId: result.processId }),
+        ...(result.exitCode === undefined ? {} : { exitCode: result.exitCode }),
+        truncated: result.truncated === true,
+        stdoutBytes: nonnegativeNumber(result.stdoutBytes) ?? Buffer.byteLength(stdout),
+        stderrBytes: nonnegativeNumber(result.stderrBytes) ?? Buffer.byteLength(stderr),
+        stdoutDroppedBytes: nonnegativeNumber(result.stdoutDroppedBytes) ?? 0,
+        stderrDroppedBytes: nonnegativeNumber(result.stderrDroppedBytes) ?? 0,
+        stdoutSha256: sha256(stdout),
+        stderrSha256: sha256(stderr),
+        stdoutPreview: unicodeHeadTail(stdout, 512),
+        stderrPreview: unicodeHeadTail(stderr, 512),
+        contextGc: 'Detailed terminal input/output was reclaimed after the process reached a stable terminal state. Re-run the command if full output is required.'
+    });
+}
+export function normalizeContextGcExecResult(modelContent, completedPayload) {
+    const parsed = parseContextGcExecResult(modelContent);
+    if (parsed)
+        return parsed;
+    if (typeof modelContent !== 'string' ||
+        !isRecord(completedPayload) ||
+        completedPayload.type !== 'tool.completed' ||
+        completedPayload.toolName !== 'exec' ||
+        completedPayload.truncated !== true)
+        return undefined;
+    const data = completedPayload.data;
+    if (!isRecord(data) || (data.status !== 'completed' && data.status !== 'cancelled'))
+        return undefined;
+    const metadata = parseContextGcExecMetadata(data);
+    return metadata
+        ? {
+            source: 'MODEL_CONTEXT_TRUNCATED',
+            ...metadata,
+            status: data.status,
+            modelContextContent: modelContent
+        }
+        : undefined;
+}
+export function parseContextGcExecResult(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    try {
+        const parsed = JSON.parse(value);
+        if (!isRecord(parsed) ||
+            (parsed.status !== 'running' &&
+                parsed.status !== 'completed' &&
+                parsed.status !== 'cancelled') ||
+            typeof parsed.stdout !== 'string' ||
+            typeof parsed.stderr !== 'string')
+            return undefined;
+        const metadata = parseContextGcExecMetadata(parsed);
+        return metadata
+            ? {
+                source: 'STRUCTURED',
+                ...metadata,
+                status: parsed.status,
+                stdout: parsed.stdout,
+                stderr: parsed.stderr
+            }
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseContextGcExecMetadata(value) {
+    if (typeof value.truncated !== 'boolean' ||
+        (value.processId !== undefined &&
+            (typeof value.processId !== 'string' || value.processId.length === 0)) ||
+        (value.exitCode !== undefined &&
+            value.exitCode !== null &&
+            (typeof value.exitCode !== 'number' || !Number.isSafeInteger(value.exitCode))) ||
+        !isNonnegativeInteger(value.stdoutBytes) ||
+        !isNonnegativeInteger(value.stderrBytes) ||
+        !isNonnegativeInteger(value.stdoutDroppedBytes) ||
+        !isNonnegativeInteger(value.stderrDroppedBytes) ||
+        value.stdoutDroppedBytes > value.stdoutBytes ||
+        value.stderrDroppedBytes > value.stderrBytes)
+        return undefined;
+    return {
+        ...(typeof value.processId === 'string' ? { processId: value.processId } : {}),
+        ...(value.exitCode === undefined ? {} : { exitCode: value.exitCode }),
+        truncated: value.truncated,
+        stdoutBytes: value.stdoutBytes,
+        stderrBytes: value.stderrBytes,
+        stdoutDroppedBytes: value.stdoutDroppedBytes,
+        stderrDroppedBytes: value.stderrDroppedBytes
+    };
+}
+function unicodeHeadTail(value, count) {
+    const characters = [...value];
+    if (characters.length <= count * 2)
+        return value;
+    return `${characters.slice(0, count).join('')}\n...[context GC omitted middle]...\n${characters
+        .slice(-count)
+        .join('')}`;
+}
+function nonnegativeNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+function sha256(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function escapeXml(value) {
+    return value
+        .replaceAll('&', '&amp;')
+        .replaceAll('"', '&quot;')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;');
+}
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(',')}]`;
+    if (value !== null && typeof value === 'object')
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`)
+            .join(',')}}`;
+    return JSON.stringify(value) ?? 'undefined';
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isNonemptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function isNonnegativeInteger(value) {
+    return Number.isSafeInteger(value) && Number(value) >= 0;
+}

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

@@ -0,0 +1,43 @@
+export type ContextGcSubagentToolName = 'agent_start' | 'agent_wait' | 'agent_message' | 'agent_cancel';
+export interface ContextGcSubagentSnapshot {
+    readonly agentId: string;
+    readonly description: string;
+    readonly status: 'queued' | 'running' | 'completed' | 'failed' | 'cancelled' | 'interrupted';
+    readonly modelId?: string;
+    readonly modelName?: string;
+    readonly reasoningEffort?: string;
+    readonly latestMessage?: {
+        readonly itemId: string;
+        readonly turnId: string;
+        readonly phase: 'commentary' | 'final_answer';
+        readonly text: string;
+        readonly timestamp: string;
+        readonly truncated?: boolean;
+    };
+    readonly summary?: string;
+    readonly changedFiles?: readonly string[];
+    readonly verification?: readonly string[];
+    readonly evidence?: readonly {
+        readonly path: string;
+        readonly startLine?: number;
+        readonly endLine?: number;
+    }[];
+    readonly errorCode?: string;
+    readonly errorMessage?: string;
+    readonly messageId?: string;
+    readonly turnId?: string;
+    readonly deliveryStatus?: 'accepted' | 'applied' | 'cancelled' | 'failed';
+}
+export declare function normalizeContextGcSubagentSnapshot(modelContent: unknown, completedPayload: unknown, toolName: ContextGcSubagentToolName): ContextGcSubagentSnapshot | undefined;
+export declare function contextGcCompletedSubagentTurnId(snapshot: ContextGcSubagentSnapshot): string | undefined;
+export declare function contextGcSubagentSnapshotTurnId(snapshot: ContextGcSubagentSnapshot): string | undefined;
+export declare function contextGcSubagentNeedsRetainedPriorFinal(snapshot: ContextGcSubagentSnapshot): boolean;
+export declare function contextGcSubagentPriorFinalIsRetained(source: ContextGcSubagentSnapshot, retained: ContextGcSubagentSnapshot | undefined): boolean;
+export declare function contextGcSubagentSnapshotIsSuperseded(source: ContextGcSubagentSnapshot, terminal: ContextGcSubagentSnapshot, retainedPriorFinal?: ContextGcSubagentSnapshot): boolean;
+export declare function contextGcSubagentOutputReplacement(input: {
+    readonly sourceContent: string;
+    readonly source: ContextGcSubagentSnapshot;
+    readonly terminal: ContextGcSubagentSnapshot;
+    readonly terminalCallId: string;
+    readonly evidenceSequence: number;
+}): string;

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

@@ -0,0 +1,267 @@
+import { createHash } from 'node:crypto';
+export function normalizeContextGcSubagentSnapshot(modelContent, completedPayload, toolName) {
+    if (typeof modelContent !== 'string' ||
+        !isRecord(completedPayload) ||
+        completedPayload.type !== 'tool.completed' ||
+        completedPayload.toolName !== toolName ||
+        completedPayload.truncated === true)
+        return undefined;
+    const fromContent = parseContextGcSubagentSnapshot(modelContent);
+    const fromData = parseContextGcSubagentSnapshot(completedPayload.data);
+    return fromContent && fromData && stableJson(fromContent) === stableJson(fromData)
+        ? fromContent
+        : undefined;
+}
+export function contextGcCompletedSubagentTurnId(snapshot) {
+    if (snapshot.status !== 'completed' ||
+        !isNonemptyString(snapshot.summary) ||
+        snapshot.latestMessage?.phase !== 'final_answer' ||
+        (snapshot.deliveryStatus !== undefined && snapshot.deliveryStatus !== 'applied'))
+        return undefined;
+    const turnId = snapshot.latestMessage.turnId;
+    return snapshot.turnId === undefined || snapshot.turnId === turnId ? turnId : undefined;
+}
+export function contextGcSubagentSnapshotTurnId(snapshot) {
+    return snapshot.turnId ?? snapshot.latestMessage?.turnId;
+}
+export function contextGcSubagentNeedsRetainedPriorFinal(snapshot) {
+    return (snapshot.latestMessage?.phase === 'final_answer' &&
+        snapshot.latestMessage.turnId !== contextGcSubagentSnapshotTurnId(snapshot));
+}
+export function contextGcSubagentPriorFinalIsRetained(source, retained) {
+    if (!contextGcSubagentNeedsRetainedPriorFinal(source))
+        return true;
+    return (retained !== undefined &&
+        retained.agentId === source.agentId &&
+        retained.description === source.description &&
+        contextGcCompletedSubagentTurnId(retained) === source.latestMessage.turnId &&
+        stableJson(retained.latestMessage) === stableJson(source.latestMessage));
+}
+export function contextGcSubagentSnapshotIsSuperseded(source, terminal, retainedPriorFinal) {
+    const terminalTurnId = contextGcCompletedSubagentTurnId(terminal);
+    if (!terminalTurnId ||
+        source.agentId !== terminal.agentId ||
+        contextGcSubagentSnapshotTurnId(source) !== terminalTurnId ||
+        source.description !== terminal.description ||
+        !optionalStringMatches(source.modelId, terminal.modelId) ||
+        !optionalStringMatches(source.modelName, terminal.modelName) ||
+        !optionalStringMatches(source.reasoningEffort, terminal.reasoningEffort))
+        return false;
+    if (source.status === 'completed')
+        return stableJson(source) === stableJson(terminal);
+    if ((source.status !== 'queued' && source.status !== 'running') ||
+        source.errorCode !== undefined ||
+        source.errorMessage !== undefined ||
+        !optionalStringMatches(source.summary, terminal.summary) ||
+        !contextGcSubagentPriorFinalIsRetained(source, retainedPriorFinal) ||
+        (source.latestMessage?.phase === 'final_answer' &&
+            source.latestMessage.turnId === contextGcSubagentSnapshotTurnId(source)))
+        return false;
+    if (source.messageId !== undefined &&
+        ((source.deliveryStatus !== 'accepted' && source.deliveryStatus !== 'applied') ||
+            terminal.messageId !== source.messageId ||
+            terminal.turnId !== source.turnId ||
+            terminal.deliveryStatus !== 'applied'))
+        return false;
+    return (stringArrayIsCovered(source.changedFiles, terminal.changedFiles) &&
+        stringArrayIsCovered(source.verification, terminal.verification) &&
+        evidenceIsCovered(source.evidence, terminal.evidence));
+}
+export function contextGcSubagentOutputReplacement(input) {
+    const latestMessage = input.source.latestMessage;
+    return JSON.stringify({
+        agentId: input.source.agentId,
+        description: input.source.description,
+        status: input.source.status,
+        ...(input.source.modelId === undefined ? {} : { modelId: input.source.modelId }),
+        ...(input.source.modelName === undefined ? {} : { modelName: input.source.modelName }),
+        ...(input.source.reasoningEffort === undefined
+            ? {}
+            : { reasoningEffort: input.source.reasoningEffort }),
+        ...(input.source.messageId === undefined ? {} : { messageId: input.source.messageId }),
+        ...(input.source.turnId === undefined ? {} : { turnId: input.source.turnId }),
+        ...(input.source.deliveryStatus === undefined
+            ? {}
+            : { deliveryStatus: input.source.deliveryStatus }),
+        ...(latestMessage === undefined
+            ? {}
+            : {
+                latestMessage: {
+                    itemId: latestMessage.itemId,
+                    turnId: latestMessage.turnId,
+                    phase: latestMessage.phase,
+                    timestamp: latestMessage.timestamp,
+                    ...(latestMessage.truncated === undefined
+                        ? {}
+                        : { truncated: latestMessage.truncated }),
+                    textBytes: Buffer.byteLength(latestMessage.text),
+                    textSha256: sha256(latestMessage.text)
+                }
+            }),
+        contextGc: {
+            kind: 'superseded_subagent_snapshot',
+            originalBytes: Buffer.byteLength(input.sourceContent),
+            originalSha256: sha256(input.sourceContent),
+            terminalStatus: input.terminal.status,
+            terminalTurnId: contextGcCompletedSubagentTurnId(input.terminal),
+            terminalCallId: input.terminalCallId,
+            evidenceSequence: input.evidenceSequence,
+            note: 'This intermediate child-agent snapshot was superseded by retained completed evidence; complete Turn results remain in retained completed snapshots.'
+        }
+    });
+}
+function parseContextGcSubagentSnapshot(value) {
+    let parsed = value;
+    if (typeof value === 'string')
+        try {
+            parsed = JSON.parse(value);
+        }
+        catch {
+            return undefined;
+        }
+    if (!isRecord(parsed) ||
+        Object.keys(parsed).some((key) => ![
+            'agentId',
+            'description',
+            'status',
+            'modelId',
+            'modelName',
+            'reasoningEffort',
+            'latestMessage',
+            'summary',
+            'changedFiles',
+            'verification',
+            'evidence',
+            'errorCode',
+            'errorMessage',
+            'messageId',
+            'turnId',
+            'deliveryStatus'
+        ].includes(key)) ||
+        !isNonemptyString(parsed.agentId) ||
+        !isNonemptyString(parsed.description) ||
+        (parsed.status !== 'queued' &&
+            parsed.status !== 'running' &&
+            parsed.status !== 'completed' &&
+            parsed.status !== 'failed' &&
+            parsed.status !== 'cancelled' &&
+            parsed.status !== 'interrupted') ||
+        !isOptionalNonemptyString(parsed.modelId) ||
+        !isOptionalNonemptyString(parsed.modelName) ||
+        !isOptionalNonemptyString(parsed.reasoningEffort) ||
+        !isOptionalString(parsed.summary) ||
+        !isOptionalString(parsed.errorCode) ||
+        !isOptionalString(parsed.errorMessage) ||
+        !isOptionalNonemptyString(parsed.messageId) ||
+        !isOptionalNonemptyString(parsed.turnId) ||
+        (parsed.deliveryStatus !== undefined &&
+            parsed.deliveryStatus !== 'accepted' &&
+            parsed.deliveryStatus !== 'applied' &&
+            parsed.deliveryStatus !== 'cancelled' &&
+            parsed.deliveryStatus !== 'failed') ||
+        !isOptionalStringArray(parsed.changedFiles) ||
+        !isOptionalStringArray(parsed.verification) ||
+        !isOptionalSubagentEvidence(parsed.evidence))
+        return undefined;
+    const receiptCount = [parsed.messageId, parsed.turnId, parsed.deliveryStatus].filter((item) => item !== undefined).length;
+    if (receiptCount !== 0 && receiptCount !== 3)
+        return undefined;
+    const latestMessage = parseContextGcSubagentLatestMessage(parsed.latestMessage);
+    if (parsed.latestMessage !== undefined && !latestMessage)
+        return undefined;
+    return {
+        agentId: parsed.agentId,
+        description: parsed.description,
+        status: parsed.status,
+        ...(typeof parsed.modelId === 'string' ? { modelId: parsed.modelId } : {}),
+        ...(typeof parsed.modelName === 'string' ? { modelName: parsed.modelName } : {}),
+        ...(typeof parsed.reasoningEffort === 'string'
+            ? { reasoningEffort: parsed.reasoningEffort }
+            : {}),
+        ...(latestMessage ? { latestMessage } : {}),
+        ...(typeof parsed.summary === 'string' ? { summary: parsed.summary } : {}),
+        ...(Array.isArray(parsed.changedFiles) ? { changedFiles: [...parsed.changedFiles] } : {}),
+        ...(Array.isArray(parsed.verification) ? { verification: [...parsed.verification] } : {}),
+        ...(Array.isArray(parsed.evidence)
+            ? { evidence: parsed.evidence.map((item) => ({ ...item })) }
+            : {}),
+        ...(typeof parsed.errorCode === 'string' ? { errorCode: parsed.errorCode } : {}),
+        ...(typeof parsed.errorMessage === 'string' ? { errorMessage: parsed.errorMessage } : {}),
+        ...(typeof parsed.messageId === 'string' ? { messageId: parsed.messageId } : {}),
+        ...(typeof parsed.turnId === 'string' ? { turnId: parsed.turnId } : {}),
+        ...(typeof parsed.deliveryStatus === 'string'
+            ? {
+                deliveryStatus: parsed.deliveryStatus
+            }
+            : {})
+    };
+}
+function parseContextGcSubagentLatestMessage(value) {
+    if (!isRecord(value) ||
+        Object.keys(value).some((key) => !['itemId', 'turnId', 'phase', 'text', 'timestamp', 'truncated'].includes(key)) ||
+        !isNonemptyString(value.itemId) ||
+        !isNonemptyString(value.turnId) ||
+        (value.phase !== 'commentary' && value.phase !== 'final_answer') ||
+        typeof value.text !== 'string' ||
+        !isNonemptyString(value.timestamp) ||
+        (value.truncated !== undefined && typeof value.truncated !== 'boolean'))
+        return undefined;
+    return {
+        itemId: value.itemId,
+        turnId: value.turnId,
+        phase: value.phase,
+        text: value.text,
+        timestamp: value.timestamp,
+        ...(typeof value.truncated === 'boolean' ? { truncated: value.truncated } : {})
+    };
+}
+function isOptionalSubagentEvidence(value) {
+    return (value === undefined ||
+        (Array.isArray(value) &&
+            value.every((item) => isRecord(item) &&
+                Object.keys(item).every((key) => ['path', 'startLine', 'endLine'].includes(key)) &&
+                isNonemptyString(item.path) &&
+                (item.startLine === undefined || isPositiveInteger(item.startLine)) &&
+                (item.endLine === undefined || isPositiveInteger(item.endLine)))));
+}
+function isOptionalStringArray(value) {
+    return (value === undefined || (Array.isArray(value) && value.every((item) => typeof item === 'string')));
+}
+function isOptionalString(value) {
+    return value === undefined || typeof value === 'string';
+}
+function isOptionalNonemptyString(value) {
+    return value === undefined || isNonemptyString(value);
+}
+function optionalStringMatches(source, terminal) {
+    return source === undefined || source === terminal;
+}
+function stringArrayIsCovered(source, terminal) {
+    return source === undefined || source.every((item) => terminal?.includes(item) === true);
+}
+function evidenceIsCovered(source, terminal) {
+    return (source === undefined ||
+        source.every((item) => terminal?.some((candidate) => stableJson(candidate) === stableJson(item))));
+}
+function sha256(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(',')}]`;
+    if (value !== null && typeof value === 'object')
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`)
+            .join(',')}}`;
+    return JSON.stringify(value) ?? 'undefined';
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isNonemptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function isPositiveInteger(value) {
+    return Number.isSafeInteger(value) && Number(value) > 0;
+}