@myagentroam/agent 0.9.173 → 0.9.175

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

@@ -24,7 +24,7 @@ export interface CoreCompactContext {
     readonly messages: readonly CoreCompactMessage[];
     readonly focus?: string;
     readonly summaryTokenBudget: number;
-    /** Return the Core compaction contract selected for this operation's main model snapshot. */
+    /** Return the Core's default structured handoff contract, independent of model configuration. */
     readonly getPrompt: () => string;
     /** Private, bounded telemetry only; reporting never changes the generation result. */
     readonly reportDiagnostic?: (diagnostic: CoreCompactDiagnostic) => Promise<void>;

package/dist/agent-core/extensions/model-request.js

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { isDeepStrictEqual } from 'node:util';
 import { resolveModelTextBlocks } from '../model/text-blocks.js';
+import { orderToolDefinitions, stableToolDefinition } from '../tools/definition-projection.js';
 import { MarAgentError } from '../error.js';
 /** Only actual SDK model dispatch records snapshots; public views carry no raw payload authority. */
 export class ExtensionRequestSnapshots {
@@ -151,6 +152,11 @@ export class ExtensionRequestBridge {
             };
         });
         const { toolChoice: _toolChoice, reasoningEffort: _reasoningEffort, images: _images, systemBlocks: _systemBlocks, ...retained } = this.original;
+        // Middleware selects declarations; it must not reorder a retained discovery prefix.
+        const order = new Map(this.original.tools.map((tool, index) => [tool.name, index]));
+        const tools = orderToolDefinitions(structuredClone(view.tools))
+            .sort((left, right) => (order.get(left.name) ?? order.size) - (order.get(right.name) ?? order.size))
+            .map(stableToolDefinition);
         return {
             ...retained,
             system: view.system,
@@ -158,7 +164,7 @@ export class ExtensionRequestBridge {
                 ? {}
                 : { systemBlocks: resolveModelTextBlocks(view.system, view.systemBlocks) }),
             messages,
-            tools: structuredClone(view.tools),
+            tools,
             ...(view.toolChoice ? { toolChoice: view.toolChoice } : {}),
             ...(view.reasoningEffort ? { reasoningEffort: view.reasoningEffort } : {}),
             ...(view.images ? { images: structuredClone(view.images) } : {})

package/dist/agent-core/extensions/model-stream.js

@@ -59,7 +59,10 @@ function validEvent(event) {
             return typeof event.sourceRef === 'string';
         case 'response.started':
             return typeof event.responseId === 'string';
+        case 'output.started':
         case 'output.delta':
+        case 'output.paused':
+        case 'output.completed':
         case 'output.reset':
             return true;
         case 'text.delta':
@@ -87,7 +90,8 @@ function validEvent(event) {
                 typeof event.citation.id === 'string' &&
                 typeof event.citation.url === 'string');
         case 'usage':
-            return (!!event.usage &&
+            return ((event.final === undefined || typeof event.final === 'boolean') &&
+                !!event.usage &&
                 typeof event.usage === 'object' &&
                 Object.values(event.usage).every((value) => value === undefined ||
                     (typeof value === 'number' && Number.isFinite(value) && value >= 0)));

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

@@ -1,4 +1,5 @@
 import { observationModelParts } from '../tools/code-mode/observations.js';
+import { stableToolSchema } from '../tools/definition-projection.js';
 import { randomUUID } from 'node:crypto';
 import { MarAgentError } from '../error.js';
 import { resolveModelDefaultReasoningEffort } from './configuration.js';
@@ -38,7 +39,7 @@ export class AnthropicMessagesAdapter {
             await reportModelAttempt(request, { ...attemptDiagnostic, state: 'STARTED' });
             try {
                 for await (const event of this.startAttempt(request, signal)) {
-                    if (event.type === 'output.delta') {
+                    if (event.type.startsWith('output.')) {
                         resetOutputTiming = true;
                         yield event;
                         continue;
@@ -97,7 +98,7 @@ export class AnthropicMessagesAdapter {
             : request.tools.map((tool) => ({
                 name: tool.name,
                 description: tool.description,
-                input_schema: tool.inputSchema
+                input_schema: stableToolSchema(tool.inputSchema)
             }));
         const response = await fetchModelResponse(`${this.configuration.baseUrl.replace(/\/$/, '')}/v1/messages`, {
             method: 'POST',
@@ -149,18 +150,19 @@ export class AnthropicMessagesAdapter {
             if (type === 'message_start') {
                 const message = record(event.message);
                 responseId = text(message.id) ?? responseId;
-                yield { type: 'response.started', responseId };
+                yield observeModelStreamEvent({ type: 'response.started', responseId }, modelStreamEventObservedAt(raw));
                 const usage = record(message.usage);
                 const inputTokens = inputTokenCount(usage.input_tokens);
                 const cacheReadTokens = inputTokenCount(usage.cache_read_input_tokens);
                 const cacheWriteTokens = inputTokenCount(usage.cache_creation_input_tokens);
                 latestInputUsage = inputUsage(inputTokens, cacheReadTokens, cacheWriteTokens);
-                yield {
+                yield observeModelStreamEvent({
                     type: 'usage',
+                    final: false,
                     usage: {
                         ...latestInputUsage
                     }
-                };
+                }, modelStreamEventObservedAt(raw));
             }
             else if (type === 'content_block_start') {
                 const block = record(event.content_block);
@@ -173,16 +175,18 @@ export class AnthropicMessagesAdapter {
                     for (const blockIndex of pendingTextBlocks) {
                         const pending = blocks.get(blockIndex);
                         if (pending?.type === 'text')
-                            yield {
+                            yield observeModelStreamEvent({
                                 type: 'text.completed',
                                 itemId: pending.id,
                                 phase: 'commentary',
                                 text: pending.text
-                            };
+                            }, modelStreamEventObservedAt(raw));
                     }
                     pendingTextBlocks.clear();
                 }
                 const id = text(block.id) ?? `${responseId}:content-${index}`;
+                if (['text', 'thinking', 'redacted_thinking', 'tool_use', 'server_tool_use'].includes(blockType))
+                    yield observeModelStreamEvent({ type: 'output.started' }, modelStreamEventObservedAt(raw));
                 blocks.set(index, {
                     type: blockType,
                     id,
@@ -193,18 +197,18 @@ export class AnthropicMessagesAdapter {
                     ...(blockType === 'redacted_thinking' ? { data: block.data } : {})
                 });
                 if (blockType === 'text' && text(block.text))
-                    yield {
+                    yield observeModelStreamEvent({
                         type: 'text.delta',
                         itemId: id,
                         phase: 'commentary',
                         delta: text(block.text) ?? ''
-                    };
+                    }, modelStreamEventObservedAt(raw));
                 else if (blockType === 'server_tool_use') {
                     const toolName = text(block.name) ?? 'unknown';
                     const kind = toolName === 'web_fetch' ? 'WEB_FETCH' : 'WEB_SEARCH';
                     const summary = anthropicHostedInputSummary(record(block.input));
                     hostedTools.set(id, { kind, toolName, summary });
-                    yield {
+                    yield observeModelStreamEvent({
                         type: 'hosted_tool',
                         itemId: id,
                         kind,
@@ -212,7 +216,7 @@ export class AnthropicMessagesAdapter {
                         ...(Object.keys(summary).length ? { input: summary } : {}),
                         status: 'RUNNING',
                         summary
-                    };
+                    }, modelStreamEventObservedAt(raw));
                 }
                 else if (blockType === 'web_search_tool_result' ||
                     blockType === 'web_fetch_tool_result') {
@@ -227,7 +231,7 @@ export class AnthropicMessagesAdapter {
                             ...(Array.isArray(result) && result.length > 20 ? { sourcesTruncated: true } : {})
                         };
                         hostedTools.set(toolId, { ...hosted, summary });
-                        yield {
+                        yield observeModelStreamEvent({
                             type: 'hosted_tool',
                             itemId: toolId,
                             kind: hosted.kind,
@@ -246,7 +250,7 @@ export class AnthropicMessagesAdapter {
                             ...(summary.sourcesTruncated ? { truncated: true } : {}),
                             status: anthropicHostedResultFailed(result) ? 'FAILED' : 'COMPLETED',
                             summary
-                        };
+                        }, modelStreamEventObservedAt(raw));
                     }
                 }
             }
@@ -282,10 +286,10 @@ export class AnthropicMessagesAdapter {
                     const citation = record(delta.citation);
                     const url = text(citation.url);
                     if (url)
-                        yield {
+                        yield observeModelStreamEvent({
                             type: 'citation',
                             citation: { id: `${block.id}-citation`, url, title: text(citation.title) }
-                        };
+                        }, modelStreamEventObservedAt(raw));
                 }
             }
             else if (type === 'content_block_stop') {
@@ -301,12 +305,13 @@ export class AnthropicMessagesAdapter {
                             throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Anthropic returned an invalid or oversized native thinking block.');
                         thinkingBytes += Buffer.byteLength(JSON.stringify(item));
                         assertAnthropicThinkingBudget(thinkingBytes);
-                        yield { type: 'response.item', provider: 'ANTHROPIC_MESSAGES', item };
+                        yield observeModelStreamEvent({ type: 'response.item', provider: 'ANTHROPIC_MESSAGES', item }, modelStreamEventObservedAt(raw));
                     }
                     if (block.type === 'thinking' && block.text)
-                        yield { type: 'reasoning.summary', itemId: block.id, text: block.text };
+                        yield observeModelStreamEvent({ type: 'reasoning.summary', itemId: block.id, text: block.text }, modelStreamEventObservedAt(raw));
                 }
                 else if (block?.type === 'server_tool_use') {
+                    yield observeModelStreamEvent({ type: 'output.paused' }, modelStreamEventObservedAt(raw));
                     const hosted = hostedTools.get(block.id);
                     if (hosted !== undefined) {
                         let input;
@@ -319,7 +324,7 @@ export class AnthropicMessagesAdapter {
                         const summary = { ...hosted.summary, ...anthropicHostedInputSummary(record(input)) };
                         if (summary.query !== hosted.summary.query || summary.url !== hosted.summary.url) {
                             hostedTools.set(block.id, { ...hosted, summary });
-                            yield {
+                            yield observeModelStreamEvent({
                                 type: 'hosted_tool',
                                 itemId: block.id,
                                 kind: hosted.kind,
@@ -327,7 +332,7 @@ export class AnthropicMessagesAdapter {
                                 input: anthropicHostedInputSummary(record(input)),
                                 status: 'RUNNING',
                                 summary
-                            };
+                            }, modelStreamEventObservedAt(raw));
                         }
                     }
                 }
@@ -340,18 +345,20 @@ export class AnthropicMessagesAdapter {
                     catch {
                         argumentError = 'Tool arguments are invalid JSON.';
                     }
-                    yield {
+                    yield observeModelStreamEvent({
                         type: 'client_tool.call',
                         callId: block.id,
                         name: block.name ?? 'unknown',
                         arguments: args,
                         ...(argumentError ? { argumentError } : {})
-                    };
+                    }, modelStreamEventObservedAt(raw));
                 }
             }
             else if (type === 'message_delta') {
                 const delta = record(event.delta);
                 const reason = text(delta.stop_reason);
+                if (reason !== undefined)
+                    yield observeModelStreamEvent({ type: 'output.completed' }, modelStreamEventObservedAt(raw));
                 terminal =
                     reason === 'tool_use'
                         ? 'tool_use'
@@ -364,7 +371,7 @@ export class AnthropicMessagesAdapter {
                 for (const blockIndex of pendingTextBlocks) {
                     const block = blocks.get(blockIndex);
                     if (block?.type === 'text')
-                        yield { type: 'text.completed', itemId: block.id, phase, text: block.text };
+                        yield observeModelStreamEvent({ type: 'text.completed', itemId: block.id, phase, text: block.text }, modelStreamEventObservedAt(raw));
                 }
                 pendingTextBlocks.clear();
                 const usage = record(event.usage);
@@ -375,13 +382,14 @@ export class AnthropicMessagesAdapter {
                 const zeroPlaceholder = inputTokens === 0 && cacheReadTokens === 0 && cacheWriteTokens === 0;
                 if (!zeroPlaceholder)
                     latestInputUsage = inputUsage(inputTokens ?? latestInputUsage?.inputTokens, cacheReadTokens ?? latestInputUsage?.cacheReadTokens, cacheWriteTokens ?? latestInputUsage?.cacheWriteTokens);
-                yield {
+                yield observeModelStreamEvent({
                     type: 'usage',
+                    final: reason !== undefined,
                     usage: {
                         ...latestInputUsage,
                         outputTokens: number(usage.output_tokens)
                     }
-                };
+                }, modelStreamEventObservedAt(raw));
             }
             else if (type === 'message_stop') {
                 yield observeModelStreamEvent({ type: 'completed', reason: terminal ?? 'completed' }, modelStreamEventObservedAt(raw));
@@ -399,7 +407,7 @@ export class AnthropicMessagesAdapter {
                     : {});
             }
             else
-                yield { type: 'unknown', nativeType: type };
+                yield observeModelStreamEvent({ type: 'unknown', nativeType: type }, modelStreamEventObservedAt(raw));
         }
         if (terminal === undefined)
             throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Anthropic Messages stream ended without a terminal event.', {
@@ -462,6 +470,8 @@ function anthropicHostedResultFailed(result) {
     return entries.some((entry) => text(record(entry).type)?.endsWith('_tool_result_error'));
 }
 function isSemanticEvent(event) {
+    if (event.type.startsWith('output.'))
+        return false;
     return event.type !== 'response.started' && event.type !== 'usage';
 }
 export function isAnthropicRecoverableStreamError(error) {

package/dist/agent-core/model/catalog-file.d.ts

@@ -28,7 +28,6 @@ export declare function serializeModel(model: CliModelConfiguration): {
     defaultReasoningEffort?: "low" | "medium" | "high" | "xhigh" | "max" | "ultra" | undefined;
     titleGeneration: boolean;
     codeMode: boolean;
-    highDensityCompaction: boolean;
     fastMode?: boolean | undefined;
     serviceTier?: "default" | "auto" | "flex" | "priority" | "fast" | "ultrafast" | undefined;
     hostedWebSearch: boolean;
@@ -55,7 +54,6 @@ export declare function serializeModel(model: CliModelConfiguration): {
     defaultReasoningEffort?: "low" | "medium" | "high" | "xhigh" | "max" | "ultra" | undefined;
     titleGeneration: boolean;
     codeMode: boolean;
-    highDensityCompaction: boolean;
     fastMode?: boolean | undefined;
     serviceTier?: "default" | "auto" | "flex" | "priority" | "fast" | "ultrafast" | undefined;
     hostedWebSearch: boolean;

package/dist/agent-core/model/catalog-file.js

@@ -52,6 +52,13 @@ function parseCliModelCatalog(input, options = {}) {
         return parseModelCatalog(input, options);
     const externalCredentialModels = new Set();
     const normalizedModels = input.models.map((model, index) => {
+        if (isRecord(model) && Object.hasOwn(model, 'highDensityCompaction')) {
+            if (typeof model.highDensityCompaction !== 'boolean')
+                throw invalidCatalog();
+            const { highDensityCompaction: _compaction, ...configuration } = model;
+            void _compaction;
+            model = configuration;
+        }
         if (isRecord(model) && Object.hasOwn(model, 'responsesEncoding')) {
             if (model.protocol !== 'OPENAI_RESPONSES' ||
                 (model.responsesEncoding !== 'STANDARD' && model.responsesEncoding !== 'LITE'))

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

@@ -69,7 +69,6 @@ declare const rawModelSchema: z.ZodObject<{
     }>>;
     titleGeneration: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     codeMode: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    highDensityCompaction: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     fastMode: z.ZodOptional<z.ZodBoolean>;
     serviceTier: z.ZodOptional<z.ZodEnum<{
         default: "default";

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

@@ -49,7 +49,6 @@ const rawModelSchema = z
     defaultReasoningEffort: marAgentReasoningEffortSchema.optional(),
     titleGeneration: z.boolean().optional().default(false),
     codeMode: z.boolean().optional().default(false),
-    highDensityCompaction: z.boolean().optional().default(false),
     fastMode: z.boolean().optional(),
     serviceTier: z.enum(['auto', 'default', 'flex', 'priority', 'fast', 'ultrafast']).optional(),
     hostedWebSearch: z.boolean(),

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

@@ -51,6 +51,12 @@ export interface ModelAttemptDiagnostic {
     connectionId?: string;
     connectionReused?: boolean;
     proxyType?: 'DIRECT' | 'SOCKS5';
+    /** Hashes of the lowered full logical request; never include credentials or raw bodies. */
+    requestInstructionsHash?: string;
+    requestToolsHash?: string;
+    requestPropertiesHash?: string;
+    requestInputHash?: string;
+    requestInputItems?: number;
     /** Actual serialized WebSocket request size, including inline image Base64. */
     requestBytes?: number;
     imageCount?: number;
@@ -113,8 +119,14 @@ export type ModelStopReason = 'completed' | 'tool_use' | 'pause' | 'max_output'
 export type ModelEvent = {
     type: 'response.started';
     responseId: string;
+} | {
+    type: 'output.started';
 } | {
     type: 'output.delta';
+} | {
+    type: 'output.paused';
+} | {
+    type: 'output.completed';
 } | {
     type: 'output.reset';
 } | {
@@ -173,6 +185,7 @@ export type ModelEvent = {
 } | {
     type: 'usage';
     usage: ModelUsage;
+    final?: boolean;
 } | {
     type: 'unknown';
     nativeType: string;