@myagentroam/agent 0.9.85 → 0.9.86

package/dist/model/contracts.d.ts

@@ -5,7 +5,6 @@ export interface ModelContinuationCheckpoint {
     readonly configurationHash: string;
     readonly responseId: string;
     readonly inputPrefixLength: number;
-    readonly inputPrefixHash: string;
 }
 export interface ClientToolDefinition {
     name: string;

package/dist/model/openai-responses.js

@@ -35,9 +35,14 @@ export class OpenAiResponsesAdapter {
         if (this.#cacheLeased ||
             this.#cachedState.lastRequest !== undefined ||
             this.#cachedState.lastResponse !== undefined ||
-            !responsesContinuationEnabled(this.#configuration) ||
+            !responsesPersistedContinuationEnabled(this.#configuration) ||
             checkpoint.version !== 2 ||
             checkpoint.protocol !== 'OPENAI_RESPONSES' ||
+            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;
@@ -656,7 +661,7 @@ class OpenAiResponsesTurnSession {
         clearResponsesContinuation(this.state);
     }
     continuationCheckpoint() {
-        if (!responsesContinuationEnabled(this.adapter.configuration))
+        if (!responsesPersistedContinuationEnabled(this.adapter.configuration))
             return undefined;
         const request = this.state.lastRequest;
         const response = this.state.lastResponse;
@@ -668,8 +673,7 @@ class OpenAiResponsesTurnSession {
             protocol: 'OPENAI_RESPONSES',
             configurationHash: responsesContinuationIdentityHash(this.adapter.configuration),
             responseId: response.responseId,
-            inputPrefixLength: baseline.length,
-            inputPrefixHash: hashResponsesValue(baseline)
+            inputPrefixLength: baseline.length
         };
     }
     prepareRequest(request) {
@@ -885,10 +889,7 @@ function incrementalResponsesInput(state, current) {
     const completion = state.lastResponse;
     if (previous === undefined || completion === undefined) {
         const restored = state.restoredContinuation;
-        if (restored === undefined ||
-            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);
@@ -920,6 +921,9 @@ 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({
         bearer: credential.bearer.reveal(),
@@ -1460,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

@@ -1605,8 +1605,7 @@ function isModelContinuationCheckpoint(value) {
         isBoundedString(checkpoint.configurationHash, 64) &&
         isBoundedString(checkpoint.responseId, 1_024) &&
         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/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.85",
+  "version": "0.9.86",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",