@myagentroam/agent 0.10.28 → 0.10.30

package/dist/agent-core/extensions/session-input.d.ts

@@ -34,6 +34,7 @@ export interface CoreSubmitInput extends CorePromptInput {
 }
 export interface CoreCompactInput {
     readonly focus?: string;
+    readonly async?: boolean;
 }
 export type CoreSessionRequest = {
     readonly kind: 'append';
@@ -130,6 +131,7 @@ export declare class SessionInputCoordinator {
     get hasPending(): boolean;
     get hasBoundaryPending(): boolean;
     get executing(): boolean;
+    get hasBoundaryCompactPending(): boolean;
     currentCompact(): CoreSessionReceipt | undefined;
     inspect(): readonly CoreSessionReceipt[];
     performAppend(input: CoreAppendInput, call: CoreOperationContext, action: CoreSessionAction, leaf: (entry: SessionInputEntry, request: CoreSessionRequest, call: CoreOperationContext) => Promise<CoreSessionActionResult>): Promise<CoreSessionReceipt>;

package/dist/agent-core/extensions/session-input.js

@@ -43,6 +43,17 @@ export class SessionInputCoordinator {
     get executing() {
         return this.#current.getStore()?.receipt.status === 'in-progress';
     }
+    get hasBoundaryCompactPending() {
+        for (const entry of this.#pending) {
+            if (entry.receipt.status === 'cancelled' || entry.source.signal.aborted)
+                continue;
+            if (entry.request.kind === 'submit' && entry.request.input.delivery === 'idle')
+                return false;
+            if (entry.request.kind === 'compact')
+                return true;
+        }
+        return false;
+    }
     currentCompact() {
         const entry = this.#current.getStore();
         return entry?.request.kind === 'compact' && entry.receipt.status === 'in-progress'
@@ -186,7 +197,14 @@ export class SessionInputCoordinator {
                         : entry.source.signal,
                     ...(execution ? { executionId: execution.executionId, turnId: execution.turnId } : {})
                 });
-                const applied = await this.#execute(entry, call, leaf);
+                const executing = this.#execute(entry, call, leaf);
+                if (execution && entry.request.kind === 'compact' && entry.request.input.async) {
+                    // Keep the receipt in progress while the main loop reaches adoption checkpoints.
+                    void executing.catch(() => undefined);
+                    await Promise.race([entry.started, executing]);
+                    continue;
+                }
+                const applied = await executing;
                 changed ||= applied;
             }
             return changed;
@@ -345,7 +363,7 @@ export function validateCoreSessionRequest(request) {
                 (request.input.modelAttribution !== undefined &&
                     request.input.modelAttribution !== 'none'))) ||
         (request.kind === 'compact' &&
-            request.input.focus !== undefined &&
-            typeof request.input.focus !== 'string'))
+            ((request.input.focus !== undefined && typeof request.input.focus !== 'string') ||
+                (request.input.async !== undefined && typeof request.input.async !== 'boolean'))))
         throw new MarAgentError('MAR_AGENT_SESSION_INPUT_INVALID', 'Session input is invalid.');
 }

package/dist/agent-core/model/openai-responses.js

@@ -1770,7 +1770,7 @@ function strictFunctionSchema(value, optional = false) {
     if (value === null || typeof value !== 'object' || Array.isArray(value))
         return value;
     const schema = value;
-    const supportedSchema = Object.fromEntries(Object.entries(schema).filter(([keyword]) => keyword !== 'propertyNames'));
+    const supportedSchema = Object.fromEntries(Object.entries(schema).filter(([keyword]) => keyword !== 'propertyNames' && keyword !== 'uniqueItems'));
     if (schema.type === 'object') {
         const properties = record(schema.properties);
         const required = new Set(Array.isArray(schema.required) ? schema.required : []);

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

@@ -0,0 +1,15 @@
+export interface CompactFlight {
+    readonly id: string;
+    readonly focus: string | undefined;
+    readonly result: Promise<boolean>;
+}
+/** One generation and adoption lane, with installation released only by a safe checkpoint. */
+export declare class CompactCoordinator {
+    #private;
+    get pending(): boolean;
+    get waiting(): boolean;
+    assertNotReentrant(): void;
+    start(id: string, focus: string | undefined, run: (prepare: () => Promise<void>, signal: AbortSignal) => Promise<boolean>): CompactFlight;
+    checkpoint(wait: boolean): Promise<boolean | undefined>;
+    close(reason: unknown): Promise<void>;
+}

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

@@ -0,0 +1,88 @@
+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/requests.d.ts

@@ -0,0 +1,16 @@
+import type { CompactInput, ExecutionHandle } from '../../sdk/types.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

@@ -0,0 +1,114 @@
+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

@@ -0,0 +1,6 @@
+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/jsonl-store.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

@@ -0,0 +1,52 @@
+import { parseModelInputMetadata } from '../../session/jsonl-store.js';
+import { restoreModelContext } from '../context/projection.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') {
+        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 } : {}),
+            ...(Array.isArray(input.images) &&
+                input.images.every((image) => image && typeof image.mimeType === 'string' && typeof image.dataBase64 === 'string')
+                ? {
+                    images: input.images.map((image) => ({
+                        mimeType: image.mimeType,
+                        dataBase64: image.dataBase64
+                    }))
+                }
+                : {})
+        };
+    }
+    return restoreModelContext(input);
+}

package/dist/agent-core/runtime/context/restore.d.ts

@@ -7,6 +7,7 @@ export declare function restoreMessages(store: JsonlSessionStore, sessionId: str
     strictImages?: boolean;
     currentTurnId?: string;
     projection?: ContextProjection;
+    messageSources?: WeakMap<ModelMessage, import('../../session/jsonl-store.js').SessionRecord>;
 }): Promise<{
     toolOutcomes: WeakMap<ModelMessage, {
         isError: boolean;

package/dist/agent-core/runtime/context/restore.js

@@ -1,8 +1,9 @@
 import { MarAgentError } from '../../error.js';
 import { compactSummaryFromCheckpoint, replacementHistoryFromCheckpoint, inputMetadataFromRecord } from '../../session/jsonl-store.js';
 import { compactedHistoryMessages, continuationMessage } from '../compaction/history.js';
+import { restoreCompactTail } from '../compaction/retained-context.js';
 import { environmentContextUpdate, restoreEnvironmentState } from './environment.js';
-import { buildContextProjection, restoreModelContext } from './projection.js';
+import { buildContextProjection } from './projection.js';
 export async function restoreMessages(store, sessionId, records, options) {
     const messages = [];
     const outcomes = new Map();
@@ -14,6 +15,7 @@ export async function restoreMessages(store, sessionId, records, options) {
     let currentTurnUserIndex;
     let environmentState;
     for (const record of records) {
+        const messageStart = messages.length;
         const payload = record.payload;
         if ((record.type === 'tool.completed' || record.type === 'tool.failed') &&
             typeof payload.callId === 'string') {
@@ -95,11 +97,17 @@ export async function restoreMessages(store, sessionId, records, options) {
                 ]));
             if (Array.isArray(payload.retainedModelContext))
                 for (const item of payload.retainedModelContext) {
-                    if (!item || typeof item !== 'object' || item.role !== 'user')
+                    if (!item || typeof item !== 'object')
                         continue;
-                    const message = restoreModelContext(item);
-                    if (message)
+                    const message = restoreCompactTail(item);
+                    if (message) {
                         messages.push(message);
+                        if (message.role === 'user' && message.contextKind === undefined)
+                            userMessages.push({
+                                content: message.content,
+                                ...(message.metadata ? { metadata: message.metadata } : {})
+                            });
+                    }
                 }
         }
         else if (record.type === 'context.environment') {
@@ -122,6 +130,8 @@ export async function restoreMessages(store, sessionId, records, options) {
                 }
             }
         }
+        for (const message of messages.slice(messageStart))
+            options.messageSources?.set(message, record);
     }
     const completedToolCalls = new Set(messages.filter((message) => message.role === 'tool').map((message) => message.callId));
     return {

package/dist/agent-core/runtime/context/usage.js

@@ -48,7 +48,9 @@ export function latestModelUsage(records, selectedModelId) {
             else if (invalidatesUsageCalibration(record.type, payload.type))
                 usage = undefined;
         }
-        if (payload.type === 'usage.updated' && activeModelId === selectedModelId) {
+        if (payload.type === 'usage.updated' &&
+            payload.purpose !== 'compact' &&
+            activeModelId === selectedModelId) {
             const value = payload.contextInputTokens ?? payload.inputTokens;
             if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0)
                 usage = {

package/dist/agent-core/runtime/event-projection.js

@@ -11,7 +11,7 @@ export function toolEventSummary(text) {
 /** Keep streaming deltas live-only; exec output has one durable copy in model context records. */
 export function eventForPersistence(event) {
     if (event.type === 'message.delta' ||
-        event.type === 'context.compacting' ||
+        (event.type === 'context.compacting' && event.async !== true && event.stage === undefined) ||
         event.type === 'model.performance' ||
         event.type === 'message.performance')
         return undefined;

package/dist/agent-core/runtime/events.d.ts

@@ -9,6 +9,10 @@ export interface MarAgentEventBase {
     executionId: string;
     turnId?: string;
 }
+export interface CompactSnapshotAnchor {
+    readonly kind: 'message' | 'tool';
+    readonly id: string;
+}
 export type MarAgentEvent = MarAgentEventBase & ({
     type: 'execution.started';
     mode: ExecutionMode;
@@ -97,6 +101,7 @@ export type MarAgentEvent = MarAgentEventBase & ({
     truncated?: boolean;
 } | {
     type: 'usage.updated';
+    purpose?: 'compact';
     inputTokens?: number | undefined;
     contextInputTokens?: number | undefined;
     outputTokens?: number | undefined;
@@ -145,8 +150,24 @@ export type MarAgentEvent = MarAgentEventBase & ({
 } | {
     type: 'context.compacting';
     compactionId: string;
+    async?: boolean;
+    stage?: 'GENERATING' | 'READY' | 'WAITING';
+    anchorRecordId?: string;
+    anchor?: CompactSnapshotAnchor;
 } | {
     type: 'context.compacted';
     compactionId: string;
+    async?: boolean;
+    retainedContext?: boolean;
+    anchorRecordId?: string;
+    anchor?: CompactSnapshotAnchor;
+} | {
+    type: 'context.compact_failed';
+    compactionId: string;
+    code: string;
+    async?: boolean;
+    cancelled?: boolean;
+    anchorRecordId?: string;
+    anchor?: CompactSnapshotAnchor;
 });
 export type EventPayload<T = MarAgentEvent> = T extends MarAgentEvent ? Omit<T, 'eventId' | 'sequence' | 'timestamp' | 'sessionId' | 'executionId' | 'turnId'> : never;

package/dist/agent-core/runtime/execution-policy.d.ts

@@ -3,6 +3,7 @@ export declare const AGENT_EXECUTION_POLICY: Readonly<{
     toolEventSummaryCharacters: 2000;
     modelToolOutputTokens: 10000;
     automaticCompactionPercent: 90;
+    backgroundCompactionPercent: 85;
     subagentVerificationCharacters: 500;
     estimatedTokensPerImage: 1000;
 }>;

package/dist/agent-core/runtime/execution-policy.js

@@ -3,6 +3,7 @@ export const AGENT_EXECUTION_POLICY = Object.freeze({
     toolEventSummaryCharacters: 2_000,
     modelToolOutputTokens: 10_000,
     automaticCompactionPercent: 90,
+    backgroundCompactionPercent: 85,
     subagentVerificationCharacters: 500,
     estimatedTokensPerImage: 1_000
 });

package/dist/agent-core/runtime/execution.d.ts

@@ -27,6 +27,7 @@ export interface ExecutionLoopInput {
     readonly compactionFallback?: (() => boolean) | undefined;
     readonly observeUsage: (usage: Omit<AuthoritativeModelUsage, 'historyMessages'> | undefined) => void;
     readonly observeContextTokens: (tokens: number) => void;
+    readonly afterModel?: (closedPrefixLength: number) => Promise<void>;
     readonly checkpoint: (round: PreparedExecutionRound, usage: ModelUsage | undefined) => Promise<void>;
     readonly mailbox: {
         hasPending(): boolean;

package/dist/agent-core/runtime/execution.js

@@ -299,6 +299,7 @@ export class ExecutionLoop {
             }
             recoveringFromContextOverflow = false;
             input.observeUsage(roundServerUsage);
+            await input.afterModel?.(pendingTools.length ? roundMessageCount : messages.length);
             const toolResults = await executeRoundTools(pendingTools, round.toolScope);
             for (const result of toolResults) {
                 if ('images' in result && result.images?.length)

package/dist/agent-core/sdk/extension-session.js

@@ -88,13 +88,15 @@ export function createExtensionSessionBackend(ports) {
             }
             const current = request.kind === 'compact' ? coordinator.currentCompact() : undefined;
             if (current)
-                return current;
+                throw new MarAgentError('MAR_AGENT_COMPACT_REENTRANT', 'Recursive compaction is not allowed.');
             const idle = !ports.activeExecutionId() && !coordinator.executing;
             const entry = coordinator.accept(request, call, action, request.kind === 'submit' ? 'accepted' : 'queued');
             kick();
             if (idle && request.kind === 'submit' && request.input.waitFor === 'start')
                 await entry.started;
-            else if ((idle && request.kind !== 'submit') ||
+            else if ((idle &&
+                request.kind !== 'submit' &&
+                !(request.kind === 'compact' && request.input.async)) ||
                 (request.kind === 'submit' && request.input.waitFor === 'commit'))
                 await entry.terminal;
             return Object.freeze({ ...entry.receipt });

package/dist/agent-core/sdk/session.d.ts

@@ -9,6 +9,7 @@ import type { CoreAgentsBackend } from '../extensions/agents.js';
 import type { HostDescription, MarAgentHost } from '../host/contracts.js';
 import { type MarAgentReasoningEffort } from '../model/configuration.js';
 import type { ModelAdapter, ModelMessage } from '../model/contracts.js';
+import { CompactRequests } from '../runtime/compaction/requests.js';
 import { JsonlSessionStore } from '../session/jsonl-store.js';
 import { SubagentSessionController, type SubagentMailboxMessage, type SubagentMessageDelivery, type SubagentTurnHandle } from '../subagent/session-controller.js';
 import { createSessionToolScheduler } from '../tools/scheduler.js';
@@ -24,6 +25,7 @@ export interface SessionRuntime {
     subagents?: SubagentSessionController;
     subagentsOpening?: Promise<SubagentSessionController>;
     inputs?: SessionInputCoordinator;
+    compactRequests?: CompactRequests;
     requestSnapshots?: ExtensionRequestSnapshots;
     requestMessages?: {
         readonly executionId: string;