@myagentroam/agent 0.11.53 → 0.11.54

package/dist/model/native-context.d.ts

@@ -1,5 +1,9 @@
 import type { ModelMessage } from './contracts.js';
-/** Identity of a persisted complete native thinking item; payload content is never compared. */
-export declare function completedNativeThinkingIdentity(payload: Record<string, unknown>, recordId: string): string | undefined;
+/** Adapters persist native items at completion; consumers need only type and identity. */
+export declare function completedNativeThinkingIdentity(payload: {
+    role?: unknown;
+    provider?: unknown;
+    item?: unknown;
+}, recordId: string): string | undefined;
 /** Interpret only the existing native context record shapes and their model ownership. */
 export declare function restoreNativeModelContext(payload: Record<string, unknown>, activeModelId?: string): ModelMessage | undefined;

package/dist/model/native-context.js

@@ -1,29 +1,18 @@
 import { anthropicThinkingBlock } from './anthropic-thinking.js';
-/** Identity of a persisted complete native thinking item; payload content is never compared. */
+/** Adapters persist native items at completion; consumers need only type and identity. */
 export function completedNativeThinkingIdentity(payload, recordId) {
     if (payload.role !== 'provider')
         return undefined;
+    const item = payload.item;
+    if (!item || typeof item !== 'object' || Array.isArray(item))
+        return undefined;
+    const block = item;
     if (payload.provider === 'ANTHROPIC_MESSAGES') {
-        const item = payload.item;
-        if (!item || typeof item !== 'object' || Array.isArray(item))
-            return undefined;
-        const block = item;
-        return (block.type === 'thinking' &&
-            typeof block.thinking === 'string' &&
-            typeof block.signature === 'string' &&
-            block.signature.length > 0) ||
-            (block.type === 'redacted_thinking' &&
-                typeof block.data === 'string' &&
-                block.data.length > 0)
-            ? recordId
-            : undefined;
+        return block.type === 'thinking' || block.type === 'redacted_thinking' ? recordId : undefined;
     }
-    const message = restoreNativeModelContext(payload);
-    if (!message?.item)
-        return undefined;
-    if (message.provider !== 'OPENAI_RESPONSES' || message.item.type !== 'reasoning')
+    if (payload.provider !== 'OPENAI_RESPONSES' || block.type !== 'reasoning')
         return undefined;
-    return typeof message.item.id === 'string' ? message.item.id : recordId;
+    return typeof block.id === 'string' ? block.id : recordId;
 }
 /** Interpret only the existing native context record shapes and their model ownership. */
 export function restoreNativeModelContext(payload, activeModelId) {

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

@@ -1,5 +1,10 @@
 import type { SessionModelMessage as ModelMessage } from '../../session/model-request.js';
 import type { CompactSnapshotAnchor } from '../events.js';
+/** Keep the live suffix intact, extending into the snapshot only to fill three native blocks. */
+export declare function compactRetainedStart(messages: readonly ModelMessage[], snapshotLength: number, model: {
+    readonly id: string;
+    readonly protocol: ModelMessage['provider'];
+}): number;
 /** 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/record-contract.js').SessionRecord>): CompactSnapshotAnchor | undefined;
 /** Decode the SDK-owned checkpoint suffix without promoting contextual text to real input. */

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

@@ -1,6 +1,49 @@
 import { parseModelInputMetadata } from '../../session/record-projection.js';
-import { restoreModelContext } from '../context/projection.js';
+import { providerToolCallId, restoreModelContext } from '../context/projection.js';
 import { parseModelImages } from '../../model/image.js';
+import { completedNativeThinkingIdentity } from '../../model/native-context.js';
+/** Keep the live suffix intact, extending into the snapshot only to fill three native blocks. */
+export function compactRetainedStart(messages, snapshotLength, model) {
+    let start = snapshotLength;
+    const thinking = new Set();
+    for (let index = messages.length - 1; index >= 0 && thinking.size < 3; index--) {
+        const message = messages[index];
+        if (message.provider !== model.protocol ||
+            (message.providerModelId !== undefined && message.providerModelId !== model.id))
+            continue;
+        const identity = completedNativeThinkingIdentity(message, `message:${index}`);
+        if (identity === undefined || thinking.has(identity))
+            continue;
+        thinking.add(identity);
+        start = Math.min(start, index);
+    }
+    // The existing snapshot boundary already closes tool groups.
+    if (start === snapshotLength)
+        return start;
+    // A native item can follow text or tool calls within the same assistant response.
+    while (start > 0 && messages[start - 1].role !== 'user' && messages[start - 1].role !== 'tool')
+        start--;
+    // Resolve any retained result back to its call's assistant group in two linear passes.
+    const calls = new Map();
+    let responseStart = 0;
+    for (let index = 0; index < start; index++) {
+        const message = messages[index];
+        if (message.role === 'user' || message.role === 'tool')
+            responseStart = index + 1;
+        const callId = message.role === 'tool_call' ? message.callId : providerToolCallId(message);
+        if (callId !== undefined && !calls.has(callId))
+            calls.set(callId, responseStart);
+    }
+    for (let index = messages.length - 1; index >= start; index--) {
+        const message = messages[index];
+        if (message.role !== 'tool' || message.callId === undefined)
+            continue;
+        const callStart = calls.get(message.callId);
+        if (callStart !== undefined)
+            start = Math.min(start, callStart);
+    }
+    return start;
+}
 /** 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--) {

package/dist/sdk/execution-compact-commit.d.ts

@@ -2,6 +2,7 @@ import type { SessionModelMessage } from '../session/model-request.js';
 import type { SessionRecord } from '../session/record-contract.js';
 import type { SessionStore, SessionStoreCompactInput } from '../session/store/contracts.js';
 import type { ResourceInputProjection } from './resource-input.js';
+import { compactRetainedStart } from '../runtime/compaction/retained-context.js';
 /** Commits one validated snapshot and records its fact before fallible live projection. */
 export declare function commitExecutionCompaction(input: {
     readonly store: Pick<SessionStore, 'compact'>;
@@ -9,9 +10,10 @@ export declare function commitExecutionCompaction(input: {
     readonly signal: AbortSignal;
     readonly prefix: readonly SessionModelMessage[];
     readonly messages: readonly SessionModelMessage[];
+    readonly model: Parameters<typeof compactRetainedStart>[2];
     readonly generation: string | undefined;
     readonly messageSources: WeakMap<SessionModelMessage, SessionRecord>;
-    draft(): Omit<SessionStoreCompactInput, 'retainedModelContext' | 'inlineMediaState'>;
+    draft(retainedStart: number): Omit<SessionStoreCompactInput, 'retainedModelContext' | 'inlineMediaState'>;
     readonly checkpoint: ResourceInputProjection['checkpoint'];
     readonly withProjection: <T>(action: () => Promise<T>) => Promise<T>;
     readonly currentGeneration: () => string | undefined;
@@ -20,4 +22,4 @@ export declare function commitExecutionCompaction(input: {
 }): Promise<{
     record: SessionRecord;
     retained: SessionModelMessage[];
-}>;
+} | undefined>;

package/dist/sdk/execution-compact-commit.js

@@ -1,4 +1,5 @@
 import { AgentError } from '../error.js';
+import { compactRetainedStart } from '../runtime/compaction/retained-context.js';
 /** Commits one validated snapshot and records its fact before fallible live projection. */
 export async function commitExecutionCompaction(input) {
     return input.withProjection(async () => {
@@ -6,14 +7,17 @@ export async function commitExecutionCompaction(input) {
         if (input.currentGeneration() !== input.generation ||
             input.prefix.some((message, index) => input.messages[index] !== message))
             throw new AgentError('MAR_AGENT_COMPACT_STALE', 'The compaction prefix has changed.');
+        const retainedStart = compactRetainedStart(input.messages, input.prefix.length, input.model);
+        if (retainedStart === 0)
+            return undefined;
         const retained = input.messages
-            .slice(input.prefix.length)
+            .slice(retainedStart)
             .filter((message) => message.contextKind !== 'private' || message.role === 'provider');
         const retainedModelContext = retained.map((message) => {
             const source = input.messageSources.get(message);
             const saved = source?.type === 'model.context' && source.payload.inputRef
                 ? source.payload
-                : source?.type === 'compact.completed'
+                : source?.type === 'compact.completed' && message.metadata?.recordId !== undefined
                     ? (source.payload
                         .retainedModelContext ?? []).find((item) => item.inputRef === message.metadata?.recordId)
                     : undefined;
@@ -30,7 +34,7 @@ export async function commitExecutionCompaction(input) {
                 };
         });
         const record = await input.store.compact(input.sessionId, {
-            ...input.draft(),
+            ...input.draft(retainedStart),
             inlineMediaState: input.checkpoint(retained),
             retainedModelContext
         }, { signal: input.signal });

package/dist/sdk/execution-compaction.d.ts

@@ -17,7 +17,7 @@ export declare function createExecutionCompaction(ports: {
     readonly sessionId: string;
     readonly executionId: string;
     readonly turnId: string;
-    readonly model: Pick<ResolvedModelConfiguration, 'id' | 'contextWindowTokens'>;
+    readonly model: Pick<ResolvedModelConfiguration, 'id' | 'protocol' | 'contextWindowTokens'>;
     readonly messages: SessionModelMessage[];
     readonly pendingInputs: Map<string, SessionRecord>;
     readonly messageSources: WeakMap<SessionModelMessage, SessionRecord>;

package/dist/sdk/execution-compaction.js

@@ -17,7 +17,6 @@ export function createExecutionCompaction(ports) {
             message.contextKind === 'summary'))
             return false;
         const history = structuredClone(prefix).map(({ images: _images, ...message }) => message);
-        const prefixInputs = modelContext.compactInputs(prefix);
         const tools = structuredClone(ports.snapshotTools());
         const generation = modelContext.worldState.generation;
         const usage = ports.usage();
@@ -62,7 +61,7 @@ export function createExecutionCompaction(ports) {
         await prepare();
         signal.throwIfAborted();
         const resources = await ports.retainedResources();
-        const replacementHistory = buildCompactedHistory(candidate.summary, prefixInputs, ports.userTokenLimit);
+        let replacementHistory;
         let committed = false;
         let retained;
         try {
@@ -72,6 +71,7 @@ export function createExecutionCompaction(ports) {
                 signal,
                 prefix,
                 messages,
+                model: ports.model,
                 generation,
                 messageSources: ports.messageSources,
                 checkpoint: (value) => ports.resourceInput.checkpoint(value),
@@ -85,21 +85,26 @@ export function createExecutionCompaction(ports) {
                     modelContext.replaceCompactMessages(replacementHistory, value);
                     ports.updateBoundary(messages.length - value.length);
                 },
-                draft: () => ({
-                    summary: candidate.summary,
-                    replacementHistory,
-                    pendingInputs: [...ports.pendingInputs.values()],
-                    snapshotMessageCount: prefix.length,
-                    ...(anchorRecordId ? { snapshotRecordId: anchorRecordId } : {}),
-                    automatic: ports.mode !== 'compact',
-                    environment: ports.environment(),
-                    modelId: ports.model.id,
-                    contextWindowTokens: ports.model.contextWindowTokens,
-                    ...(candidate.usage === undefined ? {} : { usage: candidate.usage }),
-                    executionId: ports.executionId,
-                    turnId: ports.turnId
-                })
+                draft: (retainedStart) => {
+                    replacementHistory = buildCompactedHistory(candidate.summary, modelContext.compactInputs(prefix.slice(0, retainedStart)), ports.userTokenLimit);
+                    return {
+                        summary: candidate.summary,
+                        replacementHistory,
+                        pendingInputs: [...ports.pendingInputs.values()],
+                        snapshotMessageCount: prefix.length,
+                        ...(anchorRecordId ? { snapshotRecordId: anchorRecordId } : {}),
+                        automatic: ports.mode !== 'compact',
+                        environment: ports.environment(),
+                        modelId: ports.model.id,
+                        contextWindowTokens: ports.model.contextWindowTokens,
+                        ...(candidate.usage === undefined ? {} : { usage: candidate.usage }),
+                        executionId: ports.executionId,
+                        turnId: ports.turnId
+                    };
+                }
             });
+            if (!result)
+                return false;
             retained = result.retained;
             await modelContext.adoptCompactCheckpoint(result.record.recordId, replacementHistory, retained, resources);
             ports.invalidateUsage();

package/dist/sdk/session-execution-factory.js

@@ -165,7 +165,8 @@ export function createSessionExecutionFactory(ports) {
                 const compactMayContainAgentInstructions = contextRecords.some((record) => compactSummaryFromCheckpoint(record) !== undefined);
                 const restored = await restoreMessages(store, sessionId, contextRecords, {
                     messageSources,
-                    includeImages: mode !== 'compact'
+                    // Keep durable references for the retained tail; the Compact snapshot removes images.
+                    includeImages: true
                 });
                 let modelLifecycle;
                 let applyCompactBoundary = () => { };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/agent",
-  "version": "0.11.53",
+  "version": "0.11.54",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",