@myagentroam/agent 0.9.173 → 0.9.175

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

@@ -5,6 +5,7 @@ import { modelOutputContinuationMessage } from '../prompts/output.js';
 import { executeRoundTools } from '../tools/execution.js';
 import { publicHostedToolEvents, publicModelUsage } from './event-projection.js';
 import { PlanOutputPrefix, splitPlanOutput } from './plan-output.js';
+import { ModelGenerationTiming } from './model-generation-timing.js';
 /** Own the single model/tool loop; the SDK owns its handle, terminal events and cleanup. */
 export class ExecutionLoop {
     input;
@@ -38,8 +39,7 @@ export class ExecutionLoop {
             let sawModelSemanticEvent = false;
             let requestStartedAt;
             let firstModelResponseAt;
-            let firstOutputDeltaAt;
-            let lastOutputDeltaAt;
+            let generation = new ModelGenerationTiming();
             let requestCompletedAt;
             let requestOutputTokens;
             const roundMessageCount = messages.length;
@@ -52,19 +52,18 @@ export class ExecutionLoop {
                 });
             };
             const emitFinalPerformance = async (completedAt) => {
-                if (mode === 'compact' ||
-                    firstModelResponseAt === undefined ||
-                    firstOutputDeltaAt === undefined ||
-                    lastOutputDeltaAt === undefined ||
-                    lastOutputDeltaAt - firstOutputDeltaAt < 1)
+                if (mode === 'compact')
                     return;
-                const outputDuration = completedAt - firstOutputDeltaAt;
+                generation.finish(completedAt);
+                const outputDuration = generation.durationMs;
                 const outputTokens = requestOutputTokens;
-                if (outputTokens === undefined || outputDuration < 1 || completedAt < lastOutputDeltaAt)
+                if (outputTokens === undefined || outputDuration === undefined)
                     return;
                 await input.publish({
                     type: 'model.performance',
-                    latencyMs: Math.max(0, Math.round(firstModelResponseAt - requestStartedAt)),
+                    ...(firstModelResponseAt === undefined
+                        ? {}
+                        : { latencyMs: Math.max(0, Math.round(firstModelResponseAt - requestStartedAt)) }),
                     outputTokens,
                     outputDurationMs: Math.round(outputDuration),
                     tokensPerSecond: Number(((outputTokens * 1000) / outputDuration).toFixed(2))
@@ -91,14 +90,25 @@ export class ExecutionLoop {
                     retryState: modelRetryState
                 })) {
                     if (event.type === 'output.reset') {
-                        firstOutputDeltaAt = undefined;
-                        lastOutputDeltaAt = undefined;
+                        generation = new ModelGenerationTiming();
+                        requestCompletedAt = undefined;
                         requestOutputTokens = undefined;
                         continue;
                     }
-                    const modelResponseAt = mode !== 'compact' && isModelResponseEvent(event)
-                        ? Math.max(requestStartedAt, modelStreamEventObservedAt(event) ?? performance.now())
-                        : undefined;
+                    const observedAt = Math.max(requestStartedAt, modelStreamEventObservedAt(event) ?? performance.now());
+                    if (event.type === 'output.started') {
+                        generation.start(observedAt);
+                        continue;
+                    }
+                    if (event.type === 'output.completed') {
+                        generation.finish(observedAt);
+                        continue;
+                    }
+                    if (event.type === 'output.paused') {
+                        generation.pause(observedAt);
+                        continue;
+                    }
+                    const modelResponseAt = mode !== 'compact' && isModelResponseEvent(event) ? observedAt : undefined;
                     const isFirstModelResponse = modelResponseAt !== undefined && firstModelResponseAt === undefined;
                     if (modelResponseAt !== undefined) {
                         if (event.type !== 'output.delta')
@@ -106,8 +116,7 @@ export class ExecutionLoop {
                         firstModelResponseAt ??= modelResponseAt;
                         if (event.type === 'output.delta' ||
                             (event.type === 'text.delta' && event.delta.length > 0)) {
-                            firstOutputDeltaAt ??= modelResponseAt;
-                            lastOutputDeltaAt = modelResponseAt;
+                            generation.start(modelResponseAt);
                         }
                     }
                     if (event.type === 'response.item') {
@@ -185,14 +194,15 @@ export class ExecutionLoop {
                     }
                     else if (event.type === 'usage') {
                         latestUsage = event.usage;
+                        if (event.final === true)
+                            generation.finish(observedAt);
                         const outputTokens = typeof event.usage.outputTokens === 'number' &&
                             Number.isSafeInteger(event.usage.outputTokens) &&
                             event.usage.outputTokens >= 0
                             ? event.usage.outputTokens
                             : undefined;
-                        if (outputTokens !== undefined) {
+                        if (event.final !== false && (outputTokens !== undefined || event.final === true))
                             requestOutputTokens = outputTokens;
-                        }
                         const reportedContext = event.usage.contextInputTokens ?? event.usage.inputTokens;
                         if (reportedContext !== undefined &&
                             Number.isSafeInteger(reportedContext) &&
@@ -235,15 +245,16 @@ export class ExecutionLoop {
                     }
                     else if (event.type === 'completed') {
                         stop = event.reason;
-                        requestCompletedAt = modelStreamEventObservedAt(event) ?? performance.now();
+                        requestCompletedAt = observedAt;
                     }
                     if (isFirstModelResponse)
                         await emitLatency();
                 }
-                if (mode !== 'compact' && firstModelResponseAt !== undefined) {
-                    const completedAt = requestCompletedAt ?? performance.now();
-                    await emitFinalPerformance(completedAt);
-                }
+                if (mode !== 'compact' &&
+                    stop !== 'cancelled' &&
+                    !input.signal.aborted &&
+                    requestCompletedAt !== undefined)
+                    await emitFinalPerformance(requestCompletedAt);
                 pendingOutputContinuation = undefined;
                 incompleteToolCall = pendingTools.some((call) => call.argumentError !== undefined);
                 if (!(stop === 'max_output' && incompleteToolCall)) {

package/dist/agent-core/runtime/model-generation-timing.d.ts

@@ -0,0 +1,12 @@
+/** Request-local observed generation intervals, excluding explicit execution pauses. */
+export declare class ModelGenerationTiming {
+    private startedAt;
+    private latestAt;
+    private duration;
+    private completed;
+    private valid;
+    start(at: number): void;
+    pause(at: number): void;
+    finish(at: number): void;
+    get durationMs(): number | undefined;
+}

package/dist/agent-core/runtime/model-generation-timing.js

@@ -0,0 +1,39 @@
+/** Request-local observed generation intervals, excluding explicit execution pauses. */
+export class ModelGenerationTiming {
+    startedAt;
+    latestAt;
+    duration = 0;
+    completed = false;
+    valid = true;
+    start(at) {
+        if (this.completed)
+            return;
+        if (!Number.isFinite(at) || (this.latestAt !== undefined && at < this.latestAt)) {
+            this.valid = false;
+            return;
+        }
+        this.startedAt ??= at;
+        this.latestAt = at;
+    }
+    pause(at) {
+        if (this.completed || this.startedAt === undefined)
+            return;
+        if (!Number.isFinite(at) || at < (this.latestAt ?? this.startedAt))
+            this.valid = false;
+        else
+            this.duration += at - this.startedAt;
+        this.startedAt = undefined;
+        this.latestAt = at;
+    }
+    finish(at) {
+        if (this.completed)
+            return;
+        if (!Number.isFinite(at) || (this.latestAt !== undefined && at < this.latestAt))
+            this.valid = false;
+        this.pause(at);
+        this.completed = true;
+    }
+    get durationMs() {
+        return this.completed && this.valid && this.duration >= 1 ? this.duration : undefined;
+    }
+}

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

@@ -109,7 +109,6 @@ export function createSessionOpener(services) {
                 .filter((tool) => !tool.name.startsWith('mcp__') &&
                 allowsDirectTool(tool, availableTools.some((candidate) => candidate.name === 'code_exec')))
                 .map((tool) => tool.name),
-            highDensityCompaction: selectedModel.highDensityCompaction,
             extension: [
                 executionSystemInstruction,
                 skillCatalog,
@@ -1031,7 +1030,6 @@ export function createSessionOpener(services) {
                             if (!coreExtensions.hooks.hasInterceptors('compact.generate'))
                                 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 {
@@ -1041,7 +1039,7 @@ export function createSessionOpener(services) {
                                     messages: compactExtensionMessages(history),
                                     ...(focus === undefined ? {} : { focus }),
                                     summaryTokenBudget,
-                                    getPrompt: () => buildCompactionMessages('', highDensityCompaction)[1].content,
+                                    getPrompt: () => buildCompactionMessages('')[1].content,
                                     reportDiagnostic: async (value) => {
                                         if (!acceptsDiagnostics || ++diagnosticReports > 8)
                                             return;
@@ -1082,17 +1080,16 @@ export function createSessionOpener(services) {
                             const compactHistory = [...messages];
                             const projectedHistory = normalizeMessagesForModel(insertContextualWorldState(compactHistory, contextualWorldState.entries), { supportsImages: false });
                             const nativeMessages = buildNativeCompactionMessages(projectedHistory, {
-                                focus: compactFocus,
-                                highDensityCompaction: selectedModel.highDensityCompaction
+                                focus: compactFocus
                             });
-                            const compactOverheadTokens = estimatedRequestTokens(compactSystemPrompt, buildCompactionMessages('', selectedModel.highDensityCompaction), executionTools);
+                            const compactOverheadTokens = estimatedRequestTokens(compactSystemPrompt, buildCompactionMessages(''), executionTools);
                             const compactInputTokens = selectedModel.contextWindowTokens - compactOverheadTokens;
                             if (compactInputTokens <= 0)
                                 throw new MarAgentError('MAR_AGENT_CONTEXT_LIMIT', 'Compaction prompt exceeds the selected model context window.');
                             const fallbackMessages = () => buildCompactionMessages(buildCompactionInput(compactHistory, {
                                 focus: compactFocus,
                                 maxTokens: compactInputTokens
-                            }), selectedModel.highDensityCompaction);
+                            }));
                             const useNative = shouldUseNativeCompaction({
                                 estimatedRequestTokens: estimatedRequestTokens(compactSystemPrompt, nativeMessages, executionTools),
                                 contextWindowTokens: selectedModel.contextWindowTokens,
@@ -1138,10 +1135,9 @@ export function createSessionOpener(services) {
                             const compactSystemPrompt = await operation((call) => coreExtensions.compose(promptComposition(executionTools, 'run'), call));
                             const projectedHistory = normalizeMessagesForModel(insertContextualWorldState(compactHistory, contextualWorldState.entries), { supportsImages: false });
                             const nativeCompactMessages = buildNativeCompactionMessages(projectedHistory, {
-                                ...(input.focus === undefined ? {} : { focus: input.focus }),
-                                highDensityCompaction: selectedModel.highDensityCompaction
+                                ...(input.focus === undefined ? {} : { focus: input.focus })
                             });
-                            const compactOverheadTokens = estimatedRequestTokens(compactSystemPrompt, buildCompactionMessages('', selectedModel.highDensityCompaction), executionTools);
+                            const compactOverheadTokens = estimatedRequestTokens(compactSystemPrompt, buildCompactionMessages(''), executionTools);
                             const compactInputTokens = Math.max(0, selectedModel.contextWindowTokens - compactOverheadTokens);
                             let usingNativeMessages = shouldUseNativeCompaction({
                                 estimatedRequestTokens: estimatedRequestTokens(compactSystemPrompt, nativeCompactMessages, executionTools),
@@ -1153,7 +1149,7 @@ export function createSessionOpener(services) {
                             const fallbackMessages = () => buildCompactionMessages(buildCompactionInput(compactHistory, {
                                 ...(input.focus === undefined ? {} : { focus: input.focus }),
                                 maxTokens: Math.max(1, compactInputTokens)
-                            }), selectedModel.highDensityCompaction);
+                            }));
                             let compactMessages = usingNativeMessages
                                 ? nativeCompactMessages
                                 : fallbackMessages();

package/dist/agent-core/tools/agent/agent-start.js

@@ -31,7 +31,9 @@ export const agentStartToolDefinition = {
 export function agentStartToolDefinitionWithModels(models) {
     if (models.length === 0)
         return agentStartToolDefinition;
-    const modelLines = models.map((model) => {
+    const modelLines = [...models]
+        .sort((left, right) => (left.id < right.id ? -1 : left.id > right.id ? 1 : 0))
+        .map((model) => {
         const efforts = model.reasoningEfforts.length === 0
             ? ''
             : `; reasoning efforts: ${model.reasoningEfforts.join(', ')}`;

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

@@ -7,6 +7,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { MarAgentError, describeMarAgentError } from '../../error.js';
 import { directLocalProcessExecutor, signalProcessTree } from '../../host/local-process-executor.js';
 import { allowsDirectTool, allowsToolCaller } from '../callers.js';
+import { orderToolDefinitions, stableToolSchema, stableToolDefinition } from '../definition-projection.js';
 import { CodeCells } from './cells.js';
 import { newObservationId, renderObservations } from './observations.js';
 import { parseCodeModeStateMutations } from './state.js';
@@ -100,16 +101,18 @@ export const codeExecWaitToolDefinition = {
 /** Deferred definitions travel in search results, not in the stable Code Mode description. */
 export function projectCodeModeTools(tools, residentTools = tools) {
     const codeModeEnabled = tools.some((tool) => tool.name === 'code_exec' && allowsToolCaller(tool, 'direct'));
-    const direct = tools.filter((tool) => allowsDirectTool(tool, codeModeEnabled));
+    const direct = tools
+        .filter((tool) => allowsDirectTool(tool, codeModeEnabled))
+        .map(stableToolDefinition);
     if (!codeModeEnabled)
         return direct;
-    const programmatic = residentTools.filter((tool) => allowsToolCaller(tool, 'programmatic'));
+    const programmatic = orderToolDefinitions(residentTools.filter((tool) => allowsToolCaller(tool, 'programmatic')));
     const directory = JSON.stringify({
         callableNames: programmatic.map((tool) => tool.name),
         programmaticOnly: programmatic.map((tool) => ({
             name: tool.name,
             description: tool.description,
-            inputSchema: tool.inputSchema,
+            inputSchema: stableToolSchema(tool.inputSchema),
             inputMode: tool.inputMode ?? 'json'
         }))
     });
@@ -129,14 +132,16 @@ export function projectCodeModeSearchResult(message, codeModeEnabled) {
     if (!codeModeEnabled)
         return {
             ...message,
-            toolSearchTools: message.toolSearchTools.filter((tool) => allowsToolCaller(tool, 'direct'))
+            toolSearchTools: message.toolSearchTools
+                .filter((tool) => allowsToolCaller(tool, 'direct'))
+                .map(stableToolDefinition)
         };
     const tools = message.toolSearchTools.map((tool) => ({
         name: tool.name,
         description: allowsToolCaller(tool, 'programmatic')
             ? `Call only as tools.${tool.name} inside code_exec, never as a direct model tool.\n${tool.description}`
             : tool.description,
-        inputSchema: tool.inputSchema,
+        inputSchema: stableToolSchema(tool.inputSchema),
         inputMode: tool.inputMode ?? 'json',
         caller: allowsToolCaller(tool, 'programmatic') ? 'programmatic' : 'direct'
     }));

package/dist/agent-core/tools/definition-projection.d.ts

@@ -0,0 +1,7 @@
+import type { ClientToolDefinition } from './contracts.js';
+/** Stable model declarations, not a serializer for historical messages or tool results. */
+export declare function stableToolSchema<T>(schema: T): T;
+export declare function stableToolDefinition(definition: ClientToolDefinition): ClientToolDefinition;
+export declare function orderToolDefinitions<T extends {
+    readonly name: string;
+}>(definitions: readonly T[]): T[];

package/dist/agent-core/tools/definition-projection.js

@@ -0,0 +1,26 @@
+/** Stable model declarations, not a serializer for historical messages or tool results. */
+export function stableToolSchema(schema) {
+    return stableSchemaValue(schema);
+}
+function stableSchemaValue(value) {
+    if (Array.isArray(value))
+        return value.map(stableSchemaValue);
+    if (value === null || typeof value !== 'object')
+        return value;
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        return value;
+    const fields = value;
+    return Object.fromEntries(Object.keys(fields)
+        .sort()
+        .map((key) => [key, stableSchemaValue(fields[key])]));
+}
+export function stableToolDefinition(definition) {
+    return {
+        ...definition,
+        inputSchema: stableToolSchema(definition.inputSchema)
+    };
+}
+export function orderToolDefinitions(definitions) {
+    return [...definitions].sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+}

package/dist/agent-core/tools/mcp/tool-search.js

@@ -2,6 +2,7 @@ import { MarAgentError } from '../../error.js';
 import { countModelTokens } from '../../runtime/token-budget.js';
 import { projectCodeModeSearchResult, projectCodeModeTools } from '../code-mode/index.js';
 import { assertMcpToolCatalog } from './catalog.js';
+import { orderToolDefinitions, stableToolDefinition } from '../definition-projection.js';
 export const TOOL_SEARCH_LIMITS = Object.freeze({
     defaultLimit: 5,
     maximumLimit: 20,
@@ -65,7 +66,11 @@ export class DeferredMcpRegistry {
     }
     update(catalog, eligible, options = {}) {
         assertMcpToolCatalog(catalog, options);
-        this.#catalog = { ...catalog, tools: catalog.tools.filter(eligible) };
+        this.#catalog = {
+            ...catalog,
+            servers: [...catalog.servers].sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0),
+            tools: catalog.tools.filter(eligible)
+        };
         const validSession = new Set(this.#catalog.tools
             .filter((tool) => tool.lifetime === 'session' && tool.exposure === 'deferred')
             .map((tool) => tool.definition.name));
@@ -128,12 +133,12 @@ export class DeferredMcpRegistry {
         });
     }
     projectDirect(base) {
-        return [
+        return orderToolDefinitions([
             ...base,
             ...this.#catalog.tools
                 .filter((tool) => tool.exposure === 'direct')
                 .map((tool) => tool.definition)
-        ];
+        ]).map(stableToolDefinition);
     }
     project(base, selection = this.#selected, executionSelection = this.#executionSelected) {
         const deferred = new Map(this.#catalog.tools
@@ -145,7 +150,10 @@ export class DeferredMcpRegistry {
                 .map((name) => deferred.get(name))
                 .filter((tool) => tool?.lifetime === 'execution')
         ];
-        return [...this.projectDirect(base), ...active.map((tool) => tool.definition)];
+        return [
+            ...this.projectDirect(base),
+            ...active.map((tool) => stableToolDefinition(tool.definition))
+        ];
     }
     search(query, limit) {
         const exact = this.#catalog.tools.find((tool) => tool.definition.name === query);

package/dist/cli/main.js

@@ -20,7 +20,7 @@ Usage:
   maragent run <prompt> [--reasoning-effort EFFORT] [--format text|json|stream-json] [--codex-auth-file PATH]
   maragent resume [sessionId] [--reasoning-effort EFFORT] [--codex-auth-file PATH]
   maragent sessions list|delete <sessionId>
-  maragent models list|add|edit|remove|test [id] [--default-reasoning-effort EFFORT] [--code-mode|--no-code-mode] [--high-density-compaction|--no-high-density-compaction] [--fast-mode|--no-fast-mode] [--codex-auth-file PATH]
+  maragent models list|add|edit|remove|test [id] [--default-reasoning-effort EFFORT] [--code-mode|--no-code-mode] [--fast-mode|--no-fast-mode] [--codex-auth-file PATH]
 `;
 function takeOption(arguments_, name) {
     const index = arguments_.indexOf(name);
@@ -63,6 +63,9 @@ async function readApiKey() {
     return value.trim();
 }
 async function modelsCommand(home, arguments_, codexAuthFile) {
+    if (arguments_.includes('--high-density-compaction') ||
+        arguments_.includes('--no-high-density-compaction'))
+        throw new MarAgentError('MAR_AGENT_CLI_ARGUMENT_INVALID', 'High-density compaction is no longer a model option.');
     if (arguments_.includes('--responses-encoding'))
         throw new MarAgentError('MAR_AGENT_CLI_ARGUMENT_INVALID', 'Responses encoding is no longer configurable.');
     const action = arguments_[1];
@@ -164,8 +167,8 @@ async function modelsCommand(home, arguments_, codexAuthFile) {
                     : required(existing?.apiKey?.reveal(), '--api-key-stdin'))
             }),
         modelId: required(option('--model', existing?.modelId), '--model'),
-        contextWindowTokens: integer('--context', existing?.contextWindowTokens ?? 200_000),
-        maxOutputTokens: integer('--max-output', existing?.maxOutputTokens ?? 16_384),
+        contextWindowTokens: integer('--context', existing?.contextWindowTokens ?? 256_000),
+        maxOutputTokens: integer('--max-output', existing?.maxOutputTokens ?? 32_000),
         inputCapabilities: booleanFlag(arguments_, '--image', '--no-image', existing?.inputCapabilities.includes('IMAGE') ?? false)
             ? ['TEXT', 'IMAGE']
             : ['TEXT'],
@@ -179,7 +182,6 @@ async function modelsCommand(home, arguments_, codexAuthFile) {
             : parseReasoningEffort(defaultReasoningEffortOption, '--default-reasoning-effort'),
         titleGeneration: existing?.titleGeneration ?? false,
         codeMode: booleanFlag(arguments_, '--code-mode', '--no-code-mode', existing?.codeMode ?? false),
-        highDensityCompaction: booleanFlag(arguments_, '--high-density-compaction', '--no-high-density-compaction', existing?.highDensityCompaction ?? false),
         ...(credential === 'codex-auth-file' && fastMode ? { fastMode: true } : {}),
         ...(protocol === 'OPENAI_RESPONSES' && existing?.serviceTier !== undefined
             ? {

package/package.json

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