@myagentroam/agent 0.9.171 → 0.9.173

package/dist/agent-core/runtime/context/world-state.js

@@ -1,11 +1,14 @@
-import { retainedSessionResourcesUpdate } from '../../prompts/resources.js';
 import { compactSummaryFromCheckpoint } from '../../session/jsonl-store.js';
 export function insertContextualWorldState(messages, entries) {
     const result = [...messages];
     let offset = 0;
     for (const entry of entries) {
         const insertionIndex = Math.max(0, Math.min(entry.index + offset, result.length));
-        result.splice(insertionIndex, 0, { role: 'user', content: entry.content });
+        result.splice(insertionIndex, 0, {
+            role: 'user',
+            content: entry.content,
+            contextKind: 'contextual'
+        });
         offset++;
     }
     return result;
@@ -87,24 +90,18 @@ export async function persistContextualWorldState(store, sessionId, state) {
         entries: state.entries
     });
 }
-export function compactHistoryMayContainRetainedResources(records) {
-    return records.some((record) => compactSummaryFromCheckpoint(record)?.includes('# Retained Session resources'));
-}
 export function updateContextualWorldState(state, index, current) {
     const entries = [...state.entries];
     if (!state.initialized || state.instructionSnapshot !== current.instructionSnapshot) {
         if (current.instructionContent !== undefined)
             entries.push({ index, kind: 'instructions', content: current.instructionContent });
     }
-    const resourceContent = retainedSessionResourcesUpdate(current.resourceSnapshot, state.initialized ? state.resourceSnapshot : undefined, current.previousMayContainResources);
-    if (resourceContent !== undefined)
-        entries.push({ index, kind: 'resources', content: resourceContent });
     return {
         generation: state.generation,
         mcpSnapshot: state.mcpSnapshot,
         initialized: true,
         instructionSnapshot: current.instructionSnapshot,
-        resourceSnapshot: current.resourceSnapshot,
+        resourceSnapshot: state.resourceSnapshot,
         entries
     };
 }
@@ -112,9 +109,8 @@ export function resetContextualWorldState(generation, index, current) {
     const entries = [];
     if (current.instructionContent !== undefined)
         entries.push({ index, kind: 'instructions', content: current.instructionContent });
-    const resourceContent = retainedSessionResourcesUpdate(current.resourceSnapshot, undefined, current.previousMayContainResources);
-    if (resourceContent !== undefined)
-        entries.push({ index, kind: 'resources', content: resourceContent });
+    if (current.resourceSnapshot !== undefined)
+        entries.push({ index, kind: 'resources', content: current.resourceSnapshot });
     return {
         generation,
         initialized: true,
@@ -124,9 +120,13 @@ export function resetContextualWorldState(generation, index, current) {
     };
 }
 export function contextualInstructionInsertIndex(messages) {
-    let index = messages.findLastIndex((message) => message.role === 'user' && message.contextKind !== 'environment');
+    let index = messages.findLastIndex((message) => message.role === 'user' &&
+        message.contextKind === undefined &&
+        message.metadata?.source !== 'extension');
+    if (index < 0)
+        index = messages.findLastIndex((message) => message.contextKind === 'summary');
     if (index < 0)
-        return 0;
+        return messages.length;
     if (index > 0 && messages[index - 1]?.contextKind === 'environment')
         index--;
     return index;

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

@@ -2,7 +2,7 @@ import { isProviderContextOverflow, recoverModelStream } from '../model/recovery
 import { estimatedRequestTokens } from '../runtime/context/request-budget.js';
 import { restoreMessages } from '../runtime/context/restore.js';
 import { lastConfigurationEffort, latestModelUsage, reasoningEffortBaseline, shouldUseNativeCompaction } from '../runtime/context/usage.js';
-import { compactHistoryMayContainRetainedResources, contextualInstructionInsertIndex, insertContextualWorldState, latestContextualWorldStateGeneration, parsePersistedContextualWorldState, persistContextualWorldState, resetContextualWorldState, updateContextualWorldState } from '../runtime/context/world-state.js';
+import { contextualInstructionInsertIndex, insertContextualWorldState, latestContextualWorldStateGeneration, parsePersistedContextualWorldState, persistContextualWorldState, resetContextualWorldState, updateContextualWorldState } from '../runtime/context/world-state.js';
 import { eventForPersistence, publicModelUsage } from '../runtime/event-projection.js';
 import { ExecutionLoop } from '../runtime/execution.js';
 import { closeModelAdapters, createModelTurnSession } from './model-runtime.js';
@@ -11,7 +11,7 @@ import { discoveredMcpToolNames, rebindMcpToolSearchOutputs } from '../tools/mcp
 import { currentExecutionImages } from '../tools/output-projection.js';
 import { createHash, randomUUID } from 'node:crypto';
 import { ExecutionToolSources } from './extension-tools.js';
-import { compactExtensionMessages, compactExtensionResult } from '../extensions/compaction.js';
+import { compactExtensionMessages, compactExtensionResult, compactExtensionDiagnostic } from '../extensions/compaction.js';
 import { ExtensionRequestBridge, ExtensionRequestSnapshots } from '../extensions/model-request.js';
 import { normalizeSessionMessagesInput, sessionMessagesPage } from '../extensions/session-messages.js';
 import { transformCoreModelStream } from '../extensions/model-stream.js';
@@ -38,7 +38,7 @@ import { AGENT_EXECUTION_POLICY } from '../runtime/execution-policy.js';
 import { loadAgentInstructions, renderAgentInstructions } from '../runtime/context/instructions.js';
 import { normalizeMessagesForModel } from '../runtime/context/normalize.js';
 import { RolloutBudget } from '../runtime/rollout-budget.js';
-import { compactSummaryFromCheckpoint } from '../session/jsonl-store.js';
+import { compactSummaryFromCheckpoint, inputMetadataFromRecord } from '../session/jsonl-store.js';
 import { SubagentSessionController } from '../subagent/session-controller.js';
 import { agentStartToolDefinitionWithModels } from '../tools/agent/agent-start.js';
 import { allowsDirectTool, allowsToolCaller, toolCallers } from '../tools/callers.js';
@@ -386,7 +386,6 @@ export function createSessionOpener(services) {
                         sessionRuntime.contextualWorldState = contextualWorldState;
                     }
                     const compactMayContainAgentInstructions = contextRecords.some((record) => compactSummaryFromCheckpoint(record) !== undefined);
-                    const compactMayContainRetainedResources = compactHistoryMayContainRetainedResources(contextRecords);
                     const restored = await restoreMessages(store, sessionId, contextRecords, {
                         includeImages: mode !== 'compact'
                     });
@@ -440,9 +439,14 @@ export function createSessionOpener(services) {
                                 executionId,
                                 turnId
                             }, { signal: call.signal });
-                            committed(content, record.recordId);
+                            const inputMetadata = inputMetadataFromRecord(record);
+                            compactionUserMessages.push({
+                                content: content.modelText ?? content.text,
+                                metadata: inputMetadata
+                            });
+                            committed(content, record.recordId, inputMetadata);
                             for (const text of content.modelContext ?? content.context ?? [])
-                                messages.push({ role: 'user', content: text });
+                                messages.push({ role: 'user', content: text, contextKind: 'contextual' });
                         });
                     };
                     const appendMailboxMessages = async () => inputs.drain(async (entry, request, call) => {
@@ -476,12 +480,13 @@ export function createSessionOpener(services) {
                             : {
                                 source: extensionInputSource(call, request.input.provenance, request.input.modelAttribution),
                                 ...(parent?.delivery ? { messageId: parent.delivery.messageId } : {})
-                            }, call, (actual, recordId) => {
+                            }, call, (actual, recordId, metadata) => {
                             outcome = { changed: true, executionId, recordId };
                             recordSessionInputCommit(entry, outcome);
                             messages.push({
                                 role: 'user',
                                 content: actual.modelText ?? actual.text,
+                                metadata,
                                 ...(actual.images?.length
                                     ? {
                                         images: actual.images.map(({ mimeType, dataBase64 }) => ({
@@ -739,21 +744,26 @@ export function createSessionOpener(services) {
                             subagents: subagents?.listSessionResources() ?? []
                         };
                     };
-                    let currentResourceSnapshot = retainedSessionResourcesSnapshot(await loadRetainedSessionResources());
+                    const resetCompactWorldState = async (generation) => {
+                        agentInstructionInsertIndex = contextualInstructionInsertIndex(messages);
+                        contextualWorldState = resetContextualWorldState(generation, agentInstructionInsertIndex, {
+                            instructionSnapshot: currentInstructionSnapshot,
+                            instructionContent: renderAgentInstructions(instructionEntries, true),
+                            resourceSnapshot: retainedSessionResourcesSnapshot(await loadRetainedSessionResources())
+                        });
+                        sessionRuntime.contextualWorldState = contextualWorldState;
+                        await persistContextualWorldState(store, sessionId, contextualWorldState);
+                    };
+                    // A missing sidecar is rebuilt only for the latest Compact, never for a GC boundary.
+                    if (!contextualWorldState.initialized &&
+                        contextRecords.some((record) => record.recordId === contextualWorldStateGeneration &&
+                            compactSummaryFromCheckpoint(record) !== undefined))
+                        await resetCompactWorldState(contextualWorldStateGeneration);
                     const previousContextualWorldState = contextualWorldState;
                     contextualWorldState = updateContextualWorldState(contextualWorldState, agentInstructionInsertIndex, {
                         instructionSnapshot: currentInstructionSnapshot,
                         instructionContent: renderAgentInstructions(instructionEntries, compactMayContainAgentInstructions ||
-                            contextualWorldState.instructionSnapshot !== undefined),
-                        resourceSnapshot: currentResourceSnapshot,
-                        previousMayContainResources: (!contextualWorldState.initialized && compactMayContainRetainedResources) ||
-                            (host.listSessionResources !== undefined &&
-                                currentResourceSnapshot === undefined &&
-                                messages
-                                    .slice(contextualWorldState.entries.findLast((entry) => entry.kind === 'resources')
-                                    ?.index ?? 0)
-                                    .some((message) => message.role === 'tool_call' &&
-                                    ['exec', 'code_exec', 'agent_start'].includes(message.name ?? '')))
+                            contextualWorldState.instructionSnapshot !== undefined)
                     });
                     sessionRuntime.contextualWorldState = contextualWorldState;
                     if (!isDeepStrictEqual(previousContextualWorldState, contextualWorldState))
@@ -958,14 +968,17 @@ export function createSessionOpener(services) {
                                     ? {}
                                     : { inputSource: internal.inputSource }),
                                 ...(input.clientMessageId ? { clientMessageId: input.clientMessageId } : {})
-                            }, call, (actual, recordId) => {
+                            }, call, (actual, recordId, metadata) => {
                                 entered = true;
-                                compactionUserMessages.push(actual.text);
                                 modelInputImages = actual.images?.map(({ mimeType, dataBase64 }) => ({
                                     mimeType,
                                     dataBase64
                                 }));
-                                messages.push({ role: 'user', content: actual.modelText ?? actual.text });
+                                messages.push({
+                                    role: 'user',
+                                    content: actual.modelText ?? actual.text,
+                                    metadata
+                                });
                                 currentExecutionUserIndex = messages.length - 1;
                                 internal.inputCommitted?.(recordId);
                                 internal.delivery?.applied();
@@ -1019,6 +1032,8 @@ export function createSessionOpener(services) {
                                 return undefined;
                             const summaryTokenBudget = Math.min(10_000, selectedModel.maxOutputTokens, Math.max(1, Math.floor(selectedModel.contextWindowTokens / 4)));
                             const highDensityCompaction = selectedModel.highDensityCompaction;
+                            let diagnosticReports = 0;
+                            let acceptsDiagnostics = true;
                             try {
                                 const result = await compaction.generate((signal) => operation((call) => coreExtensions.hooks.invoke('compact.generate', Object.freeze({
                                     operationId: call.operationId,
@@ -1026,15 +1041,33 @@ export function createSessionOpener(services) {
                                     messages: compactExtensionMessages(history),
                                     ...(focus === undefined ? {} : { focus }),
                                     summaryTokenBudget,
-                                    getPrompt: () => buildCompactionMessages('', highDensityCompaction)[1].content
+                                    getPrompt: () => buildCompactionMessages('', highDensityCompaction)[1].content,
+                                    reportDiagnostic: async (value) => {
+                                        if (!acceptsDiagnostics || ++diagnosticReports > 8)
+                                            return;
+                                        try {
+                                            const diagnostic = compactExtensionDiagnostic(value);
+                                            if (diagnostic)
+                                                await compaction.observeExtension(diagnostic);
+                                        }
+                                        catch {
+                                            // Diagnostic failures must not change compaction or fallback.
+                                        }
+                                    }
                                 }), Object.freeze({ ...call, signal }), async () => undefined)));
                                 compaction.signal.throwIfAborted();
-                                return compactExtensionResult(result, summaryTokenBudget);
+                                const handled = compactExtensionResult(result, summaryTokenBudget);
+                                await compaction.finishExtension(handled ? 'HANDLED' : result === undefined ? 'DECLINED' : 'INVALID_RESULT');
+                                return handled;
                             }
                             catch {
+                                await compaction.finishExtension('FAILED');
                                 compaction.signal.throwIfAborted();
                                 return undefined;
                             }
+                            finally {
+                                acceptsDiagnostics = false;
+                            }
                         };
                         let manualExtension;
                         if (mode === 'compact' && coreExtensions.hooks.hasInterceptors('compact.generate')) {
@@ -1099,7 +1132,7 @@ export function createSessionOpener(services) {
                                 return false;
                             let compactSummary = '';
                             const current = messages.at(-1);
-                            const retainCurrent = current.role === 'user' && current.contextKind !== 'environment';
+                            const retainCurrent = current.role === 'user' && current.contextKind === undefined;
                             const compactHistory = retainCurrent ? messages.slice(0, -1) : [...messages];
                             const appendBoundary = pendingAppends.length;
                             const compactSystemPrompt = await operation((call) => coreExtensions.compose(promptComposition(executionTools, 'run'), call));
@@ -1188,11 +1221,21 @@ export function createSessionOpener(services) {
                             if (!compactSummary)
                                 throw new MarAgentError('MAR_AGENT_COMPACT_FAILED', 'Automatic compact failed.');
                             rolloutBudget?.recordUsage(latestUsage);
-                            let replacementHistory = buildCompactedHistory(compactSummary, retainCurrent ? compactionUserMessages.slice(0, -1) : compactionUserMessages, compactUserTokenLimit, retainCurrent ? current.content : undefined);
+                            let replacementHistory = buildCompactedHistory(compactSummary, retainCurrent ? compactionUserMessages.slice(0, -1) : compactionUserMessages, compactUserTokenLimit, retainCurrent
+                                ? {
+                                    content: current.content,
+                                    ...(current.metadata ? { metadata: current.metadata } : {})
+                                }
+                                : undefined);
                             signal.throwIfAborted();
                             const compactRecord = await writeCompactionRecord(compactSummary, true, signal, async (actual, options) => {
                                 compactSummary = actual;
-                                replacementHistory = buildCompactedHistory(actual, retainCurrent ? compactionUserMessages.slice(0, -1) : compactionUserMessages, compactUserTokenLimit, retainCurrent ? current.content : undefined);
+                                replacementHistory = buildCompactedHistory(actual, retainCurrent ? compactionUserMessages.slice(0, -1) : compactionUserMessages, compactUserTokenLimit, retainCurrent
+                                    ? {
+                                        content: current.content,
+                                        ...(current.metadata ? { metadata: current.metadata } : {})
+                                    }
+                                    : undefined);
                                 const retainedModelContext = pendingAppends
                                     .slice(appendBoundary)
                                     .map((entry) => entry.message);
@@ -1218,18 +1261,12 @@ export function createSessionOpener(services) {
                             projectedExecutionBudgetStage = undefined;
                             recordedEnvironment = executionEnvironment;
                             compactionUserMessages = replacementHistory
-                                .filter((message) => message.kind === 'user_input')
-                                .map((message) => message.content);
-                            agentInstructionInsertIndex = Math.max(0, messages.length - 1);
-                            currentResourceSnapshot = retainedSessionResourcesSnapshot(await loadRetainedSessionResources());
-                            contextualWorldState = resetContextualWorldState(compactRecord.recordId, agentInstructionInsertIndex, {
-                                instructionSnapshot: currentInstructionSnapshot,
-                                instructionContent: renderAgentInstructions(instructionEntries, true),
-                                resourceSnapshot: currentResourceSnapshot,
-                                previousMayContainResources: compactSummary.includes('# Retained Session resources')
-                            });
-                            sessionRuntime.contextualWorldState = contextualWorldState;
-                            await persistContextualWorldState(store, sessionId, contextualWorldState);
+                                .filter((message) => message.kind !== 'summary')
+                                .map((message) => ({
+                                content: message.content,
+                                ...(message.metadata ? { metadata: { ...message.metadata } } : {})
+                            }));
+                            await resetCompactWorldState(compactRecord.recordId);
                             lastServerContextTokens = undefined;
                             lastServerUsage = undefined;
                             requestReasoningEffort = reasoningEffort;
@@ -1399,17 +1436,10 @@ export function createSessionOpener(services) {
                                         projectedExecutionBudgetStage = undefined;
                                         recordedEnvironment = refreshed.environmentState;
                                         compactionUserMessages = [...refreshed.userMessages];
-                                        agentInstructionInsertIndex =
-                                            refreshed.currentTurnUserIndex ?? Math.max(0, messages.length - 1);
-                                        if (agentInstructionInsertIndex &&
-                                            messages[agentInstructionInsertIndex - 1]?.contextKind === 'environment')
-                                            agentInstructionInsertIndex--;
-                                        currentResourceSnapshot = retainedSessionResourcesSnapshot(await loadRetainedSessionResources());
+                                        agentInstructionInsertIndex = contextualInstructionInsertIndex(messages);
                                         contextualWorldState = resetContextualWorldState(latestContextualWorldStateGeneration(committed.records), agentInstructionInsertIndex, {
                                             instructionSnapshot: currentInstructionSnapshot,
-                                            instructionContent: renderAgentInstructions(instructionEntries, committed.records.some((record) => compactSummaryFromCheckpoint(record) !== undefined)),
-                                            resourceSnapshot: currentResourceSnapshot,
-                                            previousMayContainResources: compactHistoryMayContainRetainedResources(committed.records)
+                                            instructionContent: renderAgentInstructions(instructionEntries, committed.records.some((record) => compactSummaryFromCheckpoint(record) !== undefined))
                                         });
                                         sessionRuntime.contextualWorldState = contextualWorldState;
                                         await persistContextualWorldState(store, sessionId, contextualWorldState);
@@ -1439,8 +1469,8 @@ export function createSessionOpener(services) {
                             manualCompaction.signal.throwIfAborted();
                             await manualCompaction.dispose();
                         }
-                        if (mode === 'compact')
-                            await writeCompactionRecord(compactSummary, false, compactSignal, async (actual, options) => {
+                        if (mode === 'compact') {
+                            const compactRecord = await writeCompactionRecord(compactSummary, false, compactSignal, async (actual, options) => {
                                 const retainedModelContext = pendingAppends
                                     .slice(manualAppendBoundary)
                                     .map((entry) => entry.message);
@@ -1460,6 +1490,8 @@ export function createSessionOpener(services) {
                                 selected.resetContinuation?.();
                                 return record;
                             });
+                            await resetCompactWorldState(compactRecord.recordId);
+                        }
                         if (mode === 'compact' && manualCompactionId !== undefined)
                             await emit({ type: 'context.compacted', compactionId: manualCompactionId });
                     };
@@ -1861,6 +1893,7 @@ function projectAppendedModelMessage(input) {
         return undefined;
     return {
         role: 'user',
+        contextKind: 'contextual',
         content: input.content,
         ...(input.textBlocks === undefined
             ? {}

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

@@ -222,16 +222,27 @@ export function parseContextGcExecResult(value) {
                 parsed.status !== 'completed' &&
                 parsed.status !== 'cancelled') ||
             typeof parsed.stdout !== 'string' ||
-            typeof parsed.stderr !== 'string')
+            (parsed.stderr !== undefined && typeof parsed.stderr !== 'string') ||
+            (parsed.truncated === true &&
+                (parsed.stdoutBytes === undefined || parsed.stderrBytes === undefined)))
             return undefined;
-        const metadata = parseContextGcExecMetadata(parsed);
+        const stderr = parsed.stderr === undefined ? '' : parsed.stderr;
+        // Native exec bodies omit only empty/default fields and exactly derivable byte counts.
+        const defaults = {
+            truncated: false,
+            stdoutBytes: Buffer.byteLength(parsed.stdout),
+            stderrBytes: Buffer.byteLength(stderr),
+            stdoutDroppedBytes: 0,
+            stderrDroppedBytes: 0
+        };
+        const metadata = parseContextGcExecMetadata({ ...defaults, ...parsed });
         return metadata
             ? {
                 source: 'STRUCTURED',
                 ...metadata,
                 status: parsed.status,
                 stdout: parsed.stdout,
-                stderr: parsed.stderr
+                stderr
             }
             : undefined;
     }

package/dist/agent-core/session/jsonl-store.d.ts

@@ -1,5 +1,5 @@
 import { type CoreCheckpoint, type CoreJsonValue } from '../extensions/data.js';
-import type { ModelMessage, ModelUsage } from '../model/contracts.js';
+import type { ModelInputMetadata, ModelMessage, ModelUsage } from '../model/contracts.js';
 import type { EnvironmentContextState } from '../runtime/context/contracts.js';
 import { type CodeModeStateEntry } from '../tools/code-mode/state.js';
 import { type TodoSnapshot } from '../tools/agent/todo.js';
@@ -29,10 +29,13 @@ export interface SessionExecutionState {
     todo: TodoSnapshot;
     contextRecords: SessionRecord[];
 }
-export interface CompactHistoryMessage {
-    role: 'user';
+export interface CompactUserInput {
     content: string;
-    kind: 'user_input' | 'summary';
+    metadata?: ModelInputMetadata;
+}
+export interface CompactHistoryMessage extends CompactUserInput {
+    role: 'user';
+    kind: 'user_input' | 'extension_input' | 'summary';
 }
 export interface SessionInputImage {
     readonly name: string;
@@ -247,3 +250,5 @@ export declare class JsonlSessionStore {
 }
 export declare function compactSummaryFromCheckpoint(record: SessionRecord | undefined): string | undefined;
 export declare function replacementHistoryFromCheckpoint(record: SessionRecord): CompactHistoryMessage[] | undefined;
+export declare function parseModelInputMetadata(value: unknown): ModelInputMetadata | undefined;
+export declare function inputMetadataFromRecord(record: SessionRecord): ModelInputMetadata;

package/dist/agent-core/session/jsonl-store.js

@@ -2455,11 +2455,58 @@ export function replacementHistoryFromCheckpoint(record) {
             typeof message === 'object' &&
             message.role === 'user' &&
             typeof message.content === 'string' &&
+            (message.metadata === undefined ||
+                (parseModelInputMetadata(message.metadata) !== undefined &&
+                    (message.kind === 'extension_input'
+                        ? message.metadata.source === 'extension'
+                        : message.kind === 'user_input' && message.metadata.source !== 'extension'))) &&
             (message.kind === 'user_input' ||
+                message.kind === 'extension_input' ||
                 (message.kind === 'summary' && message.content.trim().length > 0))) ||
         history.filter((message) => message.kind === 'summary').length !== 1)
         return undefined;
-    return history.map(({ role, content, kind }) => ({ role, content, kind }));
+    return history.map(({ role, content, kind, metadata }) => ({
+        role,
+        content,
+        kind,
+        ...(parseModelInputMetadata(metadata) === undefined
+            ? {}
+            : { metadata: parseModelInputMetadata(metadata) })
+    }));
+}
+export function parseModelInputMetadata(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const metadata = value;
+    if (metadata.source !== 'user' &&
+        metadata.source !== 'parent_agent' &&
+        metadata.source !== 'extension')
+        return undefined;
+    return {
+        source: metadata.source,
+        ...(typeof metadata.recordId === 'string' && metadata.recordId.length <= 128
+            ? { recordId: metadata.recordId }
+            : {}),
+        ...(typeof metadata.extensionId === 'string' && metadata.extensionId.length <= 128
+            ? { extensionId: metadata.extensionId }
+            : {}),
+        ...(metadata.truncated === true ? { truncated: true } : {})
+    };
+}
+export function inputMetadataFromRecord(record) {
+    const payload = record.payload;
+    const source = payload.source;
+    return {
+        source: record.type === 'extension.input' || payload.inputSource === 'extension'
+            ? 'extension'
+            : payload.inputSource === 'parent_agent'
+                ? 'parent_agent'
+                : 'user',
+        recordId: record.recordId,
+        ...(typeof source?.extensionId === 'string' && source.extensionId.length <= 128
+            ? { extensionId: source.extensionId }
+            : {})
+    };
 }
 function isCompactCheckpoint(record) {
     return compactSummaryFromCheckpoint(record) !== undefined;

package/dist/agent-core/tools/code-mode/observations.js

@@ -145,17 +145,35 @@ export function newObservationId() {
     return randomUUID();
 }
 export function observationModelParts(message) {
-    if (message.textBlocks !== undefined || !message.observations?.length)
+    if (message.textBlocks !== undefined || message.observations === undefined)
         return undefined;
     const prefix = [];
     try {
         const parsed = JSON.parse(message.content ?? '');
         if (parsed && !Array.isArray(parsed) && typeof parsed === 'object') {
             const { observations: _observations, ...metadata } = parsed;
+            const cellEnvelope = typeof metadata.cellId === 'string' &&
+                typeof metadata.status === 'string' &&
+                Array.isArray(_observations);
+            if (!message.observations.length && !cellEnvelope)
+                return undefined;
+            if (cellEnvelope) {
+                // Keep execution facts in storage; project only actionable lifecycle metadata.
+                delete metadata.toolCalls;
+                delete metadata.outputBytes;
+                if (metadata.outputDroppedBytes === 0)
+                    delete metadata.outputDroppedBytes;
+                if (metadata.truncated === false)
+                    delete metadata.truncated;
+                if (metadata.cached === false)
+                    delete metadata.cached;
+            }
             prefix.push({ type: 'text', text: JSON.stringify(metadata) });
         }
     }
     catch { }
+    if (!message.observations.length && !prefix.length)
+        return undefined;
     return [
         ...prefix,
         ...message.observations.flatMap((value) => {

package/dist/agent-core/tools/local/exec.d.ts

@@ -1,10 +1,12 @@
 import { type LocalProcessExecutor } from '../../host/local-process-executor.js';
 import type { ClientToolDefinition } from '../../model/contracts.js';
-import type { ExecResult } from '../contracts.js';
+import type { ExecResult, ToolExecutionResult } from '../contracts.js';
 import { WorkspacePathResolver } from '../shared/path-resolver.js';
 import { type CoreProcessInput, type CoreProcessHandle } from '../../extensions/processes.js';
 import type { CoreOperationContext } from '../../extensions/operation.js';
 export type { ExecResult } from '../contracts.js';
+/** Share the model-facing body across direct calls and original Code Mode observations. */
+export declare function formatExecResult(result: ExecResult): ToolExecutionResult;
 export type ExecInput = {
     action?: 'start';
     command: string;

package/dist/agent-core/tools/local/exec.js

@@ -4,6 +4,27 @@ import { MarAgentError } from '../../error.js';
 import { directLocalProcessExecutor, signalProcessTree } from '../../host/local-process-executor.js';
 import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
 import { validateCoreProcessInput } from '../../extensions/processes.js';
+/** Share the model-facing body across direct calls and original Code Mode observations. */
+export function formatExecResult(result) {
+    const visible = { ...result };
+    if (result.stderr === '')
+        delete visible.stderr;
+    if (!result.truncated) {
+        delete visible.truncated;
+        // Incremental output may be smaller than the cumulative stream counts.
+        if (result.stdoutBytes === Buffer.byteLength(result.stdout))
+            delete visible.stdoutBytes;
+        if (result.stderrBytes === Buffer.byteLength(result.stderr))
+            delete visible.stderrBytes;
+    }
+    if (result.stdoutDroppedBytes === 0)
+        delete visible.stdoutDroppedBytes;
+    if (result.stderrDroppedBytes === 0)
+        delete visible.stderrDroppedBytes;
+    if (result.cached === false)
+        delete visible.cached;
+    return { content: JSON.stringify(visible), data: result, truncated: result.truncated };
+}
 export const execToolDefinition = {
     name: 'exec',
     allowedCallers: ['direct', 'programmatic'],

package/dist/agent-core/tools/local/registry.js

@@ -3,7 +3,7 @@ import { LocalFileAccess } from '../../host/local-file-access.js';
 import { ApplyPatchTool, applyPatchToolInput, applyPatchToolDefinition } from './apply-patch.js';
 import { CodeModeTool, codeModeToolDefinition, codeExecWaitToolDefinition } from '../code-mode/index.js';
 import { normalizeToolInput } from '../input.js';
-import { ExecTool, execToolInput, execToolDefinition, execWaitToolDefinition } from './exec.js';
+import { ExecTool, execToolInput, execToolDefinition, execWaitToolDefinition, formatExecResult } from './exec.js';
 import { ReadTool, formatBatchReadOutput, readToolDefinition } from './read.js';
 import { WorkspacePathResolver } from '../shared/path-resolver.js';
 import { ViewImageTool, viewImageToolDefinition } from './view-image.js';
@@ -91,7 +91,7 @@ export class LocalToolRegistry {
                                     : { ownerInstanceId: context.operation.ownerInstanceId })
                             })
                     });
-                    return { content: JSON.stringify(result), data: result, truncated: result.truncated };
+                    return formatExecResult(result);
                 }
             ])
         ]);

package/dist/index.d.ts

@@ -13,7 +13,7 @@ export type { CoreAgentExtensionContext, CoreSessionExtensionContext, CoreRuntim
 export type { CoreDisposer, CoreResourceRegistration, CoreResourceScope } from './agent-core/extensions/resources.js';
 export type { CoreHookOptions, CoreInterceptor } from './agent-core/extensions/hooks.js';
 export type { CoreOperationContext } from './agent-core/extensions/operation.js';
-export type { CoreCompactContext, CoreCompactMessage, CoreCompactResult } from './agent-core/extensions/compaction.js';
+export type { CoreCompactContext, CoreCompactDiagnostic, CoreCompactMessage, CoreCompactResult } from './agent-core/extensions/compaction.js';
 export { buildCompactionInput as buildCompactEvidence } from './agent-core/runtime/compaction/history.js';
 export { countModelTokens } from './agent-core/runtime/token-budget.js';
 export type { CoreServiceKey, CoreServiceRegistry } from './agent-core/extensions/services.js';

package/dist/shared/model-text.d.ts

@@ -1,5 +1,5 @@
 import { type MarAgentModelConfiguration, type MarAgentReasoningEffort } from '../agent-core/model/configuration.js';
-import type { ModelUsage } from '../agent-core/model/contracts.js';
+import type { ModelAttemptDiagnostic, ModelUsage } from '../agent-core/model/contracts.js';
 import type { CoreCompactMessage } from '../agent-core/extensions/compaction.js';
 export interface GenerateModelTextInput {
     readonly model: MarAgentModelConfiguration;
@@ -8,6 +8,7 @@ export interface GenerateModelTextInput {
     readonly reasoningEffort?: MarAgentReasoningEffort;
     readonly outputLimit?: number;
     readonly signal: AbortSignal;
+    readonly onAttemptDiagnostic?: (diagnostic: ModelAttemptDiagnostic) => Promise<void> | void;
 }
 /** One tool-free request using the SDK transports. Credential providers remain caller-owned. */
 export declare function generateModelText(input: GenerateModelTextInput): Promise<{

package/dist/shared/model-text.js

@@ -22,6 +22,7 @@ export async function generateModelText(input) {
             allowTools: false,
             toolChoice: 'none',
             reasoningEffort: input.reasoningEffort ?? resolveModelDefaultReasoningEffort(input.model),
+            ...(input.onAttemptDiagnostic ? { onAttemptDiagnostic: input.onAttemptDiagnostic } : {}),
             ...(input.outputLimit === undefined ? {} : { outputLimit: input.outputLimit })
         }, input.signal)) {
             input.signal.throwIfAborted();

package/package.json

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