@myagentroam/agent 0.9.171 → 0.9.173

package/dist/agent-core/extensions/compaction.d.ts

@@ -1,4 +1,16 @@
 import type { ModelMessage, ModelUsage } from '../model/contracts.js';
+export interface CoreCompactDiagnostic {
+    readonly modelId: string;
+    readonly providerModelId?: string;
+    readonly reasoningEffort: string;
+    readonly state: 'STARTED' | 'SUCCEEDED' | 'DECLINED' | 'FAILED';
+    readonly inputTokensEstimateBefore: number;
+    readonly inputTokensEstimateAfter: number;
+    readonly modelRequests: number;
+    readonly elapsedMs: number;
+    readonly reason?: 'INPUT_BUDGET_EXHAUSTED' | 'MODEL_INCOMPLETE' | 'MODEL_FAILED';
+    readonly errorCode?: string;
+}
 export interface CoreCompactMessage {
     readonly role: 'user' | 'assistant' | 'tool' | 'tool_call';
     readonly content: string;
@@ -14,6 +26,8 @@ export interface CoreCompactContext {
     readonly summaryTokenBudget: number;
     /** Return the Core compaction contract selected for this operation's main model snapshot. */
     readonly getPrompt: () => string;
+    /** Private, bounded telemetry only; reporting never changes the generation result. */
+    readonly reportDiagnostic?: (diagnostic: CoreCompactDiagnostic) => Promise<void>;
 }
 export interface CoreCompactResult {
     readonly summary: string;
@@ -21,5 +35,7 @@ export interface CoreCompactResult {
 }
 /** Copy only neutral evidence; a hook never receives provider payloads or history ownership. */
 export declare function compactExtensionMessages(messages: readonly ModelMessage[]): readonly CoreCompactMessage[];
+/** Whitelist scalar facts; never copy arbitrary plugin payloads into the session log. */
+export declare function compactExtensionDiagnostic(value: unknown): CoreCompactDiagnostic | undefined;
 /** Invalid plugin results decline generation rather than altering the checkpoint contract. */
 export declare function compactExtensionResult(value: unknown, budget: number): CoreCompactResult | undefined;

package/dist/agent-core/extensions/compaction.js

@@ -2,7 +2,8 @@ import { countModelTokens } from '../runtime/token-budget.js';
 /** Copy only neutral evidence; a hook never receives provider payloads or history ownership. */
 export function compactExtensionMessages(messages) {
     return freeze(messages
-        .filter((message) => message.role !== 'provider' && message.contextKind === undefined)
+        .filter((message) => message.role !== 'provider' &&
+        !['environment', 'private', 'compact_control'].includes(message.contextKind ?? ''))
         .map((message) => ({
         role: message.role,
         content: message.content,
@@ -23,6 +24,46 @@ const usageKeys = new Set([
     'hostedSearches',
     'hostedFetches'
 ]);
+/** Whitelist scalar facts; never copy arbitrary plugin payloads into the session log. */
+export function compactExtensionDiagnostic(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const input = value;
+    const label = (value, limit) => typeof value === 'string' &&
+        value.length > 0 &&
+        value.length <= limit &&
+        !/[\r\n]/u.test(value);
+    if (!label(input.modelId, 128) ||
+        !label(input.reasoningEffort, 32) ||
+        typeof input.state !== 'string' ||
+        !['STARTED', 'SUCCEEDED', 'DECLINED', 'FAILED'].includes(input.state))
+        return undefined;
+    for (const key of [
+        'inputTokensEstimateBefore',
+        'inputTokensEstimateAfter',
+        'modelRequests',
+        'elapsedMs'
+    ])
+        if (typeof input[key] !== 'number' || !Number.isSafeInteger(input[key]) || input[key] < 0)
+            return undefined;
+    return {
+        modelId: input.modelId,
+        reasoningEffort: input.reasoningEffort,
+        state: input.state,
+        inputTokensEstimateBefore: input.inputTokensEstimateBefore,
+        inputTokensEstimateAfter: input.inputTokensEstimateAfter,
+        modelRequests: input.modelRequests,
+        elapsedMs: input.elapsedMs,
+        ...(label(input.providerModelId, 256) ? { providerModelId: input.providerModelId } : {}),
+        ...(typeof input.reason === 'string' &&
+            ['INPUT_BUDGET_EXHAUSTED', 'MODEL_INCOMPLETE', 'MODEL_FAILED'].includes(input.reason)
+            ? { reason: input.reason }
+            : {}),
+        ...(typeof input.errorCode === 'string' && /^[A-Z][A-Z0-9_]{0,127}$/u.test(input.errorCode)
+            ? { errorCode: input.errorCode }
+            : {})
+    };
+}
 /** Invalid plugin results decline generation rather than altering the checkpoint contract. */
 export function compactExtensionResult(value, budget) {
     if (value === null ||

package/dist/agent-core/model/anthropic-messages.js

@@ -3,9 +3,10 @@ import { randomUUID } from 'node:crypto';
 import { MarAgentError } from '../error.js';
 import { resolveModelDefaultReasoningEffort } from './configuration.js';
 import { isRetryableUpstreamOverloadCode, number, parseSse, record, text, observeModelStreamEvent, modelStreamEventObservedAt } from './sse.js';
-import { fetchModelResponse, modelRetryMaxAttempts, isRetryableModelRequestError, isRetryableModelTransportError, waitForModelRetry } from './http.js';
+import { fetchModelResponse, modelRetryMaxAttempts, isRetryableModelRequestError, isRetryableModelTransportError, modelRetryDelay, waitForModelRetry } from './http.js';
 import { anthropicThinkingBlock, assertAnthropicThinkingBudget } from './anthropic-thinking.js';
 import { resolveModelTextBlocks } from './text-blocks.js';
+import { reportModelAttempt } from './attempt-diagnostics.js';
 export class AnthropicMessagesAdapter {
     configuration;
     constructor(configuration) {
@@ -16,13 +17,25 @@ export class AnthropicMessagesAdapter {
         const maxAttempts = modelRetryMaxAttempts(retryState);
         let resetOutputTiming = false;
         while (retryState.attempts < maxAttempts) {
+            signal.throwIfAborted();
             if (resetOutputTiming)
                 yield { type: 'output.reset' };
             resetOutputTiming = false;
             const attempt = retryState.attempts++;
+            const startedAt = Date.now();
+            const attemptDiagnostic = {
+                protocol: 'ANTHROPIC_MESSAGES',
+                transport: 'HTTP',
+                attempt: attempt + 1,
+                maxAttempts,
+                continuation: false,
+                credentialReason: 'REQUEST'
+            };
             // Buffer non-semantic events until a semantic event makes this attempt non-retryable.
             const prelude = [];
             let sawSemanticEvent = false;
+            let firstSemanticEventType;
+            await reportModelAttempt(request, { ...attemptDiagnostic, state: 'STARTED' });
             try {
                 for await (const event of this.startAttempt(request, signal)) {
                     if (event.type === 'output.delta') {
@@ -36,21 +49,42 @@ export class AnthropicMessagesAdapter {
                     }
                     if (!sawSemanticEvent) {
                         sawSemanticEvent = true;
+                        firstSemanticEventType = event.type;
                         for (const pending of prelude)
                             yield pending;
                         prelude.length = 0;
                     }
                     yield event;
                 }
+                await reportModelAttempt(request, {
+                    ...attemptDiagnostic,
+                    state: 'SUCCEEDED',
+                    semanticEventObserved: sawSemanticEvent,
+                    ...(firstSemanticEventType === undefined ? {} : { firstSemanticEventType }),
+                    durationMs: Math.max(0, Date.now() - startedAt)
+                });
                 return;
             }
             catch (error) {
-                if (signal.aborted ||
-                    sawSemanticEvent ||
-                    !(isRetryableModelRequestError(error) || isAnthropicRecoverableStreamError(error)) ||
-                    attempt + 1 >= maxAttempts)
+                const retryable = isRetryableModelRequestError(error) || isAnthropicRecoverableStreamError(error);
+                const willRetry = !signal.aborted && !sawSemanticEvent && retryable && attempt + 1 < maxAttempts;
+                const delayMs = willRetry ? modelRetryDelay(retryAfter(error), attempt) : undefined;
+                await reportModelAttempt(request, {
+                    ...attemptDiagnostic,
+                    state: 'FAILED',
+                    semanticEventObserved: sawSemanticEvent,
+                    ...(firstSemanticEventType === undefined ? {} : { firstSemanticEventType }),
+                    durationMs: Math.max(0, Date.now() - startedAt),
+                    errorCode: error instanceof MarAgentError ? error.code : 'MAR_AGENT_MODEL_ATTEMPT_FAILED',
+                    retryable,
+                    willRetry,
+                    ...(delayMs === undefined
+                        ? {}
+                        : { retryDelayMs: delayMs, retryReason: 'STREAM' })
+                });
+                if (!willRetry)
                     throw error;
-                await waitForModelRetry(retryAfter(error), attempt, signal);
+                await waitForModelRetry(retryAfter(error), attempt, signal, delayMs);
             }
         }
     }

package/dist/agent-core/model/attempt-diagnostics.d.ts

@@ -0,0 +1,3 @@
+import type { ModelAttemptDiagnostic, ModelRequest } from './contracts.js';
+/** One observer boundary for all adapters; telemetry cannot change request outcomes. */
+export declare function reportModelAttempt(request: ModelRequest, diagnostic: ModelAttemptDiagnostic): Promise<void>;

package/dist/agent-core/model/attempt-diagnostics.js

@@ -0,0 +1,9 @@
+/** One observer boundary for all adapters; telemetry cannot change request outcomes. */
+export async function reportModelAttempt(request, diagnostic) {
+    try {
+        await request.onAttemptDiagnostic?.(diagnostic);
+    }
+    catch {
+        // Diagnostics must never change the model request result.
+    }
+}

package/dist/agent-core/model/contracts.d.ts

@@ -5,6 +5,12 @@ export interface ModelTextBlock {
     readonly text: string;
     readonly cache?: true;
 }
+export interface ModelInputMetadata {
+    source: 'user' | 'parent_agent' | 'extension';
+    recordId?: string;
+    extensionId?: string;
+    truncated?: true;
+}
 export interface ModelMessage {
     /** Model-facing tool-result status; independent of the actual execution outcome. */
     isError?: boolean;
@@ -12,7 +18,9 @@ export interface ModelMessage {
     role: 'user' | 'assistant' | 'tool' | 'tool_call' | 'provider';
     content: string;
     textBlocks?: readonly ModelTextBlock[];
-    contextKind?: 'environment' | 'private';
+    contextKind?: 'environment' | 'private' | 'contextual' | 'summary' | 'compact_control';
+    /** Input provenance and local truncation state; never serialized to a Provider. */
+    metadata?: ModelInputMetadata;
     callId?: string;
     name?: string;
     arguments?: unknown;

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

@@ -8,6 +8,7 @@ import { isRetryableUpstreamOverloadCode, number, parseSse, record, text, observ
 import { connectSocks5Target, fetchModelResponse, isRetryableModelHttpStatus, isRetryableModelTransportError, modelRetryMaxAttempts, isRetryableModelRequestError, modelRetryDelay, waitForModelRetry } from './http.js';
 import { acquireModelCredential, appendModelCredentialHeaders } from './runtime-credential.js';
 import { resolveModelTextBlocks } from './text-blocks.js';
+import { reportModelAttempt } from './attempt-diagnostics.js';
 const WEBSOCKET_IDLE_TIMEOUT_MS = 300_000;
 const WEBSOCKET_SEND_FRAME_BYTES = 1024 * 1024;
 export const OPENAI_RESPONSES_EARLY_EOF_REASON = 'OPENAI_RESPONSES_EARLY_EOF';
@@ -92,7 +93,7 @@ export class OpenAiResponsesAdapter {
             let sawSemanticEvent = false;
             let firstSemanticEventType;
             turn.beginAttempt();
-            await reportOpenAiResponsesAttempt(request, {
+            await reportModelAttempt(request, {
                 protocol: 'OPENAI_RESPONSES',
                 transport: attemptTransport,
                 state: 'STARTED',
@@ -121,7 +122,7 @@ export class OpenAiResponsesAdapter {
                     }
                     yield event;
                 }
-                await reportOpenAiResponsesAttempt(request, {
+                await reportModelAttempt(request, {
                     protocol: 'OPENAI_RESPONSES',
                     transport: attemptTransport,
                     state: 'SUCCEEDED',
@@ -137,7 +138,7 @@ export class OpenAiResponsesAdapter {
                 return;
             }
             catch (error) {
-                const reportFailure = async (willRetry, options = {}) => reportOpenAiResponsesAttempt(request, {
+                const reportFailure = async (willRetry, options = {}) => reportModelAttempt(request, {
                     protocol: 'OPENAI_RESPONSES',
                     transport: attemptTransport,
                     state: 'FAILED',
@@ -1437,14 +1438,6 @@ function retryAfter(error) {
     const value = error.details?.retryAfter;
     return typeof value === 'string' ? value : null;
 }
-async function reportOpenAiResponsesAttempt(request, diagnostic) {
-    try {
-        await request.onAttemptDiagnostic?.(diagnostic);
-    }
-    catch {
-        // Diagnostics must never change the model request result.
-    }
-}
 function openAiResponsesAttemptError(error) {
     const diagnostic = describeMarAgentError(error, 'MAR_AGENT_MODEL_ATTEMPT_FAILED');
     const causeCode = deepestCauseCode(error);

package/dist/agent-core/prompts/resources.d.ts

@@ -14,4 +14,3 @@ export interface RetainedSessionResources {
     }[];
 }
 export declare function retainedSessionResourcesSnapshot(input: RetainedSessionResources): string | undefined;
-export declare function retainedSessionResourcesUpdate(snapshot: string | undefined, previousSnapshot: string | undefined, previousMayContainResources?: boolean): string | undefined;

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

@@ -1,3 +1,4 @@
+import { truncateModelText } from '../runtime/token-budget.js';
 export function retainedSessionResourcesSnapshot(input) {
     if (input.processes.length === 0 && input.subagents.length === 0 && !input.codeCells?.length)
         return undefined;
@@ -9,7 +10,7 @@ export function retainedSessionResourcesSnapshot(input) {
         ...(input.codeCells?.length
             ? [
                 'Code Exec cells: use direct code_exec_wait with the retained cellId for ongoing work or needed output; cancelling a wait does not terminate the cell.',
-                ...input.codeCells.map((cell) => `- cellId: ${cell.cellId}; status: ${cell.status}; executionId: ${cell.executionId}`)
+                ...input.codeCells.map((cell) => `- cellId: ${cell.cellId}; status: ${cell.status}`)
             ]
             : []),
         processes.length === 0
@@ -25,26 +26,15 @@ export function retainedSessionResourcesSnapshot(input) {
             ? ''
             : [
                 'Managed processes:',
-                ...processes.map((process) => `- processId: ${process.processId}; status: ${process.status}; cwd: ${process.cwd}; command: ${process.command}`)
+                ...processes.map((process) => `- processId: ${process.processId}; status: ${process.status}; cwd: ${truncateModelText(process.cwd, 64, 'resource cwd').content}; command: ${truncateModelText(process.command, 128, 'resource command').content}`)
             ].join('\n'),
         subagents.length === 0
             ? ''
             : [
                 'Subagents:',
-                ...subagents.map((task) => `- agentId: ${task.agentId}; status: ${task.status}; description: ${task.description}`)
+                ...subagents.map((task) => `- agentId: ${task.agentId}; status: ${task.status}; description: ${truncateModelText(task.description, 96, 'resource description').content}`)
             ].join('\n')
     ]
         .filter(Boolean)
         .join('\n');
 }
-export function retainedSessionResourcesUpdate(snapshot, previousSnapshot, previousMayContainResources = false) {
-    if (!previousMayContainResources && snapshot === previousSnapshot)
-        return undefined;
-    if (!snapshot)
-        return previousSnapshot || previousMayContainResources
-            ? 'The previously provided retained Session resources no longer apply. No retained processes, code cells or subagents remain. Historical resource IDs are not live handles; do not poll or wait on them. Use already recorded results or saved artifacts to recover completed work before starting anything again.'
-            : undefined;
-    return previousSnapshot || previousMayContainResources
-        ? `This replaces all previously provided retained Session resources.\n\n${snapshot}`
-        : snapshot;
-}

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

@@ -1,5 +1,5 @@
 import type { ModelMessage } from '../../model/contracts.js';
-import type { CompactHistoryMessage } from '../../session/jsonl-store.js';
+import type { CompactHistoryMessage, CompactUserInput } from '../../session/jsonl-store.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;
@@ -11,6 +11,7 @@ export declare function buildCompactionInput(messages: readonly ModelMessage[],
     maxTokens: number;
 }): string;
 export declare function retainCompactionUserMessages(messages: readonly string[], maxTokens: number): string[];
-export declare function buildCompactedHistory(summary: string, userMessages: readonly string[], maxUserTokens: number, currentUserMessage?: string): CompactHistoryMessage[];
+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/history.js

@@ -16,15 +16,17 @@ export function buildNativeCompactionMessages(messages, input = {}) {
         }),
         {
             role: 'user',
+            contextKind: 'compact_control',
             content: focus ? `Compaction focus: ${focus}\n\n${contract}` : contract
         }
     ];
 }
 export function buildCompactionMessages(evidence, highDensityCompaction = false) {
     return [
-        { role: 'user', content: evidence },
+        { role: 'user', content: evidence, contextKind: 'contextual' },
         {
             role: 'user',
+            contextKind: 'compact_control',
             content: highDensityCompaction ? highDensityCompactionPrompt() : compactionPrompt()
         }
     ];
@@ -37,7 +39,7 @@ export function buildCompactionInput(messages, input) {
         !(message.role === 'provider' && message.provider === 'ANTHROPIC_MESSAGES'))
         .map((message, index) => ({
         index,
-        user: message.role === 'user',
+        user: message.role === 'user' && message.contextKind === undefined,
         text: renderMessage(message)
     }));
     const header = `Compaction focus: ${focus}\n\nConversation evidence (chronological):\n`;
@@ -104,15 +106,26 @@ export function retainCompactionUserMessages(messages, maxTokens) {
     const selected = [];
     for (let index = messages.length - 1; index >= 0 && remaining > 0; index--) {
         const message = messages[index];
-        const tokens = countModelTokens(message) + 8;
+        const content = typeof message === 'string' ? message : message.content;
+        const tokens = countModelTokens(content) + 8;
         if (tokens <= remaining) {
             selected.push(message);
             remaining -= tokens;
         }
         else {
-            const truncated = truncateModelText(message, Math.max(0, remaining - 8), 'user input');
+            const truncated = truncateModelText(content, Math.max(0, remaining - 8), 'user input');
             if (truncated.content)
-                selected.push(truncated.content);
+                selected.push(typeof message === 'string'
+                    ? truncated.content
+                    : {
+                        ...message,
+                        content: truncated.content,
+                        metadata: {
+                            source: message.metadata?.source ?? 'user',
+                            ...message.metadata,
+                            truncated: true
+                        }
+                    });
             break;
         }
     }
@@ -120,19 +133,36 @@ export function retainCompactionUserMessages(messages, maxTokens) {
 }
 export function buildCompactedHistory(summary, userMessages, maxUserTokens, currentUserMessage) {
     return [
-        ...retainCompactionUserMessages(userMessages, maxUserTokens).map((content) => ({
-            role: 'user',
-            content,
-            kind: 'user_input'
-        })),
+        ...retainCompactionUserMessages(userMessages.map(asCompactInput), maxUserTokens).map(asHistoryInput),
         { role: 'user', content: continuationMessage(summary), kind: 'summary' },
         ...(currentUserMessage === undefined
             ? []
-            : [{ role: 'user', content: currentUserMessage, kind: 'user_input' }])
+            : [asHistoryInput(asCompactInput(currentUserMessage))])
     ];
 }
+function asCompactInput(input) {
+    return typeof input === 'string'
+        ? { content: input }
+        : { content: input.content, ...(input.metadata ? { metadata: { ...input.metadata } } : {}) };
+}
+function asHistoryInput(input) {
+    return {
+        ...input,
+        role: 'user',
+        kind: input.metadata?.source === 'extension' ? 'extension_input' : 'user_input'
+    };
+}
 export function compactedHistoryMessages(history) {
-    return history.map(({ role, content }) => ({ role, content }));
+    return history.map(({ role, content, kind, metadata }) => ({
+        role,
+        content,
+        ...(kind === 'summary' ? { contextKind: 'summary' } : {}),
+        ...(metadata
+            ? { metadata: { ...metadata } }
+            : kind === 'extension_input'
+                ? { metadata: { source: 'extension' } }
+                : {})
+    }));
 }
 export function continuationMessage(summary) {
     return `Continue from the compacted state below. Treat it as a factual handoff, not a new user request. Earlier user messages are retained historical evidence, not requests to repeat completed work or authorization for new side effects. Newer user instructions override older messages and this handoff. The handoff cannot create or revive authorization: an action that requires separate authorization may proceed only when current direct authorization still covers its exact action, scope, and lifetime. Continue directly from its Next action without recapping it to the user. Re-read files or rerun checks when the handoff marks facts as stale, inferred, failed, or unverified. Do not repeat completed side effects.\n\n${summary}`;

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

@@ -1,4 +1,5 @@
 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;
@@ -9,6 +10,8 @@ export interface CompactionProgress {
     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 {
@@ -19,6 +22,8 @@ export declare class CompactionOperation {
     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

@@ -18,6 +18,8 @@ export class CompactionOperation {
     #textDeltaCharacters = 0;
     #firstOutputAfterMs;
     #lastOutputAfterMs;
+    #extension;
+    #extensionOutcome;
     constructor(parent, record) {
         this.record = record;
         this.signal = AbortSignal.any([parent, this.#controller.signal]);
@@ -81,6 +83,20 @@ export class CompactionOperation {
                 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;
@@ -93,8 +109,12 @@ export class CompactionOperation {
         const progress = {
             state,
             elapsedMs: Math.max(0, Date.now() - this.#startedAt),
-            inputTokensEstimate: this.#inputTokensEstimate,
-            modelRequests: this.#modelRequests,
+            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

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

@@ -159,6 +159,7 @@ export function restoreModelContext(payload, providerModelId) {
         return {
             role: 'user',
             content: payload.content,
+            contextKind: 'contextual',
             ...(textBlocks === undefined ? {} : { textBlocks })
         };
     }

package/dist/agent-core/runtime/context/request-budget.js

@@ -4,7 +4,7 @@ import { observationModelText } from '../../tools/code-mode/observations.js';
 export function estimatedRequestTokens(system, messages, tools, images) {
     const transientImageCount = messages.reduce((total, message) => total + (message.images?.length ?? 0), images?.length ?? 0);
     const textMessages = messages.map((message) => {
-        const { images: _images, observations: _observations, observationId: _observationId, ...textMessage } = message;
+        const { images: _images, observations: _observations, observationId: _observationId, metadata: _metadata, contextKind: _contextKind, ...textMessage } = message;
         const content = message.role === 'tool' ? observationModelText(message) : undefined;
         if (content !== undefined)
             textMessage.content = content;

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

@@ -1,5 +1,5 @@
 import type { ModelMessage } from '../../model/contracts.js';
-import { type JsonlSessionStore } from '../../session/jsonl-store.js';
+import { type CompactUserInput, type JsonlSessionStore } from '../../session/jsonl-store.js';
 import type { EnvironmentContextState } from './contracts.js';
 import { type ContextProjection } from './projection.js';
 export declare function restoreMessages(store: JsonlSessionStore, sessionId: string, records: readonly import('../../session/jsonl-store.js').SessionRecord[], options: {
@@ -13,7 +13,7 @@ export declare function restoreMessages(store: JsonlSessionStore, sessionId: str
         result?: unknown;
     }>;
     environmentState: EnvironmentContextState | undefined;
-    userMessages: string[];
+    userMessages: CompactUserInput[];
     messages: ModelMessage[];
     ignoredImages: number;
     currentTurnUserIndex: number | undefined;

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

@@ -1,5 +1,5 @@
 import { MarAgentError } from '../../error.js';
-import { compactSummaryFromCheckpoint, replacementHistoryFromCheckpoint } from '../../session/jsonl-store.js';
+import { compactSummaryFromCheckpoint, replacementHistoryFromCheckpoint, inputMetadataFromRecord } from '../../session/jsonl-store.js';
 import { compactedHistoryMessages, continuationMessage } from '../compaction/history.js';
 import { environmentContextUpdate, restoreEnvironmentState } from './environment.js';
 import { buildContextProjection, restoreModelContext } from './projection.js';
@@ -26,7 +26,9 @@ export async function restoreMessages(store, sessionId, records, options) {
         const compactSummary = compactSummaryFromCheckpoint(record);
         if ((record.type === 'turn.user' || record.type === 'extension.input') &&
             typeof payload.prompt === 'string') {
-            userMessages.push(payload.prompt);
+            const content = typeof payload.modelText === 'string' ? payload.modelText : payload.prompt;
+            const metadata = inputMetadataFromRecord(record);
+            userMessages.push({ content, metadata });
             let images = [];
             if (options.includeImages)
                 try {
@@ -47,20 +49,21 @@ export async function restoreMessages(store, sessionId, records, options) {
                 currentTurnUserIndex = messages.length;
             messages.push({
                 role: 'user',
-                content: typeof payload.modelText === 'string' ? payload.modelText : payload.prompt,
+                content,
+                metadata,
                 ...(images.length ? { images } : {})
             });
             const context = payload.modelContext ?? payload.context;
             if (payload.contextRecords !== true && Array.isArray(context))
                 for (const text of context)
                     if (typeof text === 'string')
-                        messages.push({ role: 'user', content: text });
+                        messages.push({ role: 'user', content: text, contextKind: 'contextual' });
         }
         else if (record.type === 'input.context') {
             if (Array.isArray(payload.modelContext))
                 for (const text of payload.modelContext)
                     if (typeof text === 'string')
-                        messages.push({ role: 'user', content: text });
+                        messages.push({ role: 'user', content: text, contextKind: 'contextual' });
         }
         else if ((record.type === 'message.completed' || record.type === 'plan.completed') &&
             typeof payload.text === 'string')
@@ -72,11 +75,24 @@ export async function restoreMessages(store, sessionId, records, options) {
             const history = replacementHistoryFromCheckpoint(record);
             userMessages =
                 history
-                    ?.filter((message) => message.kind === 'user_input')
-                    .map((message) => message.content) ?? [];
+                    ?.filter((message) => message.kind !== 'summary')
+                    .map((message) => ({
+                    content: message.content,
+                    ...(message.metadata
+                        ? { metadata: { ...message.metadata } }
+                        : message.kind === 'extension_input'
+                            ? { metadata: { source: 'extension' } }
+                            : {})
+                })) ?? [];
             messages.push(...(history
                 ? compactedHistoryMessages(history)
-                : [{ role: 'user', content: continuationMessage(compactSummary) }]));
+                : [
+                    {
+                        role: 'user',
+                        content: continuationMessage(compactSummary),
+                        contextKind: 'summary'
+                    }
+                ]));
             if (Array.isArray(payload.retainedModelContext))
                 for (const item of payload.retainedModelContext) {
                     if (!item || typeof item !== 'object' || item.role !== 'user')

package/dist/agent-core/runtime/context/world-state.d.ts

@@ -19,17 +19,14 @@ export declare function insertContextualWorldState(messages: readonly ModelMessa
 export declare function latestContextualWorldStateGeneration(records: readonly import('../../session/jsonl-store.js').SessionRecord[]): string | undefined;
 export declare function parsePersistedContextualWorldState(payload: unknown): ContextualWorldState | undefined;
 export declare function persistContextualWorldState(store: import('../../session/jsonl-store.js').JsonlSessionStore, sessionId: string, state: ContextualWorldState): Promise<void>;
-export declare function compactHistoryMayContainRetainedResources(records: readonly import('../../session/jsonl-store.js').SessionRecord[]): boolean;
 export declare function updateContextualWorldState(state: ContextualWorldState, index: number, current: {
     instructionSnapshot: string | undefined;
     instructionContent: string | undefined;
-    resourceSnapshot: string | undefined;
-    previousMayContainResources?: boolean;
 }): ContextualWorldState;
 export declare function resetContextualWorldState(generation: string | undefined, index: number, current: {
     instructionSnapshot: string | undefined;
     instructionContent: string | undefined;
-    resourceSnapshot: string | undefined;
-    previousMayContainResources?: boolean;
+    /** Only a committed Compact may supply a new dynamic-resource snapshot. */
+    resourceSnapshot?: string | undefined;
 }): ContextualWorldState;
 export declare function contextualInstructionInsertIndex(messages: readonly ModelMessage[]): number;