@myagentroam/agent 0.9.84 → 0.9.86

package/dist/model/configuration.js

@@ -80,6 +80,11 @@ const rawModelSchema = z
         });
     if (value.protocol !== 'OPENAI_RESPONSES' && value.responsesPreviousResponseId)
         context.addIssue({ code: 'custom', message: 'Responses continuation requires Responses.' });
+    if (value.responsesPreviousResponseId && value.responsesTransport?.transport !== 'WEBSOCKET')
+        context.addIssue({
+            code: 'custom',
+            message: 'Responses continuation requires WebSocket transport.'
+        });
     if (value.protocol !== 'OPENAI_RESPONSES' && value.responsesTransport !== undefined)
         context.addIssue({ code: 'custom', message: 'Responses transport requires Responses.' });
     if (value.protocol !== 'OPENAI_RESPONSES' && value.responsesEncoding !== undefined)

package/dist/model/contracts.d.ts

@@ -1,12 +1,10 @@
 import type { MarAgentModelConfiguration, MarAgentReasoningEffort, ModelCredentialAcquireReason } from './configuration.js';
 export interface ModelContinuationCheckpoint {
-    readonly version: 1;
+    readonly version: 2;
     readonly protocol: 'OPENAI_RESPONSES';
     readonly configurationHash: string;
     readonly responseId: string;
-    readonly requestPropertiesHash: string;
     readonly inputPrefixLength: number;
-    readonly inputPrefixHash: string;
 }
 export interface ClientToolDefinition {
     name: string;

package/dist/model/openai-responses.d.ts

@@ -45,8 +45,7 @@ declare class OpenAiResponsesTurnSession implements ModelTurnSession {
     private readonly adapter;
     private readonly state;
     private readonly cacheLease;
-    private readonly allowExternalContinuation;
-    constructor(adapter: OpenAiResponsesAdapter, state: ResponsesSessionState, cacheLease: boolean, allowExternalContinuation: boolean);
+    constructor(adapter: OpenAiResponsesAdapter, state: ResponsesSessionState, cacheLease: boolean);
     start(request: ModelRequest, signal: AbortSignal): AsyncIterable<ModelEvent>;
     close(): Promise<void>;
     resetContinuation(): void;

package/dist/model/openai-responses.js

@@ -35,14 +35,21 @@ export class OpenAiResponsesAdapter {
         if (this.#cacheLeased ||
             this.#cachedState.lastRequest !== undefined ||
             this.#cachedState.lastResponse !== undefined ||
+            !responsesPersistedContinuationEnabled(this.#configuration) ||
+            checkpoint.version !== 2 ||
             checkpoint.protocol !== 'OPENAI_RESPONSES' ||
-            checkpoint.configurationHash !== responsesConfigurationHash(this.#configuration))
+            typeof checkpoint.responseId !== 'string' ||
+            checkpoint.responseId.length === 0 ||
+            checkpoint.responseId.length > 1024 ||
+            !Number.isSafeInteger(checkpoint.inputPrefixLength) ||
+            checkpoint.inputPrefixLength < 0 ||
+            checkpoint.configurationHash !== responsesContinuationIdentityHash(this.#configuration))
             return false;
         this.#cachedState.restoredContinuation = checkpoint;
         return true;
     }
     async *start(request, signal) {
-        const turn = new OpenAiResponsesTurnSession(this, {}, false, true);
+        const turn = new OpenAiResponsesTurnSession(this, {}, false);
         try {
             yield* turn.start(request, signal);
         }
@@ -59,7 +66,7 @@ export class OpenAiResponsesAdapter {
             this.#cachedState = {};
             this.#cacheLeased = true;
         }
-        return new OpenAiResponsesTurnSession(this, state, cacheLease, false);
+        return new OpenAiResponsesTurnSession(this, state, cacheLease);
     }
     async close() {
         if (this.#closed)
@@ -546,17 +553,15 @@ class OpenAiResponsesTurnSession {
     adapter;
     state;
     cacheLease;
-    allowExternalContinuation;
     #active = false;
     #closed = false;
     #turnState;
     #fullBody;
     #connectionDiagnostic;
-    constructor(adapter, state, cacheLease, allowExternalContinuation) {
+    constructor(adapter, state, cacheLease) {
         this.adapter = adapter;
         this.state = state;
         this.cacheLease = cacheLease;
-        this.allowExternalContinuation = allowExternalContinuation;
     }
     async *start(request, signal) {
         if (this.#closed)
@@ -573,7 +578,7 @@ class OpenAiResponsesTurnSession {
             this.#fullBody = prepared.fullBody;
             if (this.adapter.configuration.responsesEncoding === 'LITE' &&
                 this.adapter.configuration.responsesTransport?.transport === 'WEBSOCKET' &&
-                this.adapter.configuration.responsesPreviousResponseId &&
+                responsesContinuationEnabled(this.adapter.configuration) &&
                 this.state.lastRequest === undefined &&
                 request.allowTools !== false &&
                 request.toolChoice !== 'none' &&
@@ -626,7 +631,7 @@ class OpenAiResponsesTurnSession {
                     completed = event.reason === 'completed' || event.reason === 'tool_use';
                 yield event;
             }
-            if (this.adapter.configuration.responsesPreviousResponseId &&
+            if (responsesContinuationEnabled(this.adapter.configuration) &&
                 completed &&
                 responseId !== undefined &&
                 (outputItems.length > 0 || !sawUnrepresentedOutput)) {
@@ -656,19 +661,19 @@ class OpenAiResponsesTurnSession {
         clearResponsesContinuation(this.state);
     }
     continuationCheckpoint() {
+        if (!responsesPersistedContinuationEnabled(this.adapter.configuration))
+            return undefined;
         const request = this.state.lastRequest;
         const response = this.state.lastResponse;
         if (request === undefined || response === undefined)
             return this.state.restoredContinuation;
         const baseline = [...request.input, ...response.outputItems];
         return {
-            version: 1,
+            version: 2,
             protocol: 'OPENAI_RESPONSES',
-            configurationHash: responsesConfigurationHash(this.adapter.configuration),
+            configurationHash: responsesContinuationIdentityHash(this.adapter.configuration),
             responseId: response.responseId,
-            requestPropertiesHash: responsesRequestPropertiesHash(request),
-            inputPrefixLength: baseline.length,
-            inputPrefixHash: hashResponsesValue(baseline)
+            inputPrefixLength: baseline.length
         };
     }
     prepareRequest(request) {
@@ -677,7 +682,7 @@ class OpenAiResponsesTurnSession {
             this.state.socket.readyState !== WebSocket.OPEN)
             invalidateResponsesWebSocket(this.state, false);
         const fullBody = responsesRequestBody(this.adapter.configuration, request, request.messages, this.adapter.prefixIdentity);
-        if (this.adapter.configuration.responsesPreviousResponseId) {
+        if (responsesContinuationEnabled(this.adapter.configuration)) {
             const incremental = incrementalResponsesInput(this.state, fullBody);
             if (incremental !== undefined) {
                 const responseId = this.state.lastResponse.responseId;
@@ -692,20 +697,6 @@ class OpenAiResponsesTurnSession {
                     continuation: true
                 };
             }
-            if (this.allowExternalContinuation &&
-                request.continuation !== undefined &&
-                this.adapter.configuration.responsesTransport?.transport !== 'WEBSOCKET') {
-                const deltaBody = responsesRequestBody(this.adapter.configuration, request, request.continuation.deltaMessages);
-                return {
-                    fullBody,
-                    body: {
-                        ...fullBody,
-                        input: deltaBody.input,
-                        previous_response_id: request.continuation.previousResponseId
-                    },
-                    continuation: true
-                };
-            }
         }
         return {
             fullBody,
@@ -898,17 +889,11 @@ function incrementalResponsesInput(state, current) {
     const completion = state.lastResponse;
     if (previous === undefined || completion === undefined) {
         const restored = state.restoredContinuation;
-        if (restored === undefined ||
-            restored.requestPropertiesHash !== responsesRequestPropertiesHash(current) ||
-            current.input.length < restored.inputPrefixLength ||
-            restored.inputPrefixHash !==
-                hashResponsesValue(current.input.slice(0, restored.inputPrefixLength)))
+        if (restored === undefined || current.input.length < restored.inputPrefixLength)
             return undefined;
         state.lastResponse = { responseId: restored.responseId, outputItems: [] };
         return current.input.slice(restored.inputPrefixLength);
     }
-    if (!responsesRequestPropertiesMatch(previous, current))
-        return undefined;
     const baseline = [...previous.input, ...completion.outputItems];
     if (current.input.length < baseline.length)
         return undefined;
@@ -917,37 +902,27 @@ function incrementalResponsesInput(state, current) {
             return undefined;
     return current.input.slice(baseline.length);
 }
-function responsesRequestPropertiesMatch(previous, current) {
-    return RESPONSES_REQUEST_PROPERTY_KEYS.every((key) => isDeepStrictEqual(previous[key], current[key]));
-}
 function clearResponsesContinuation(state) {
     delete state.lastRequest;
     delete state.lastResponse;
     delete state.restoredContinuation;
 }
-const RESPONSES_REQUEST_PROPERTY_KEYS = [
-    'model',
-    'instructions',
-    'tools',
-    'tool_choice',
-    'parallel_tool_calls',
-    'reasoning',
-    'store',
-    'stream',
-    'include',
-    'prompt_cache_key',
-    'text',
-    'client_metadata'
-];
-function responsesRequestPropertiesHash(request) {
-    return hashResponsesValue(Object.fromEntries(RESPONSES_REQUEST_PROPERTY_KEYS.map((key) => [key, request[key]])));
-}
 function hashResponsesValue(value) {
     return createHash('sha256').update(JSON.stringify(value)).digest('hex');
 }
-function responsesConfigurationHash(configuration) {
-    const { apiKey: _apiKey, credentialProvider: _credentialProvider, imageGeneration: _imageGeneration, ...identity } = configuration;
-    return hashResponsesValue(identity);
+function responsesContinuationIdentityHash(configuration) {
+    return hashResponsesValue({
+        endpoint: new URL(responsesEndpoint(configuration.baseUrl)).toString(),
+        modelId: configuration.modelId,
+        responsesEncoding: configuration.responsesEncoding ?? 'STANDARD'
+    });
+}
+function responsesContinuationEnabled(configuration) {
+    return (configuration.responsesPreviousResponseId === true &&
+        configuration.responsesTransport?.transport === 'WEBSOCKET');
+}
+function responsesPersistedContinuationEnabled(configuration) {
+    return responsesContinuationEnabled(configuration) && configuration.responsesEncoding !== 'LITE';
 }
 function responsesCredentialFingerprint(credential) {
     return hashResponsesValue({
@@ -1489,11 +1464,17 @@ function isInvalidPreviousResponseFields(code, message) {
         normalizedCode === 'invalid_previous_response_id')
         return true;
     const normalizedMessage = message?.toLowerCase().replaceAll('`', '') ?? '';
+    if ((normalizedCode === 'unsupported_parameter' ||
+        normalizedCode === 'unsupported_previous_response_id') &&
+        normalizedMessage.includes('previous_response_id'))
+        return true;
     return (normalizedMessage.includes('previous_response_id') &&
         (normalizedMessage.includes('invalid') ||
             normalizedMessage.includes('not found') ||
             normalizedMessage.includes('does not exist') ||
             normalizedMessage.includes('expired') ||
+            normalizedMessage.includes('not supported') ||
+            normalizedMessage.includes('unsupported') ||
             normalizedMessage.includes('unavailable')));
 }
 const RESPONSE_ITEM_TYPES = new Set([

package/dist/runtime/context-gc.js

@@ -632,7 +632,9 @@ function collectExecCandidates(input, groups, existingTargets, usageRatio) {
     }
     for (const startGroup of execGroups) {
         const start = invocations.get(startGroup.callId);
-        if (!start || start.input.action !== 'start')
+        if (!start ||
+            (start.input.action !== 'start' &&
+                !(start.input.action == null && typeof start.input.command === 'string')))
             continue;
         const lifecycle = [start];
         let processId;

package/dist/sdk/agent.js

@@ -1600,14 +1600,12 @@ function isModelContinuationCheckpoint(value) {
     if (value === null || typeof value !== 'object' || Array.isArray(value))
         return false;
     const checkpoint = value;
-    return (checkpoint.version === 1 &&
+    return (checkpoint.version === 2 &&
         checkpoint.protocol === 'OPENAI_RESPONSES' &&
         isBoundedString(checkpoint.configurationHash, 64) &&
         isBoundedString(checkpoint.responseId, 1_024) &&
-        isBoundedString(checkpoint.requestPropertiesHash, 64) &&
         Number.isSafeInteger(checkpoint.inputPrefixLength) &&
-        checkpoint.inputPrefixLength >= 0 &&
-        isBoundedString(checkpoint.inputPrefixHash, 64));
+        checkpoint.inputPrefixLength >= 0);
 }
 function isBoundedString(value, maximumLength) {
     return typeof value === 'string' && value.length > 0 && value.length <= maximumLength;

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

@@ -74,7 +74,11 @@ export function contextGcWebOutputReplacement(toolName, originalContent, truncat
 export function contextGcExecInputReplacement(arguments_, formatVersion = 3) {
     if (!isRecord(arguments_))
         return `<context_gc kind="terminal_exec_input"${formatVersion === 3 ? ' formatVersion="3"' : ''} originalBytes="${Buffer.byteLength(stableJson(arguments_))}"${formatVersion === 3 ? '' : ` originalSha256="${sha256(stableJson(arguments_))}"`} />`;
-    const action = typeof arguments_.action === 'string' ? arguments_.action : 'unknown';
+    const action = typeof arguments_.action === 'string'
+        ? arguments_.action
+        : typeof arguments_.command === 'string'
+            ? 'start'
+            : 'unknown';
     const original = stableJson(arguments_);
     const retained = {
         action,

package/dist/tools/agent-message.js

@@ -33,7 +33,10 @@ function parseAgentMessageInput(value) {
         return invalid();
     const input = value;
     if (Object.keys(input).some((key) => !['agentId', 'message', 'delivery'].includes(key)) ||
-        (input.delivery !== undefined && input.delivery !== 'append' && input.delivery !== 'replace') ||
+        (input.delivery !== undefined &&
+            input.delivery !== null &&
+            input.delivery !== 'append' &&
+            input.delivery !== 'replace') ||
         typeof input.agentId !== 'string' ||
         input.agentId.trim().length === 0 ||
         typeof input.message !== 'string' ||
@@ -43,7 +46,9 @@ function parseAgentMessageInput(value) {
     return {
         agentId: input.agentId.trim(),
         message: input.message,
-        ...(input.delivery === undefined ? {} : { delivery: input.delivery })
+        ...(input.delivery === 'append' || input.delivery === 'replace'
+            ? { delivery: input.delivery }
+            : {})
     };
 }
 function invalid() {

package/dist/tools/agent-start.js

@@ -62,6 +62,7 @@ function parseAgentStartInput(value) {
             input.modelId !== null &&
             (typeof input.modelId !== 'string' || input.modelId.trim().length === 0)) ||
         (input.reasoningEffort !== undefined &&
+            input.reasoningEffort !== null &&
             (typeof input.reasoningEffort !== 'string' ||
                 !marAgentReasoningEffortSchema.safeParse(input.reasoningEffort.trim()).success)) ||
         (input.background !== undefined &&

package/dist/tools/agent-wait.js

@@ -46,11 +46,14 @@ function parseAgentWaitInput(value) {
     const input = value;
     if (Object.keys(input).some((key) => !['agentId', 'waitFor', 'waitMs'].includes(key)) ||
         (input.agentId !== undefined &&
+            input.agentId !== null &&
             (typeof input.agentId !== 'string' || input.agentId.trim().length === 0)) ||
         (input.waitFor !== undefined &&
+            input.waitFor !== null &&
             input.waitFor !== 'completion' &&
             input.waitFor !== 'message') ||
         (input.waitMs !== undefined &&
+            input.waitMs !== null &&
             (!Number.isInteger(input.waitMs) ||
                 input.waitMs < TOOL_EXECUTION_LIMITS.agentWaitMinWaitMs ||
                 input.waitMs > TOOL_EXECUTION_LIMITS.agentWaitMaxWaitMs)))

package/dist/tools/exec.d.ts

@@ -2,7 +2,7 @@ import type { ClientToolDefinition } from '../model/contracts.js';
 import { type LocalProcessExecutor } from '../host/local-process-executor.js';
 import { WorkspacePathResolver } from './shared/path-resolver.js';
 export type ExecInput = {
-    action: 'start';
+    action?: 'start';
     command: string;
     cwd?: string;
     timeoutMs?: number;

package/dist/tools/exec.js

@@ -5,8 +5,8 @@ import { MarAgentError } from '../error.js';
 import { TOOL_EXECUTION_LIMITS } from './execution-limits.js';
 export const execToolDefinition = {
     name: 'exec',
-    parallelSafety: 'serial',
-    description: 'Unrestricted general system execution. start runs any platform-native command, script, text/file tool, builder, generator, network client, or program in workspace/default cwd and may return running with processId; poll waits up to yieldMs for new output or termination and returns only output produced since the prior result; write sends stdin; cancel terminates the process tree. Returns status, processId, incremental stdout/stderr, cumulative stdoutBytes/stderrBytes, per-result dropped bytes, exitCode, and truncated; a completed status does not imply exitCode 0. Always inspect stderr/exitCode and consume terminal output or cancel.',
+    parallelSafety: 'safe',
+    description: 'Unrestricted general system execution. Providing command starts any platform-native command, script, text/file tool, builder, generator, network client, or program in workspace/default cwd; action may be omitted for start. poll waits up to yieldMs for new output or termination and returns only output produced since the prior result; write sends stdin; cancel terminates the process tree. Returns status, processId, incremental stdout/stderr, cumulative stdoutBytes/stderrBytes, per-result dropped bytes, exitCode, and truncated; a completed status does not imply exitCode 0. Always inspect stderr/exitCode and consume terminal output or cancel.',
     outputSchema: {
         type: 'object',
         required: ['content', 'data'],
@@ -42,8 +42,14 @@ export const execToolDefinition = {
     inputSchema: {
         type: 'object',
         properties: {
-            action: { enum: ['start', 'poll', 'write', 'cancel'], description: 'Lifecycle operation.' },
-            command: { type: 'string', description: 'Required only for start.' },
+            action: {
+                enum: ['start', 'poll', 'write', 'cancel'],
+                description: 'Lifecycle operation. Omit when providing command to start a process.'
+            },
+            command: {
+                type: 'string',
+                description: 'Required for start; implies start when action is omitted.'
+            },
             cwd: {
                 type: 'string',
                 description: 'Optional relative/absolute start directory; defaults to workspace.'
@@ -59,7 +65,7 @@ export const execToolDefinition = {
             processId: { type: 'string', description: 'Required for poll, write and cancel.' },
             data: { type: 'string', description: 'stdin data required for write.' }
         },
-        required: ['action'],
+        required: [],
         additionalProperties: false
     }
 };
@@ -71,6 +77,7 @@ export class ExecTool {
     shell;
     processExecutor;
     #processes = new Map();
+    #startingProcesses = new Set();
     constructor(paths, maxOutputBytes = TOOL_EXECUTION_LIMITS.execDefaultMaxOutputBytes, maxProcesses = TOOL_EXECUTION_LIMITS.maxProcesses, environment = process.env, shell, processExecutor = directLocalProcessExecutor) {
         this.paths = paths;
         this.maxOutputBytes = maxOutputBytes;
@@ -83,7 +90,7 @@ export class ExecTool {
         if (signal?.aborted)
             throw executionAbortReason(signal);
         const input = parseExecInput(arguments_);
-        if (input.action !== 'start') {
+        if ('processId' in input) {
             const process = this.#processes.get(input.processId);
             if (!process || (owner !== undefined && process.ownerSessionId !== owner.sessionId))
                 throw new MarAgentError('MAR_AGENT_PROCESS_NOT_FOUND', 'Managed process was not found.');
@@ -98,38 +105,53 @@ export class ExecTool {
                 this.#processes.delete(input.processId);
             return result;
         }
-        if (this.#processes.size >= this.maxProcesses)
+        if (this.#processes.size + this.#startingProcesses.size >= this.maxProcesses)
             throw new MarAgentError('MAR_AGENT_PROCESS_LIMIT', 'The managed process limit was reached.');
-        const id = randomUUID();
-        const cwd = await this.paths.resolveWithDisplay(input.cwd ?? '.');
-        const child = await this.processExecutor.spawn({
-            command: input.command,
-            cwd: cwd.physicalPath,
-            shell: this.shell ?? true,
-            environment: this.environment,
-            detached: process.platform !== 'win32',
-            ...(owner === undefined ? {} : { owner }),
-            ...(signal === undefined ? {} : { signal })
-        });
-        let resolveExited;
-        let resolveSettled;
-        const managed = {
-            child,
+        let resolveStarting;
+        const starting = {
             ...(owner === undefined ? {} : { ownerSessionId: owner.sessionId }),
-            command: input.command,
-            cwd: cwd.displayPath,
-            stdout: createOutputBuffer(),
-            stderr: createOutputBuffer(),
-            status: 'running',
-            exited: new Promise((resolve) => (resolveExited = resolve)),
-            settled: new Promise((resolve) => (resolveSettled = resolve)),
-            resolveExited,
-            resolveSettled,
-            exitObserved: child.exitCode !== null,
-            finalized: false,
-            waiters: new Set()
+            settled: new Promise((resolve) => (resolveStarting = resolve)),
+            resolveSettled: () => resolveStarting()
         };
-        this.#processes.set(id, managed);
+        this.#startingProcesses.add(starting);
+        const id = randomUUID();
+        let child;
+        let managed;
+        try {
+            const cwd = await this.paths.resolveWithDisplay(input.cwd ?? '.');
+            child = await this.processExecutor.spawn({
+                command: input.command,
+                cwd: cwd.physicalPath,
+                shell: this.shell ?? true,
+                environment: this.environment,
+                detached: process.platform !== 'win32',
+                ...(owner === undefined ? {} : { owner }),
+                ...(signal === undefined ? {} : { signal })
+            });
+            let resolveExited;
+            let resolveSettled;
+            managed = {
+                child,
+                ...(owner === undefined ? {} : { ownerSessionId: owner.sessionId }),
+                command: input.command,
+                cwd: cwd.displayPath,
+                stdout: createOutputBuffer(),
+                stderr: createOutputBuffer(),
+                status: 'running',
+                exited: new Promise((resolve) => (resolveExited = resolve)),
+                settled: new Promise((resolve) => (resolveSettled = resolve)),
+                resolveExited,
+                resolveSettled,
+                exitObserved: child.exitCode !== null,
+                finalized: false,
+                waiters: new Set()
+            };
+            this.#processes.set(id, managed);
+        }
+        finally {
+            this.#startingProcesses.delete(starting);
+            starting.resolveSettled();
+        }
         child.stdout.on('data', (chunk) => {
             if (managed.finalized)
                 return;
@@ -182,6 +204,9 @@ export class ExecTool {
             : []);
     }
     async disposeSession(sessionId) {
+        await Promise.all([...this.#startingProcesses]
+            .filter((process) => process.ownerSessionId === sessionId)
+            .map((process) => process.settled));
         const owned = [...this.#processes.entries()].filter(([, process]) => process.ownerSessionId === sessionId);
         await Promise.all(owned.map(([, process]) => process.status === 'running' ? this.#terminate(process, false) : process.settled));
         for (const [processId] of owned)
@@ -239,6 +264,7 @@ export class ExecTool {
         };
     }
     async dispose() {
+        await Promise.all([...this.#startingProcesses].map((process) => process.settled));
         await Promise.all([...this.#processes.values()].map((process) => process.status === 'running' ? this.#terminate(process, false) : process.settled));
         this.#processes.clear();
     }
@@ -332,7 +358,7 @@ function parseExecInput(value) {
     if (!value || typeof value !== 'object')
         return invalidExecInput();
     const input = value;
-    const action = input.action;
+    const action = input.action == null && typeof input.command === 'string' ? 'start' : input.action;
     if (!['start', 'poll', 'write', 'cancel'].includes(String(action)))
         return invalidExecInput();
     const yieldMs = optionalBoundedInteger(input.yieldMs, 0, TOOL_EXECUTION_LIMITS.execMaxYieldMs);
@@ -343,7 +369,7 @@ function parseExecInput(value) {
             return invalidExecInput();
         const timeoutMs = optionalBoundedInteger(input.timeoutMs, 1, TOOL_EXECUTION_LIMITS.execMaxTimeoutMs);
         return {
-            action,
+            ...(input.action === 'start' ? { action: 'start' } : {}),
             command: input.command,
             ...(typeof input.cwd === 'string' ? { cwd: input.cwd } : {}),
             ...(timeoutMs === undefined ? {} : { timeoutMs }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/agent",
-  "version": "0.9.84",
+  "version": "0.9.86",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",
@@ -42,6 +42,7 @@
     "build": "node ../scripts/clean-build-output.mjs dist && tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test:unit": "vitest run --config vitest.config.ts test/unit",
+    "analyze:session": "node test/tools/session-analyzer.mjs",
     "benchmark:compaction": "node test/e2e/compaction-benchmark.mjs",
     "test:performance": "vitest run --config vitest.performance.config.ts",
     "test:memory": "node --expose-gc ./node_modules/vitest/vitest.mjs run --config vitest.memory.config.ts",