@myagentroam/agent 0.9.173 → 0.9.175

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

@@ -1,4 +1,5 @@
 import { observationModelParts } from '../tools/code-mode/observations.js';
+import { stableToolSchema } from '../tools/definition-projection.js';
 import { isDeepStrictEqual } from 'node:util';
 import { createHash, randomUUID } from 'node:crypto';
 import { describeMarAgentError, MarAgentError } from '../error.js';
@@ -89,6 +90,15 @@ export class OpenAiResponsesAdapter {
             const attemptContinuation = useContinuation;
             const attemptCredentialReason = credentialReason;
             const attemptTransport = this.configuration.responsesTransport?.transport === 'WEBSOCKET' ? 'WEBSOCKET' : 'HTTP';
+            const requestPrefixDiagnostic = request.onAttemptDiagnostic
+                ? {
+                    requestInstructionsHash: hashResponsesValue(prepared.fullBody.instructions),
+                    requestToolsHash: hashResponsesValue(prepared.fullBody.tools),
+                    requestPropertiesHash: hashResponsesValue({ ...prepared.fullBody, input: undefined }),
+                    requestInputHash: hashResponsesValue(prepared.fullBody.input),
+                    requestInputItems: prepared.fullBody.input.length
+                }
+                : {};
             const prelude = [];
             let sawSemanticEvent = false;
             let firstSemanticEventType;
@@ -100,11 +110,12 @@ export class OpenAiResponsesAdapter {
                 attempt: attemptNumber,
                 maxAttempts,
                 continuation: attemptContinuation,
-                credentialReason: attemptCredentialReason
+                credentialReason: attemptCredentialReason,
+                ...requestPrefixDiagnostic
             });
             try {
                 for await (const event of this.startAttempt(request, signal, requestBody, useContinuation, credentialReason, turn)) {
-                    if (event.type === 'output.delta') {
+                    if (event.type.startsWith('output.')) {
                         resetOutputTiming = true;
                         yield event;
                         continue;
@@ -130,6 +141,7 @@ export class OpenAiResponsesAdapter {
                     maxAttempts,
                     continuation: attemptContinuation,
                     credentialReason: attemptCredentialReason,
+                    ...requestPrefixDiagnostic,
                     semanticEventObserved: sawSemanticEvent,
                     ...(firstSemanticEventType === undefined ? {} : { firstSemanticEventType }),
                     ...turn.connectionDiagnostic(),
@@ -146,6 +158,7 @@ export class OpenAiResponsesAdapter {
                     maxAttempts,
                     continuation: attemptContinuation,
                     credentialReason: attemptCredentialReason,
+                    ...requestPrefixDiagnostic,
                     semanticEventObserved: sawSemanticEvent,
                     ...(firstSemanticEventType === undefined ? {} : { firstSemanticEventType }),
                     ...turn.connectionDiagnostic(),
@@ -297,10 +310,15 @@ export class OpenAiResponsesAdapter {
             for await (const raw of rawEvents) {
                 const event = record(raw);
                 const type = text(event.type) ?? 'unknown';
+                if (type === 'response.output_item.added' &&
+                    ['reasoning', 'message', 'function_call', 'custom_tool_call'].includes(text(record(event.item).type) ?? ''))
+                    yield observeModelStreamEvent({ type: 'output.started' }, modelStreamEventObservedAt(raw));
+                if (type === 'response.web_search_call.searching')
+                    yield observeModelStreamEvent({ type: 'output.paused' }, modelStreamEventObservedAt(raw));
                 if (type === 'response.output_item.done') {
                     const item = responseItem(event.item);
                     if (item)
-                        yield { type: 'response.item', provider: 'OPENAI_RESPONSES', item };
+                        yield observeModelStreamEvent({ type: 'response.item', provider: 'OPENAI_RESPONSES', item }, modelStreamEventObservedAt(raw));
                 }
                 if (type === 'response.output_item.added' && text(record(event.item).type) === 'message') {
                     const item = record(event.item);
@@ -319,7 +337,7 @@ export class OpenAiResponsesAdapter {
                     if (completedText !== undefined && !emittedCompletedText.has(itemId)) {
                         emittedCompletedText.add(itemId);
                         pendingCompletedText.delete(itemId);
-                        yield { type: 'text.completed', itemId, phase, text: completedText };
+                        yield observeModelStreamEvent({ type: 'text.completed', itemId, phase, text: completedText }, modelStreamEventObservedAt(raw));
                     }
                 }
                 else if (type === 'response.output_item.added' &&
@@ -363,10 +381,10 @@ export class OpenAiResponsesAdapter {
                         yield observeModelStreamEvent({ type: 'output.delta' }, modelStreamEventObservedAt(raw));
                 }
                 else if (type === 'response.created')
-                    yield {
+                    yield observeModelStreamEvent({
                         type: 'response.started',
                         responseId: responseEventId(event) ?? 'unknown'
-                    };
+                    }, modelStreamEventObservedAt(raw));
                 else if (type === 'response.output_text.delta')
                     yield observeModelStreamEvent({
                         type: 'text.delta',
@@ -384,17 +402,17 @@ export class OpenAiResponsesAdapter {
                         continue;
                     if (phase) {
                         emittedCompletedText.add(itemId);
-                        yield { type: 'text.completed', itemId, phase, text: completedText };
+                        yield observeModelStreamEvent({ type: 'text.completed', itemId, phase, text: completedText }, modelStreamEventObservedAt(raw));
                     }
                     else
                         pendingCompletedText.set(itemId, completedText);
                 }
                 else if (type === 'response.reasoning_summary_text.done')
-                    yield {
+                    yield observeModelStreamEvent({
                         type: 'reasoning.summary',
                         itemId: text(event.item_id) ?? 'reasoning',
                         text: text(event.text) ?? ''
-                    };
+                    }, modelStreamEventObservedAt(raw));
                 else if (type === 'response.output_item.done' &&
                     text(record(event.item).type) === 'tool_search_call') {
                     const item = record(event.item);
@@ -410,13 +428,13 @@ export class OpenAiResponsesAdapter {
                         }
                     if (!emittedFunctionCalls.has(callId)) {
                         emittedFunctionCalls.add(callId);
-                        yield {
+                        yield observeModelStreamEvent({
                             type: 'client_tool.call',
                             callId,
                             name: 'tool_search',
                             arguments: arguments_,
                             ...(argumentError ? { argumentError } : {})
-                        };
+                        }, modelStreamEventObservedAt(raw));
                     }
                 }
                 else if (type === 'response.function_call_arguments.done' ||
@@ -440,13 +458,13 @@ export class OpenAiResponsesAdapter {
                         'unknown';
                     if (!emittedFunctionCalls.has(callId)) {
                         emittedFunctionCalls.add(callId);
-                        yield {
+                        yield observeModelStreamEvent({
                             type: 'client_tool.call',
                             callId,
                             name: text(event.name) ?? text(item.name) ?? known?.name ?? 'unknown',
                             arguments: args,
                             ...(argumentError ? { argumentError } : {})
-                        };
+                        }, modelStreamEventObservedAt(raw));
                     }
                 }
                 else if (type === 'response.custom_tool_call_input.done' ||
@@ -458,13 +476,13 @@ export class OpenAiResponsesAdapter {
                     const callId = text(event.call_id) ?? text(item.call_id) ?? known?.callId ?? itemId;
                     if (!emittedFunctionCalls.has(callId)) {
                         emittedFunctionCalls.add(callId);
-                        yield {
+                        yield observeModelStreamEvent({
                             type: 'client_tool.call',
                             callId,
                             name: text(event.name) ?? text(item.name) ?? known?.name ?? 'unknown',
                             arguments: text(event.input) ?? text(item.input) ?? known?.input ?? '',
                             inputMode: 'freeform'
-                        };
+                        }, modelStreamEventObservedAt(raw));
                     }
                 }
                 else if (type.includes('web_search_call') ||
@@ -489,7 +507,7 @@ export class OpenAiResponsesAdapter {
                             ? {}
                             : { sourcesTruncated: summary.sourcesTruncated })
                     };
-                    yield {
+                    yield observeModelStreamEvent({
                         type: 'hosted_tool',
                         itemId,
                         kind,
@@ -503,13 +521,13 @@ export class OpenAiResponsesAdapter {
                                 ? 'COMPLETED'
                                 : 'RUNNING',
                         summary
-                    };
+                    }, modelStreamEventObservedAt(raw));
                 }
                 else if (type === 'response.output_text.annotation.added') {
                     const annotation = record(event.annotation);
                     const url = text(annotation.url);
                     if (url)
-                        yield {
+                        yield observeModelStreamEvent({
                             type: 'citation',
                             citation: {
                                 id: text(annotation.id) ??
@@ -517,9 +535,10 @@ export class OpenAiResponsesAdapter {
                                 url,
                                 ...(text(annotation.title) ? { title: text(annotation.title) } : {})
                             }
-                        };
+                        }, modelStreamEventObservedAt(raw));
                 }
                 else if (type === 'response.completed' || type === 'response.incomplete') {
+                    yield observeModelStreamEvent({ type: 'output.completed' }, modelStreamEventObservedAt(raw));
                     const responseData = record(event.response);
                     if (type === 'response.completed')
                         turn.captureCompletedResponseId(responseEventId(event));
@@ -527,21 +546,22 @@ export class OpenAiResponsesAdapter {
                         if (emittedCompletedText.has(itemId))
                             continue;
                         emittedCompletedText.add(itemId);
-                        yield {
+                        yield observeModelStreamEvent({
                             type: 'text.completed',
                             itemId,
                             phase: textPhases.get(itemId) ?? 'final_answer',
                             text: completedText
-                        };
+                        }, modelStreamEventObservedAt(raw));
                     }
                     pendingCompletedText.clear();
                     for (const citation of responseCitations(responseData))
-                        yield { type: 'citation', citation };
+                        yield observeModelStreamEvent({ type: 'citation', citation }, modelStreamEventObservedAt(raw));
                     const usage = record(responseData.usage);
                     const inputDetails = record(usage.input_tokens_details);
                     const rolloutBudgetUnits = optionalRolloutBudgetUnits(usage.codex_rollout_budget_units);
-                    yield {
+                    yield observeModelStreamEvent({
                         type: 'usage',
+                        final: true,
                         usage: {
                             inputTokens: number(usage.input_tokens),
                             contextInputTokens: number(usage.input_tokens),
@@ -550,7 +570,7 @@ export class OpenAiResponsesAdapter {
                             cacheWriteTokens: number(inputDetails.cache_write_tokens),
                             ...(rolloutBudgetUnits === undefined ? {} : { rolloutBudgetUnits })
                         }
-                    };
+                    }, modelStreamEventObservedAt(raw));
                     yield observeModelStreamEvent({
                         type: 'completed',
                         reason: type === 'response.incomplete' ? 'max_output' : 'completed'
@@ -586,7 +606,7 @@ export class OpenAiResponsesAdapter {
                     });
                 }
                 else if (!isNonSemanticOpenAiResponsesEvent(type))
-                    yield { type: 'unknown', nativeType: type };
+                    yield observeModelStreamEvent({ type: 'unknown', nativeType: type }, modelStreamEventObservedAt(raw));
             }
         }
         catch (error) {
@@ -651,7 +671,7 @@ class OpenAiResponsesTurnSession {
                 if (event.type === 'response.started' && event.responseId !== 'unknown')
                     responseId = event.responseId;
                 else if (event.type === 'response.item')
-                    outputItems.push(event.item);
+                    outputItems.push(JSON.parse(JSON.stringify(event.item)));
                 else if (event.type === 'text.delta' ||
                     event.type === 'output.delta' ||
                     event.type === 'text.completed' ||
@@ -706,7 +726,8 @@ class OpenAiResponsesTurnSession {
             invalidateResponsesWebSocket(this.state, false);
             clearResponsesContinuation(this.state);
         }
-        const fullBody = responsesRequestBody(this.adapter.configuration, request, request.messages);
+        // The continuation baseline must not share mutable schemas or items with callers.
+        const fullBody = JSON.parse(JSON.stringify(responsesRequestBody(this.adapter.configuration, request, request.messages)));
         if (responsesContinuationEnabled(this.adapter.configuration)) {
             const incremental = incrementalResponsesInput(this.state, fullBody);
             if (incremental !== undefined) {
@@ -875,7 +896,7 @@ function responsesRequestBody(configuration, request, messages) {
                 type: 'tool_search',
                 execution: 'client',
                 description: tool.description,
-                parameters: strictFunctionSchema(tool.inputSchema)
+                parameters: stableToolSchema(strictFunctionSchema(stableToolSchema(tool.inputSchema)))
             }
             : responsesFunctionTool(tool));
     if (configuration.responsesToolNamespace && tools.length > 0) {
@@ -948,27 +969,13 @@ function incrementalResponsesInput(state, current) {
     if (current.input.length < baseline.length)
         return undefined;
     for (let index = 0; index < baseline.length; index++)
-        if (!isDeepStrictEqual(baseline[index], current.input[index]))
+        if (JSON.stringify(baseline[index]) !== JSON.stringify(current.input[index]))
             return undefined;
     return current.input.slice(baseline.length);
 }
 function responsesContinuationPropertiesMatch(previous, current) {
-    const properties = [
-        'model',
-        'service_tier',
-        'instructions',
-        'tools',
-        'tool_choice',
-        'max_output_tokens',
-        'parallel_tool_calls',
-        'reasoning',
-        'store',
-        'stream',
-        'include',
-        'prompt_cache_key',
-        'text'
-    ];
-    return properties.every((property) => isDeepStrictEqual(previous[property], current[property]));
+    return (JSON.stringify({ ...previous, input: undefined }) ===
+        JSON.stringify({ ...current, input: undefined }));
 }
 function clearResponsesContinuation(state) {
     delete state.lastRequest;
@@ -1387,6 +1394,8 @@ function webSocketReceiveError(cause) {
     });
 }
 function isSemanticEvent(event) {
+    if (event.type.startsWith('output.'))
+        return false;
     if (event.type === 'response.started' || event.type === 'usage' || event.type === 'response.item')
         return false;
     if (event.type === 'text.delta')
@@ -1508,11 +1517,11 @@ function responsesHeaders(credential, promptCacheKey, turnState) {
         authorization: `Bearer ${credential.bearer.reveal()}`,
         'content-type': 'application/json',
         accept: 'text/event-stream',
+        'x-client-request-id': randomUUID(),
         ...(promptCacheKey
             ? {
                 'session-id': promptCacheKey,
-                'thread-id': promptCacheKey,
-                'x-client-request-id': promptCacheKey
+                'thread-id': promptCacheKey
             }
             : {})
     });
@@ -1927,7 +1936,7 @@ function responsesFunctionTool(tool) {
             type: 'function',
             name: tool.name,
             description: tool.description,
-            parameters: strict ? strictFunctionSchema(tool.inputSchema) : tool.inputSchema,
+            parameters: stableToolSchema(strict ? strictFunctionSchema(stableToolSchema(tool.inputSchema)) : tool.inputSchema),
             strict
         };
 }

package/dist/agent-core/model/sse.js

@@ -38,18 +38,66 @@ export async function* parseSse(response, signal, maxBytes = 16 * 1024 * 1024, i
     let buffer = '';
     let total = 0;
     let streamCompleted = false;
+    const receiverAbort = new AbortController();
+    const receiverSignal = AbortSignal.any([signal, receiverAbort.signal]);
+    const chunks = [];
+    let nextChunk = 0;
+    let receivedAll = false;
+    let receiverFailure;
+    let wake;
+    const notify = () => {
+        wake?.();
+        wake = undefined;
+    };
+    // Keep transport receipt independent of async SDK publication and persistence.
+    // The cumulative response byte limit also bounds the pending raw chunk queue.
+    const receive = (async () => {
+        try {
+            while (true) {
+                const { value, done } = await readStreamChunk(reader, receiverSignal, idleTimeoutMs);
+                const observedAt = performance.now();
+                if (done) {
+                    streamCompleted = true;
+                    break;
+                }
+                total += value.byteLength;
+                enforceResponseSize(total, maxBytes);
+                if (value.byteLength === 0)
+                    continue;
+                chunks.push({ value, observedAt });
+                notify();
+            }
+        }
+        catch (error) {
+            receiverFailure = { error };
+            await reader.cancel(error).catch(() => undefined);
+        }
+        finally {
+            receivedAll = true;
+            notify();
+        }
+    })();
     try {
         while (true) {
-            if (signal.aborted)
-                throw signal.reason;
-            const { value, done } = await readStreamChunk(reader, signal, idleTimeoutMs);
-            const observedAt = performance.now();
-            if (done) {
-                streamCompleted = true;
-                break;
+            signal.throwIfAborted();
+            const chunk = chunks[nextChunk];
+            if (chunk === undefined) {
+                if (receivedAll) {
+                    if (receiverFailure !== undefined)
+                        throw receiverFailure.error;
+                    break;
+                }
+                await new Promise((resolve) => {
+                    wake = resolve;
+                });
+                continue;
             }
-            total += value.byteLength;
-            enforceResponseSize(total, maxBytes);
+            chunks[nextChunk++] = undefined;
+            if (nextChunk >= 1_024 && nextChunk * 2 >= chunks.length) {
+                chunks.splice(0, nextChunk);
+                nextChunk = 0;
+            }
+            const { value, observedAt } = chunk;
             buffer += decoder.decode(value, { stream: true }).replaceAll('\r\n', '\n');
             let boundary;
             while ((boundary = buffer.indexOf('\n\n')) >= 0) {
@@ -75,6 +123,8 @@ export async function* parseSse(response, signal, maxBytes = 16 * 1024 * 1024, i
             throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Model SSE ended with an incomplete frame.');
     }
     finally {
+        receiverAbort.abort();
+        await receive;
         await closeReader(reader, streamCompleted);
     }
 }

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

@@ -1,2 +1 @@
 export declare function compactionPrompt(): string;
-export declare function highDensityCompactionPrompt(): string;

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

@@ -24,59 +24,3 @@ Remove aggressively:
 
 Use compact Markdown with these headings when applicable: Objective, Instructions and constraints, Decisions and facts, Completed work, Verification and evidence, Active state, Open issues and risks, Next action. Omit empty headings. Prefer precise paths, IDs, error codes, and short evidence over narrative. Output only the handoff.`;
 }
-export function highDensityCompactionPrompt() {
-    return `Compile the visible conversation into Textual Continuation IR that lets the next agent continue correctly after the transcript is discarded. Transfer state; do not recap, address the user, call tools, advance the task, or invent facts.
-
-Optimize for continuation fidelity first and density second. Prefer sufficient continuation state over brevity; never omit information required to resume correctly.
-
-## Output contract
-Use these English section names when applicable; omit empty sections:
-1. Goal contract
-2. Current state
-3. Settled matters
-4. Necessary evidence
-5. Open loops
-
-IR grammar and vocabulary are English: headings, keys, enums, state atoms, and control terms. Natural-language values may follow the task's dominant language. Preserve exact user-designated text and established domain terms; do not translate identifiers or invent localized IR terminology.
-
-Prefer records over prose:
-<object> | <key>=<value> | <key>=<value>
-<event/condition> -> <object>.<key>=<value> | <effect>
-
-Use | for parallel facts, = for current state, and -> only for causality, invalidation, or transition. Keep enums lowercase and semantic: required, forbidden, pending; never YES/NO. Omit empty or irrelevant unknown fields. Keep pending, not run, unverified, and failed distinct. Use a sentence only when records cannot express a multi-object cause, conflict, authorization, or safety boundary unambiguously.
-
-Examples:
-src/discount.js | cause=verified | edit=pending | tests=not run
-patch(src/discount.js) -> prior_read=stale | next=re-evidence
-authorization | action=<exact> | scope=<exact> | lifetime=<exact> | status=active
-
-## Compiler
-1. Resolve intent. The latest user correction overrides older intent. Extract the primary objective, current deliverable, completion criteria, non-goals, and boundaries.
-2. Reduce time. Convert before -> event -> after into the latest evidenced state. Source mutation or base/branch change makes only affected evidence stale. History replacement invalidates Responses continuation, not factual evidence. Without an invalidating event, a verified claim remains current.
-3. Build objects. Emit one current record per file, symbol, feature, migration, test, worktree axis, selected Skill, Todo/plan item, external decision, or external side effect. Deduplicate equivalent facts.
-4. Separate status axes when needed:
-   - completion=pending|in_progress|completed|blocked
-   - epistemic=observed|verified|inferred|proposed|disproved
-   - freshness=current|stale|superseded
-   - scope=turn|worktree|base|branch|external
-5. Bind evidence to the claim it proves. Prefer a verified conclusion over raw snapshots or intermediate hypotheses.
-6. Select under budget. Protect, in order: objective, progress, boundaries and authorization, non-repeatable side effects, open loops, then necessary evidence. Remove provenance and recoverable detail only after those remain sufficient.
-
-## Retention rules
-- Preserve active caller/user instructions outside filesystem-loaded AGENTS.md, exact authorization boundaries, confirmed decisions and exclusions, completed edits and side effects, verification actually run, reproducible failures, failed approaches that constrain the next step, unresolved risks, and the smallest established next action.
-- Authorization is valid only for its exact action, scope, and lifetime in the active request. Completed or superseded scopes cannot revive it. Object state, completion, tool availability, and convenience never imply permission.
-- Preserve decisive values, or an exact artifact path/command that deterministically recovers them, when a result controls later work. Counts or schemas alone are insufficient.
-- Preserve paths, symbols, APIs, tools, models, providers, JSON keys, protocol fields, commands, arguments, error codes, commit hashes, call IDs, sequences, versions, numbers, and user-designated text verbatim.
-- Preserve selected Skill names with only continuation-critical constraints. Preserve Todo/plan revision, item/status, and current minimum step.
-- Keep observed HEAD, validated base, target commit, and current worktree as separate axes. Evidence updates only what it directly proves; cross-axis, cross-base, and cross-branch inference remains unverified.
-- If evidence conflicts, use state=conflict | candidates=<short values> | next=re-evidence. Never choose a side without evidence.
-
-## Exclusions
-Remove greetings, progress chatter, chronology that does not affect current state, duplicate facts, superseded hypotheses without remaining constraints, long logs, source bodies, verbose payloads, cheap-to-recover content, local-only integrity hashes, hidden reasoning, secrets, credentials, and unrelated content.
-
-Remove user/project/directory AGENTS.md text and constraints derived only from those files; the next Execution reloads them. Remove retained process/Subagent inventory, IDs, status, commands, cwd, and reuse instructions; Runtime reloads them.
-
-Before emitting, verify that objective, current progress, authorization/boundaries, completed versus unverified work, decisive evidence, open loops, and next action are explicit and non-contradictory.
-
-Output only compact Markdown IR.`;
-}

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

@@ -13,7 +13,6 @@ interface SystemPromptInput {
     workspace: string;
     tools: readonly string[];
     directTools?: readonly string[];
-    highDensityCompaction?: boolean;
     extension?: string | undefined;
 }
 export declare function buildSystemPrompt(input: SystemPromptInput): string;

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

@@ -1,5 +1,5 @@
 import { renderPromptSections } from '../extensions/prompt-composition.js';
-import { compactionPrompt, highDensityCompactionPrompt } from './compact.js';
+import { compactionPrompt } from './compact.js';
 import { environmentPrompt, identityPrompt, instructionPriorityPrompt, workspaceDisciplinePrompt } from './core.js';
 import { modePrompt } from './modes.js';
 import { outputStylePrompt } from './output.js';
@@ -36,14 +36,7 @@ export function buildSystemPromptSections(input) {
                 questionAvailable: toolNames.has('question')
             })
         ],
-        [
-            'compaction',
-            input.mode === 'compact'
-                ? input.highDensityCompaction
-                    ? highDensityCompactionPrompt()
-                    : compactionPrompt()
-                : ''
-        ],
+        ['compaction', input.mode === 'compact' ? compactionPrompt() : ''],
         ['subagent', toolNames.has('agent_start') ? subagentPrompt : ''],
         [
             'caller-instructions',

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

@@ -3,9 +3,8 @@ import type { CompactHistoryMessage, CompactUserInput } from '../../session/json
 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;
-    highDensityCompaction?: boolean;
 }): ModelMessage[];
-export declare function buildCompactionMessages(evidence: string, highDensityCompaction?: boolean): ModelMessage[];
+export declare function buildCompactionMessages(evidence: string): ModelMessage[];
 export declare function buildCompactionInput(messages: readonly ModelMessage[], input: {
     focus?: string;
     maxTokens: number;

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

@@ -1,9 +1,9 @@
 import { countModelTokens, truncateModelText } from '../token-budget.js';
-import { compactionPrompt, highDensityCompactionPrompt } from '../../prompts/compact.js';
+import { compactionPrompt } from '../../prompts/compact.js';
 export const DEFAULT_COMPACTION_FOCUS = 'Create a durable continuation state for the next model invocation.';
 export function buildNativeCompactionMessages(messages, input = {}) {
     const focus = input.focus?.trim();
-    const contract = input.highDensityCompaction ? highDensityCompactionPrompt() : compactionPrompt();
+    const contract = compactionPrompt();
     return [
         ...messages
             .filter((message) => message.contextKind !== 'private')
@@ -21,13 +21,13 @@ export function buildNativeCompactionMessages(messages, input = {}) {
         }
     ];
 }
-export function buildCompactionMessages(evidence, highDensityCompaction = false) {
+export function buildCompactionMessages(evidence) {
     return [
         { role: 'user', content: evidence, contextKind: 'contextual' },
         {
             role: 'user',
             contextKind: 'compact_control',
-            content: highDensityCompaction ? highDensityCompactionPrompt() : compactionPrompt()
+            content: compactionPrompt()
         }
     ];
 }

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

@@ -26,7 +26,7 @@ export type MarAgentEvent = MarAgentEventBase & ({
     modelName: string;
 } | {
     type: 'model.performance';
-    latencyMs: number;
+    latencyMs?: number | undefined;
     outputTokens?: number | undefined;
     outputDurationMs?: number | undefined;
     tokensPerSecond?: number | undefined;