@myagentroam/agent 0.11.32 → 0.11.34

package/dist/prompts/read-context.js

@@ -0,0 +1,152 @@
+import { decodeMarkupText, markupAttributes, markupText, parseMarkupAttributes } from './markup.js';
+export function formatReadContextItem(index, metadata, content) {
+    const { oversizedLine, ...values } = metadata;
+    const header = `<mar_read_result${markupAttributes({ index, path: metadata.path, pathTruncated: metadata.pathTruncated })}>`;
+    const info = oversizedLine && typeof oversizedLine === 'object'
+        ? `<metadata${markupAttributes(values)}>\n    <oversized_line${markupAttributes(oversizedLine)} />\n  </metadata>`
+        : `<metadata${markupAttributes(values)} />`;
+    return [header, '  ' + markupText('content', content), '  ' + info, '</mar_read_result>'].join('\n');
+}
+function metadataValues(values) {
+    const result = {};
+    for (const [key, value] of Object.entries(values)) {
+        if (key === 'path')
+            result[key] = value;
+        else if (key === 'encoding' && ['utf-8', 'utf-16le', 'utf-16be'].includes(value))
+            result[key] = value;
+        else if (key === 'newline' && ['lf', 'crlf'].includes(value))
+            result[key] = value;
+        else if (['pathTruncated', 'eof', 'truncated', 'previewComplete'].includes(key)) {
+            if (value !== 'true' && value !== 'false')
+                throw new Error('MAR_AGENT_MARKUP_INVALID');
+            result[key] = value === 'true';
+        }
+        else if (['startLine', 'endLine', 'nextOffset'].includes(key)) {
+            if (!/^[0-9]+$/u.test(value) || !Number.isSafeInteger(Number(value)) || Number(value) < 1)
+                throw new Error('MAR_AGENT_MARKUP_INVALID');
+            result[key] = Number(value);
+        }
+        else
+            throw new Error('MAR_AGENT_MARKUP_INVALID');
+    }
+    return result;
+}
+export function parseReadContextOutput(value) {
+    try {
+        if (!value.startsWith('<mar_read_'))
+            return undefined;
+        const items = [];
+        const indexes = new Set();
+        let offset = 0;
+        while (offset < value.length) {
+            const header = /^<mar_read_(result|error)([^<>]*)>/.exec(value.slice(offset));
+            if (!header)
+                return undefined;
+            const attrs = parseMarkupAttributes(header[2]);
+            const index = Number(attrs.index);
+            if (!/^[0-9]+$/u.test(attrs.index ?? '') || !Number.isSafeInteger(index))
+                return undefined;
+            if (indexes.has(index))
+                return undefined;
+            indexes.add(index);
+            if (header[1] === 'error') {
+                if (!attrs.code ||
+                    Object.keys(attrs).some((key) => !['index', 'path', 'pathTruncated', 'code', 'detailsTruncated'].includes(key)))
+                    return undefined;
+                if (['pathTruncated', 'detailsTruncated'].some((key) => attrs[key] !== undefined && attrs[key] !== 'true' && attrs[key] !== 'false'))
+                    return undefined;
+                const end = value.indexOf('</mar_read_error>', offset + header[0].length);
+                if (end < 0)
+                    return undefined;
+                const body = value.slice(offset + header[0].length, end).trim();
+                if (body !== '<message />') {
+                    if (!body.startsWith('<message>') || !body.endsWith('</message>'))
+                        return undefined;
+                    decodeMarkupText(body.slice(9, -10));
+                }
+                offset = end + '</mar_read_error>'.length;
+            }
+            else {
+                if (!attrs.path ||
+                    Object.keys(attrs).some((key) => !['index', 'path', 'pathTruncated'].includes(key)) ||
+                    (attrs.pathTruncated !== undefined &&
+                        attrs.pathTruncated !== 'true' &&
+                        attrs.pathTruncated !== 'false'))
+                    return undefined;
+                const contentStart = offset + header[0].length + 3;
+                if (value.slice(contentStart - 3, contentStart) !== '\n  ')
+                    return undefined;
+                const contentEnd = value.indexOf('\n  ' + '<metadata', contentStart);
+                if (contentEnd < 0)
+                    return undefined;
+                const body = value.slice(contentStart, contentEnd);
+                let content;
+                if (body === '<content />')
+                    content = '';
+                else if (body.startsWith('<content>') && body.endsWith('</content>'))
+                    content = decodeMarkupText(body.slice(9, -10));
+                else {
+                    const reclaimed = /^<mar_context_gc([^<>]*)>\s*<instruction>([^<]*)<\/instruction>\s*<\/mar_context_gc>$/u.exec(body);
+                    if (!reclaimed || parseMarkupAttributes(reclaimed[1]).kind !== 'stale_read')
+                        return undefined;
+                    decodeMarkupText(reclaimed[2]);
+                    content = body;
+                }
+                const end = value.indexOf('\n' + '</mar_read_result>', contentEnd);
+                if (end < 0)
+                    return undefined;
+                const info = value.slice(contentEnd + 3, end);
+                const meta = /^<metadata([^<>]*?)(?: \/>|>\s*<oversized_line([^<>]*) \/>\s*<\/metadata>)$/u.exec(info);
+                if (!meta)
+                    return undefined;
+                const metadata = metadataValues(parseMarkupAttributes(meta[1]));
+                if (metadata.path !== attrs.path ||
+                    (metadata.pathTruncated === true) !== (attrs.pathTruncated === 'true'))
+                    return undefined;
+                if (meta[2] !== undefined) {
+                    const oversized = parseMarkupAttributes(meta[2]);
+                    if (Object.keys(oversized).length !== 4 ||
+                        Object.keys(oversized).some((key) => !['line', 'bytes', 'shownBytes', 'omittedBytes'].includes(key)) ||
+                        Object.values(oversized).some((number) => !/^[0-9]+$/u.test(number) || !Number.isSafeInteger(Number(number))))
+                        return undefined;
+                    metadata.oversizedLine = Object.fromEntries(Object.entries(oversized).map(([key, number]) => [key, Number(number)]));
+                }
+                items.push({
+                    index,
+                    path: attrs.path,
+                    pathTruncated: attrs.pathTruncated === 'true',
+                    content,
+                    metadata,
+                    contentStart,
+                    contentEnd
+                });
+                offset = end + 1 + '</mar_read_result>'.length;
+            }
+            if (offset < value.length) {
+                if (value[offset] !== '\n')
+                    return undefined;
+                offset++;
+            }
+        }
+        return { items };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function replaceReadContextItems(value, replacements) {
+    const parsed = parseReadContextOutput(value);
+    if (!parsed)
+        return value;
+    const byIndex = new Map(replacements.map((replacement) => [replacement.index, replacement]));
+    const selected = parsed.items
+        .flatMap((item) => {
+        const replacement = byIndex.get(item.index);
+        return replacement ? [{ item, replacement: replacement.replacement }] : [];
+    })
+        .sort((left, right) => right.item.contentStart - left.item.contentStart);
+    let result = value;
+    for (const { item, replacement } of selected)
+        result = `${result.slice(0, item.contentStart)}${replacement}${result.slice(item.contentEnd)}`;
+    return result;
+}

package/dist/runtime/compaction/contracts.d.ts

@@ -0,0 +1,23 @@
+import type { ModelUsage } from '../../model/contracts.js';
+export interface ExtensionCompactDiagnostic {
+    readonly modelId: string;
+    readonly providerModelId?: string;
+    readonly reasoningEffort: string;
+    readonly state: 'STARTED' | 'SUCCEEDED' | 'DECLINED' | 'FAILED';
+    readonly inputTokensEstimateBefore: number;
+    readonly inputTokensEstimateAfter: number;
+    readonly modelRequests: number;
+    readonly elapsedMs: number;
+    readonly reason?: 'INPUT_BUDGET_EXHAUSTED' | 'MODEL_INCOMPLETE' | 'MODEL_FAILED';
+    readonly errorCode?: string;
+    readonly trigger?: 'manual' | 'automatic';
+    readonly causeCode?: string;
+    readonly errorReason?: string;
+    readonly httpStatus?: number;
+    readonly retryable?: boolean;
+    readonly transport?: 'HTTP' | 'WEBSOCKET';
+}
+export interface ExtensionCompactResult {
+    readonly summary: string;
+    readonly usage?: Readonly<ModelUsage>;
+}

package/dist/runtime/compaction/coordinator.js

@@ -0,0 +1,88 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { AgentError } from '../../error.js';
+/** One generation and adoption lane, with installation released only by a safe checkpoint. */
+export class CompactCoordinator {
+    #owner = new AsyncLocalStorage();
+    #flight;
+    get pending() {
+        return this.#flight !== undefined;
+    }
+    get waiting() {
+        return this.#flight?.waiting === true;
+    }
+    assertNotReentrant() {
+        if (this.#owner.getStore())
+            throw new AgentError('MAR_AGENT_COMPACT_REENTRANT', 'Recursive compaction is not allowed.');
+    }
+    start(id, focus, run) {
+        this.assertNotReentrant();
+        if (this.#flight) {
+            if (focus !== undefined && focus !== this.#flight.focus)
+                throw new AgentError('MAR_AGENT_COMPACT_CONFLICT', 'A different compaction is already active.');
+            return this.#flight;
+        }
+        let ready;
+        let release;
+        const gate = new Promise((resolve) => {
+            release = resolve;
+        });
+        const controller = new AbortController();
+        const flight = {
+            id,
+            focus,
+            controller,
+            prepared: false,
+            settled: false,
+            waiting: false,
+            release,
+            ready: new Promise((resolve) => {
+                ready = resolve;
+            }),
+            result: undefined
+        };
+        this.#flight = flight;
+        const abort = () => release();
+        controller.signal.addEventListener('abort', abort, { once: true });
+        flight.result = this.#owner.run(id, async () => {
+            try {
+                return await run(async () => {
+                    controller.signal.throwIfAborted();
+                    flight.prepared = true;
+                    ready();
+                    await gate;
+                    controller.signal.throwIfAborted();
+                }, controller.signal);
+            }
+            finally {
+                flight.settled = true;
+                ready();
+                controller.signal.removeEventListener('abort', abort);
+            }
+        });
+        // The result remains observable at the next checkpoint, including asynchronous failures.
+        void flight.result.catch(() => undefined);
+        return flight;
+    }
+    async checkpoint(wait) {
+        const flight = this.#flight;
+        if (!flight || (!wait && !flight.prepared && !flight.settled))
+            return undefined;
+        flight.waiting ||= wait;
+        try {
+            await flight.ready;
+            flight.release();
+            return await flight.result;
+        }
+        finally {
+            if (this.#flight === flight)
+                this.#flight = undefined;
+        }
+    }
+    async close(reason) {
+        const flight = this.#flight;
+        if (!flight)
+            return;
+        flight.controller.abort(reason);
+        await this.checkpoint(true).catch(() => undefined);
+    }
+}

package/dist/runtime/compaction/generate.d.ts

@@ -0,0 +1,31 @@
+import type { ClientToolDefinition } from '../../tools/contracts.js';
+import type { SessionModelMessage as ModelMessage } from '../../session/model-request.js';
+import type { SessionModelRequest as ModelRequest } from '../../session/model-request.js';
+import type { ExtensionCompactResult } from './contracts.js';
+import type { ModelEvent, ModelTurnSession, ModelUsage } from '../../model/contracts.js';
+import { type AuthoritativeModelUsage } from '../context/usage.js';
+import type { CompactionOperation } from './operation.js';
+interface CompactionSnapshot {
+    readonly history: readonly ModelMessage[];
+    readonly system: string;
+    readonly systemBlocks?: ModelRequest['systemBlocks'];
+    readonly tools: readonly ClientToolDefinition[];
+    readonly contextWindowTokens: number;
+    readonly latestUsage: AuthoritativeModelUsage | undefined;
+    readonly reasoningEffort: NonNullable<ModelRequest['reasoningEffort']>;
+    readonly focus?: string;
+    readonly reason: 'manual' | 'automatic';
+    readonly promptCacheKey: string;
+}
+interface CompactionGeneration {
+    readonly operation: CompactionOperation;
+    readonly turn: ModelTurnSession;
+    readonly generateExtension: (history: readonly ModelMessage[], reason: 'manual' | 'automatic', focus: string | undefined, operation: CompactionOperation) => Promise<ExtensionCompactResult | undefined>;
+    readonly transformRequest: (request: ModelRequest) => Promise<ModelRequest>;
+    readonly stream: (start: (signal: AbortSignal) => AsyncIterable<ModelEvent>, signal: AbortSignal) => AsyncIterable<ModelEvent>;
+    readonly observeUsage: (usage: ModelUsage) => Promise<void>;
+    readonly onAttemptDiagnostic: NonNullable<ModelRequest['onAttemptDiagnostic']>;
+}
+/** Generate a candidate from an isolated snapshot; never commit or adopt active context. */
+export declare function generateCompactionCandidate(snapshot: CompactionSnapshot, dependencies: CompactionGeneration): Promise<ExtensionCompactResult>;
+export {};

package/dist/runtime/compaction/generate.js

@@ -0,0 +1,84 @@
+import { AgentError } from '../../error.js';
+import { isProviderContextOverflow, recoverModelStream } from '../../model/recovery.js';
+import { normalizeMessagesForModel } from '../context/normalize.js';
+import { estimatedRequestTokens } from '../context/request-budget.js';
+import { shouldUseNativeCompaction } from '../context/usage.js';
+import { buildCompactionInput, buildCompactionMessages, buildNativeCompactionMessages } from './history.js';
+import { projectSmartCompactionMessage } from './smart.js';
+/** Generate a candidate from an isolated snapshot; never commit or adopt active context. */
+export async function generateCompactionCandidate(snapshot, dependencies) {
+    const { operation, turn } = dependencies;
+    const projectedHistory = normalizeMessagesForModel(snapshot.history, {
+        supportsImages: false
+    }).map(projectSmartCompactionMessage);
+    const nativeMessages = buildNativeCompactionMessages(projectedHistory, {
+        ...(snapshot.focus === undefined ? {} : { focus: snapshot.focus })
+    });
+    const overhead = estimatedRequestTokens(snapshot.system, buildCompactionMessages(''), snapshot.tools);
+    const inputTokens = Math.max(0, snapshot.contextWindowTokens - overhead);
+    let usingNativeMessages = shouldUseNativeCompaction({
+        estimatedRequestTokens: estimatedRequestTokens(snapshot.system, nativeMessages, snapshot.tools),
+        contextWindowTokens: snapshot.contextWindowTokens,
+        latestUsage: snapshot.latestUsage,
+        historyMessages: snapshot.history,
+        appendedMessages: nativeMessages.slice(projectedHistory.length)
+    });
+    const fallbackMessages = () => buildCompactionMessages(buildCompactionInput(snapshot.history, {
+        ...(snapshot.focus === undefined ? {} : { focus: snapshot.focus }),
+        maxTokens: Math.max(1, inputTokens)
+    }));
+    let messages = usingNativeMessages ? nativeMessages : fallbackMessages();
+    const retryState = { attempts: 0 };
+    const extension = await dependencies.generateExtension(snapshot.history, snapshot.reason, snapshot.focus, operation);
+    operation.signal.throwIfAborted();
+    if (extension) {
+        if (extension.usage)
+            await dependencies.observeUsage(extension.usage);
+        return extension;
+    }
+    while (true) {
+        if (inputTokens === 0)
+            throw new AgentError('MAR_AGENT_CONTEXT_LIMIT', 'Compaction prompt exceeds the selected model context window.');
+        let summary = '';
+        let usage;
+        try {
+            const request = await dependencies.transformRequest({
+                retryState,
+                system: snapshot.system,
+                ...(snapshot.systemBlocks === undefined ? {} : { systemBlocks: snapshot.systemBlocks }),
+                messages,
+                tools: snapshot.tools,
+                toolChoice: 'none',
+                promptCacheKey: snapshot.promptCacheKey,
+                reasoningEffort: snapshot.reasoningEffort,
+                onAttemptDiagnostic: dependencies.onAttemptDiagnostic
+            });
+            for await (const event of dependencies.stream((signal) => operation.start({ start: (request) => turn.start(request, signal) }, request), operation.signal)) {
+                if (event.type === 'text.completed' && (event.phase ?? 'final_answer') === 'final_answer')
+                    summary = event.text.trim();
+                else if (event.type === 'usage') {
+                    usage = event.usage;
+                    await dependencies.observeUsage(event.usage);
+                }
+                else if (event.type === 'client_tool.call')
+                    throw new AgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Compaction returned a tool call while tools were disabled.');
+            }
+        }
+        catch (error) {
+            if (await recoverModelStream(error, retryState, operation.signal))
+                continue;
+            if (isProviderContextOverflow(error) && usingNativeMessages) {
+                usingNativeMessages = false;
+                messages = fallbackMessages();
+                retryState.attempts = 0;
+                continue;
+            }
+            if (isProviderContextOverflow(error))
+                throw new AgentError('MAR_AGENT_CONTEXT_LIMIT', 'The compaction request exceeds the model context window.', { cause: error });
+            throw error;
+        }
+        if (!summary)
+            throw new AgentError('MAR_AGENT_COMPACT_FAILED', 'Automatic compact failed.');
+        return { summary, ...(usage === undefined ? {} : { usage }) };
+    }
+}

package/dist/runtime/compaction/history.d.ts

@@ -0,0 +1,16 @@
+import type { SessionModelMessage as ModelMessage } from '../../session/model-request.js';
+import type { CompactHistoryMessage, CompactUserInput } from '../../session/record-contract.js';
+export declare const DEFAULT_COMPACTION_FOCUS = "Create a durable continuation state for the next model invocation.";
+export declare function buildNativeCompactionMessages(messages: readonly ModelMessage[], input?: {
+    focus?: string;
+}): ModelMessage[];
+export declare function buildCompactionMessages(evidence: string): ModelMessage[];
+export declare function buildCompactionInput(messages: readonly ModelMessage[], input: {
+    focus?: string;
+    maxTokens: number;
+}): string;
+export declare function retainCompactionUserMessages(messages: readonly string[], maxTokens: number): string[];
+export declare function retainCompactionUserMessages(messages: readonly CompactUserInput[], maxTokens: number): CompactUserInput[];
+export declare function buildCompactedHistory(summary: string, userMessages: readonly (string | CompactUserInput)[], maxUserTokens: number, currentUserMessage?: string | CompactUserInput): CompactHistoryMessage[];
+export declare function compactedHistoryMessages(history: readonly CompactHistoryMessage[]): ModelMessage[];
+export declare function continuationMessage(summary: string): string;

package/dist/runtime/compaction/operation.d.ts

@@ -0,0 +1,30 @@
+import type { SessionModelRequest as ModelRequest } from '../../session/model-request.js';
+import type { ModelEvent, ModelTurnSession } from '../../model/contracts.js';
+import type { ExtensionCompactDiagnostic } from './contracts.js';
+export interface CompactionProgress {
+    state: 'STARTED' | 'PROGRESS' | 'FINISHED';
+    elapsedMs: number;
+    inputTokensEstimate: number;
+    modelRequests: number;
+    eventCounts: Partial<Record<ModelEvent['type'], number>>;
+    textDeltaCharacters: number;
+    firstOutputAfterMs?: number;
+    lastOutputAfterMs?: number;
+    timedOut: boolean;
+    extension?: ExtensionCompactDiagnostic;
+    extensionOutcome?: 'HANDLED' | 'DECLINED' | 'INVALID_RESULT' | 'FAILED';
+}
+/** One deadline spans all model attempts and recovery waits for a single compaction. */
+export declare class CompactionOperation {
+    #private;
+    private readonly record;
+    readonly signal: AbortSignal;
+    constructor(parent: AbortSignal, record: (progress: CompactionProgress) => void | Promise<void>);
+    start(model: Pick<ModelTurnSession, 'start'>, request: ModelRequest): AsyncIterable<ModelEvent>;
+    /** External generation shares this operation's deadline, including the default fallback. */
+    generate<T>(run: (signal: AbortSignal) => Promise<T>): Promise<T>;
+    observeExtension(diagnostic: ExtensionCompactDiagnostic): Promise<void>;
+    finishExtension(outcome: NonNullable<CompactionProgress['extensionOutcome']>): Promise<void>;
+    dispose(): Promise<void>;
+    private report;
+}

package/dist/runtime/compaction/operation.js

@@ -0,0 +1,131 @@
+import { AgentError } from '../../error.js';
+import { countModelTokens } from '../token-budget.js';
+const COMPACTION_TIMEOUT_MS = 600_000;
+const COMPACTION_PROGRESS_INTERVAL_MS = 30_000;
+/** One deadline spans all model attempts and recovery waits for a single compaction. */
+export class CompactionOperation {
+    record;
+    #controller = new AbortController();
+    signal;
+    #startedAt = Date.now();
+    #deadline;
+    #progressTimer;
+    #closed = false;
+    #tail = Promise.resolve();
+    #inputTokensEstimate = 0;
+    #modelRequests = 0;
+    #eventCounts = {};
+    #textDeltaCharacters = 0;
+    #firstOutputAfterMs;
+    #lastOutputAfterMs;
+    #extension;
+    #extensionOutcome;
+    constructor(parent, record) {
+        this.record = record;
+        this.signal = AbortSignal.any([parent, this.#controller.signal]);
+        this.#deadline = setTimeout(() => this.#controller.abort(new AgentError('MAR_AGENT_MODEL_TIMEOUT', 'Compaction exceeded its total time limit; the previous context was retained.', { details: { reason: 'COMPACTION_DEADLINE_EXCEEDED' } })), COMPACTION_TIMEOUT_MS);
+        this.#deadline.unref();
+        this.#progressTimer = setInterval(() => {
+            void this.report('PROGRESS');
+        }, COMPACTION_PROGRESS_INTERVAL_MS);
+        this.#progressTimer.unref();
+    }
+    async *start(model, request) {
+        this.signal.throwIfAborted();
+        this.#modelRequests++;
+        this.#inputTokensEstimate =
+            countModelTokens(request.system) +
+                request.messages.reduce((sum, message) => sum + countModelTokens(message.content), 0);
+        await this.report(this.#modelRequests === 1 ? 'STARTED' : 'PROGRESS');
+        let completed = false;
+        try {
+            for await (const event of model.start(request, this.signal)) {
+                this.signal.throwIfAborted();
+                this.#eventCounts[event.type] = (this.#eventCounts[event.type] ?? 0) + 1;
+                if (event.type === 'completed')
+                    completed = event.reason === 'completed';
+                if (event.type === 'text.delta')
+                    this.#textDeltaCharacters += event.delta.length;
+                if ((event.type === 'text.delta' && event.delta.length > 0) ||
+                    ((event.type === 'text.completed' || event.type === 'reasoning.completed') &&
+                        event.text.length > 0)) {
+                    this.#lastOutputAfterMs = Math.max(0, Date.now() - this.#startedAt);
+                    this.#firstOutputAfterMs ??= this.#lastOutputAfterMs;
+                }
+                yield event;
+            }
+            this.signal.throwIfAborted();
+            if (!completed)
+                throw new AgentError('MAR_AGENT_COMPACT_FAILED', 'Compaction did not return a complete response.');
+        }
+        catch (error) {
+            this.signal.throwIfAborted();
+            throw error;
+        }
+    }
+    /** External generation shares this operation's deadline, including the default fallback. */
+    async generate(run) {
+        this.signal.throwIfAborted();
+        let abort;
+        try {
+            return await Promise.race([
+                Promise.resolve().then(() => run(this.signal)),
+                new Promise((_resolve, reject) => {
+                    abort = () => reject(this.signal.reason);
+                    this.signal.addEventListener('abort', abort, { once: true });
+                    if (this.signal.aborted)
+                        abort();
+                })
+            ]);
+        }
+        finally {
+            if (abort)
+                this.signal.removeEventListener('abort', abort);
+        }
+    }
+    async observeExtension(diagnostic) {
+        if (this.#closed || this.signal.aborted)
+            return;
+        if (diagnostic.modelRequests < (this.#extension?.modelRequests ?? 0))
+            return;
+        this.#extension = { ...diagnostic };
+        await this.report('PROGRESS');
+    }
+    async finishExtension(outcome) {
+        if (this.#closed)
+            return;
+        this.#extensionOutcome = outcome;
+        await this.report('PROGRESS');
+    }
+    async dispose() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        clearTimeout(this.#deadline);
+        clearInterval(this.#progressTimer);
+        await this.report('FINISHED');
+    }
+    report(state) {
+        const progress = {
+            state,
+            elapsedMs: Math.max(0, Date.now() - this.#startedAt),
+            inputTokensEstimate: this.#modelRequests
+                ? this.#inputTokensEstimate
+                : (this.#extension?.inputTokensEstimateAfter ?? this.#inputTokensEstimate),
+            modelRequests: this.#modelRequests + (this.#extension?.modelRequests ?? 0),
+            ...(this.#extension ? { extension: { ...this.#extension } } : {}),
+            ...(this.#extensionOutcome ? { extensionOutcome: this.#extensionOutcome } : {}),
+            eventCounts: { ...this.#eventCounts },
+            textDeltaCharacters: this.#textDeltaCharacters,
+            ...(this.#firstOutputAfterMs === undefined
+                ? {}
+                : { firstOutputAfterMs: this.#firstOutputAfterMs }),
+            ...(this.#lastOutputAfterMs === undefined
+                ? {}
+                : { lastOutputAfterMs: this.#lastOutputAfterMs }),
+            timedOut: this.#controller.signal.aborted
+        };
+        this.#tail = this.#tail.then(() => this.record(progress)).catch(() => undefined);
+        return this.#tail;
+    }
+}

package/dist/runtime/compaction/requests.d.ts

@@ -0,0 +1,16 @@
+import type { CompactInput, ExecutionHandle } from '../execution-handle.js';
+import type { AgentEvent } from '../events.js';
+import type { CompactFlight } from './coordinator.js';
+/** External handles represent an operation inside its owning main Execution, not another loop. */
+export declare class CompactRequests {
+    #private;
+    readonly executionId: string;
+    readonly assertAdmission: () => void;
+    constructor(executionId: string, assertAdmission: () => void);
+    request(input: CompactInput): ExecutionHandle;
+    publish(event: AgentEvent): void;
+    bind(join: (input: CompactInput) => CompactFlight | undefined): void;
+    drain(start: (input: CompactInput) => CompactFlight): boolean;
+    seal(): void;
+    close(error: unknown): void;
+}