@myagentroam/agent 0.11.33 → 0.11.34

package/dist/agent-core/prompts/index.js

@@ -1,49 +0,0 @@
-import { renderPromptSections } from '../extensions/prompt-composition.js';
-import { compactionPrompt } from './compact.js';
-import { environmentPrompt, identityPrompt, instructionPriorityPrompt, workspaceDisciplinePrompt } from './core.js';
-import { modePrompt } from './modes.js';
-import { outputStylePrompt } from './output.js';
-import { subagentPrompt } from './subagent.js';
-import { interactionPrompt, longRunningPrompt, safetyPrompt, toolUsagePrompt, workflowPrompt } from './workflow.js';
-export const MAR_AGENT_PROMPT_VERSION = '1.67';
-export function buildSystemPrompt(input) {
-    return renderPromptSections(buildSystemPromptSections(input));
-}
-export function buildSystemPromptSections(input) {
-    const toolNames = new Set(input.tools);
-    const hasLongRunningCapability = [
-        'exec',
-        'todo_read',
-        'todo_write',
-        'agent_start',
-        'agent_wait',
-        'agent_cancel'
-    ].some((name) => toolNames.has(name));
-    const values = [
-        ['identity', identityPrompt()],
-        ['instruction-priority', instructionPriorityPrompt],
-        ['workspace-discipline', workspaceDisciplinePrompt],
-        ['workflow', workflowPrompt],
-        ['interaction', interactionPrompt],
-        ['safety', safetyPrompt],
-        ['output-style', outputStylePrompt],
-        ['environment-rules', environmentPrompt(input)],
-        ['tools', input.tools.length > 0 ? toolUsagePrompt(input.tools, input.directTools) : ''],
-        ['long-running', hasLongRunningCapability ? longRunningPrompt(input.tools) : ''],
-        [
-            'mode',
-            modePrompt(input.mode, {
-                questionAvailable: toolNames.has('question')
-            })
-        ],
-        ['compaction', input.mode === 'compact' ? compactionPrompt() : ''],
-        ['subagent', toolNames.has('agent_start') ? subagentPrompt : ''],
-        [
-            'caller-instructions',
-            input.extension
-                ? `# Caller, project, and selected Skill instructions\n${input.extension}`
-                : ''
-        ]
-    ];
-    return Object.freeze(values.map(([id, text]) => Object.freeze({ id: `core:${id}`, text: text || null })));
-}

package/dist/agent-core/runtime/compaction/coordinator.js

@@ -1,88 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { MarAgentError } 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 MarAgentError('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 MarAgentError('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/agent-core/runtime/compaction/generate.d.ts

@@ -1,28 +0,0 @@
-import type { CoreCompactResult } from '../../extensions/compaction.js';
-import type { ClientToolDefinition, ModelEvent, ModelMessage, ModelRequest, 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<CoreCompactResult | 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<CoreCompactResult>;
-export {};

package/dist/agent-core/runtime/compaction/generate.js

@@ -1,84 +0,0 @@
-import { MarAgentError } 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 MarAgentError('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 MarAgentError('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 MarAgentError('MAR_AGENT_CONTEXT_LIMIT', 'The compaction request exceeds the model context window.', { cause: error });
-            throw error;
-        }
-        if (!summary)
-            throw new MarAgentError('MAR_AGENT_COMPACT_FAILED', 'Automatic compact failed.');
-        return { summary, ...(usage === undefined ? {} : { usage }) };
-    }
-}

package/dist/agent-core/runtime/compaction/history.d.ts

@@ -1,16 +0,0 @@
-import type { ModelMessage } from '../../model/contracts.js';
-import type { CompactHistoryMessage, CompactUserInput } from '../../session/store/index.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/agent-core/runtime/compaction/operation.d.ts

@@ -1,29 +0,0 @@
-import type { ModelEvent, ModelRequest, ModelTurnSession } from '../../model/contracts.js';
-import type { CoreCompactDiagnostic } from '../../extensions/compaction.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?: CoreCompactDiagnostic;
-    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: CoreCompactDiagnostic): Promise<void>;
-    finishExtension(outcome: NonNullable<CompactionProgress['extensionOutcome']>): Promise<void>;
-    dispose(): Promise<void>;
-    private report;
-}

package/dist/agent-core/runtime/compaction/operation.js

@@ -1,131 +0,0 @@
-import { MarAgentError } 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 MarAgentError('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 MarAgentError('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/agent-core/runtime/compaction/requests.d.ts

@@ -1,16 +0,0 @@
-import type { CompactInput, ExecutionHandle } from '../execution-handle.js';
-import type { MarAgentEvent } 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: MarAgentEvent): void;
-    bind(join: (input: CompactInput) => CompactFlight | undefined): void;
-    drain(start: (input: CompactInput) => CompactFlight): boolean;
-    seal(): void;
-    close(error: unknown): void;
-}

package/dist/agent-core/runtime/compaction/requests.js

@@ -1,114 +0,0 @@
-import { AsyncQueue } from '../async-queue.js';
-import { MarAgentError, describeMarAgentError } from '../../error.js';
-/** External handles represent an operation inside its owning main Execution, not another loop. */
-export class CompactRequests {
-    executionId;
-    assertAdmission;
-    #closed = false;
-    #blocking = false;
-    #join;
-    #pending = [];
-    #observers = new Set();
-    constructor(executionId, assertAdmission) {
-        this.executionId = executionId;
-        this.assertAdmission = assertAdmission;
-    }
-    request(input) {
-        this.assertAdmission();
-        if (this.#closed)
-            throw new MarAgentError('MAR_AGENT_SESSION_INPUT_CLOSED', 'Execution is finishing.');
-        if (Object.entries(input).some(([key, value]) => value !== undefined && !['prompt', 'async'].includes(key)))
-            throw new MarAgentError('MAR_AGENT_COMPACT_CONFLICT', 'An active compaction uses its owning execution configuration.');
-        if (input.async !== undefined && typeof input.async !== 'boolean')
-            throw new MarAgentError('MAR_AGENT_SESSION_INPUT_INVALID', 'Compaction async mode is invalid.');
-        const queue = new AsyncQueue();
-        let resolve;
-        const result = new Promise((settle) => {
-            resolve = settle;
-        });
-        let settled = false;
-        let operationId;
-        const observe = (event) => {
-            if ('compactionId' in event && event.compactionId === operationId)
-                queue.push(event);
-        };
-        this.#observers.add(observe);
-        const finish = (status, error) => {
-            if (settled)
-                return;
-            settled = true;
-            const diagnostic = error === undefined ? undefined : describeMarAgentError(error, 'MAR_AGENT_COMPACT_FAILED');
-            resolve({
-                executionId: this.executionId,
-                status,
-                finalAnswer: '',
-                ...(diagnostic ? { errorCode: diagnostic.code, errorMessage: diagnostic.message } : {})
-            });
-            this.#observers.delete(observe);
-            queue.close();
-        };
-        const pending = {
-            input: { ...input },
-            cancelled: () => settled,
-            settle: (flight) => {
-                operationId = flight.id;
-                void flight.result.then((changed) => finish(changed ? 'completed' : 'failed', changed
-                    ? undefined
-                    : new MarAgentError('MAR_AGENT_CONTEXT_LIMIT', 'No history can be compacted.')), (error) => finish('failed', error));
-            },
-            fail: (error) => finish('failed', error)
-        };
-        try {
-            const flight = this.#join?.(input);
-            if (flight) {
-                pending.settle(flight);
-                this.#blocking ||= input.async !== true;
-            }
-            else
-                this.#pending.push(pending);
-        }
-        catch (error) {
-            pending.fail(error);
-        }
-        return {
-            executionId: this.executionId,
-            [Symbol.asyncIterator]: () => queue[Symbol.asyncIterator](),
-            result: () => {
-                queue.discardIfUnobserved();
-                return result;
-            },
-            cancel: () => finish('cancelled')
-        };
-    }
-    publish(event) {
-        for (const observer of this.#observers)
-            observer(event);
-    }
-    bind(join) {
-        this.#join = join;
-    }
-    drain(start) {
-        let blocking = this.#blocking;
-        this.#blocking = false;
-        for (const pending of this.#pending.splice(0)) {
-            if (pending.cancelled())
-                continue;
-            try {
-                pending.settle(start(pending.input));
-                blocking ||= pending.input.async !== true;
-            }
-            catch (error) {
-                pending.fail(error);
-            }
-        }
-        return blocking;
-    }
-    seal() {
-        this.#closed = true;
-    }
-    close(error) {
-        this.seal();
-        for (const pending of this.#pending.splice(0))
-            pending.fail(error);
-    }
-}

package/dist/agent-core/runtime/compaction/retained-context.d.ts

@@ -1,6 +0,0 @@
-import type { ModelMessage } from '../../model/contracts.js';
-import type { CompactSnapshotAnchor } from '../events.js';
-/** Use a public native identity, never private context text, as the visible boundary. */
-export declare function compactSnapshotAnchor(messages: readonly ModelMessage[], sources: WeakMap<ModelMessage, import('../../session/store/index.js').SessionRecord>): CompactSnapshotAnchor | undefined;
-/** Decode the SDK-owned checkpoint suffix without promoting contextual text to real input. */
-export declare function restoreCompactTail(value: unknown): ModelMessage | undefined;

package/dist/agent-core/runtime/compaction/retained-context.js

@@ -1,47 +0,0 @@
-import { parseModelInputMetadata } from '../../session/store/execution-state.js';
-import { restoreModelContext } from '../context/projection.js';
-import { parseModelImages } from '../../model/image.js';
-/** Use a public native identity, never private context text, as the visible boundary. */
-export function compactSnapshotAnchor(messages, sources) {
-    for (let index = messages.length - 1; index >= 0; index--) {
-        const message = messages[index];
-        if (message.role === 'tool' && message.callId)
-            return { kind: 'tool', id: message.callId };
-        const record = sources.get(message);
-        const payload = record?.payload;
-        if (record?.type === 'message.completed' && typeof payload?.itemId === 'string')
-            return { kind: 'message', id: payload.itemId };
-    }
-    return undefined;
-}
-/** Decode the SDK-owned checkpoint suffix without promoting contextual text to real input. */
-export function restoreCompactTail(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return undefined;
-    const input = value;
-    if ((input.contextKind === 'private' && input.role !== 'provider') ||
-        input.contextKind === 'compact_control')
-        return undefined;
-    if ((input.role === 'assistant' || input.role === 'user') && typeof input.content === 'string') {
-        if (input.inputRef !== undefined)
-            return restoreModelContext(input);
-        const projected = restoreModelContext(input);
-        const metadata = parseModelInputMetadata(input.metadata);
-        const contextKind = ['environment', 'contextual', 'summary'].includes(String(input.contextKind))
-            ? input.contextKind
-            : undefined;
-        return {
-            role: input.role,
-            content: input.content,
-            ...(contextKind
-                ? { contextKind }
-                : input.role === 'user' && !metadata
-                    ? { contextKind: 'contextual' }
-                    : {}),
-            ...(metadata ? { metadata } : {}),
-            ...(projected?.textBlocks ? { textBlocks: projected.textBlocks } : {}),
-            ...(parseModelImages(input.images)?.length ? { images: parseModelImages(input.images) } : {})
-        };
-    }
-    return restoreModelContext(input);
-}

package/dist/agent-core/runtime/compaction/smart.d.ts

@@ -1,14 +0,0 @@
-import type { ModelMessage } from '../../model/contracts.js';
-import type { SessionRecord } from '../../session/store/contracts.js';
-export declare const SMART_COMPACTION_MARKER = "<mar_runtime>\n  <smart_compaction>For this message only, smart_compact may be considered at a clear transition into sustained new work, when the previous phase is largely complete and its details have low continuation value.</smart_compaction>\n</mar_runtime>";
-export interface SmartCompactionInput {
-    readonly recordId: string;
-    readonly eligible: boolean;
-    requested: boolean;
-    error?: unknown;
-}
-/** A measured watermark, not the stricter native-request budget calibration. */
-export declare function latestSmartContextTokens(records: readonly SessionRecord[], modelId: string, contextWindowTokens: number): number | undefined;
-/** Only provider views receive the marker; durable message content stays unchanged. */
-export declare function projectSmartCompactionMessage(message: ModelMessage): ModelMessage;
-export declare function requestSmartCompaction(input: SmartCompactionInput | undefined, start: () => void): void;