@myagentroam/agent 0.11.61 → 0.11.62

package/dist/cli/main.js

@@ -9,6 +9,7 @@ import { readModelCatalog, writeModelCatalog } from './catalog-file.js';
 import { AgentError, createAgent, agentReasoningEffortSchema, resolveModelDefaultReasoningEffort, SecretValue, testAgentModelTransport } from '../index.js';
 import { CodexAuthFileCredentialProvider } from './codex-auth-file.js';
 import { generateSessionTitle } from '../shared/auto-title.js';
+import { TerminalInput, TerminalInputClosed } from './terminal-input.js';
 const HELP = `maragent - MAR coding agent
 
 Usage:
@@ -261,21 +262,22 @@ async function main() {
     // `run` does not need stdin until a question occurs. Create
     // readline lazily so a closed or pseudo-TTY stream in an external harness
     // cannot fail the execution before its first model request.
-    let terminal;
-    const requireTerminal = () => (terminal ??= createInterface({ input: stdin, output: stdout }));
+    const terminal = new TerminalInput(() => createInterface({ input: stdin, output: stdout }));
     const host = new LocalAgentHost({
         homeDirectory: home,
         workspace,
-        question: async (request) => {
+        question: async (request, signal) => {
             if (!stdin.isTTY)
                 throw new AgentError('MAR_AGENT_USER_INPUT_UNAVAILABLE', 'Interactive input is unavailable.');
-            const answers = {};
-            for (const question of request.questions) {
-                const value = question;
-                const id = typeof value.id === 'string' ? value.id : String(Object.keys(answers).length);
-                answers[id] = await requireTerminal().question(`${typeof value.question === 'string' ? value.question : JSON.stringify(question)} `);
-            }
-            return answers;
+            return terminal.run(signal, async (ask) => {
+                const answers = {};
+                for (const question of request.questions) {
+                    const value = question;
+                    const id = typeof value.id === 'string' ? value.id : String(Object.keys(answers).length);
+                    answers[id] = await ask(`${typeof value.question === 'string' ? value.question : JSON.stringify(question)} `);
+                }
+                return answers;
+            });
         }
     });
     const runtime = runtimeModels(catalog.models, codexAuthFile);
@@ -311,7 +313,7 @@ async function main() {
             const listed = (await agent.listSessions());
             for (const item of listed.sessions ?? [])
                 stdout.write(`${item.id}\t${item.title}\t${item.lastActivityAt}\n`);
-            resumeId = (await requireTerminal().question('Session ID: ')).trim();
+            resumeId = (await terminal.run(undefined, (ask) => ask('Session ID: '))).trim();
             if (!resumeId)
                 throw new AgentError('MAR_AGENT_CLI_ARGUMENT_INVALID', 'Session id is required.');
         }
@@ -329,7 +331,7 @@ async function main() {
             if (activeHandle)
                 activeHandle.cancel();
             else
-                terminal?.close();
+                terminal.close();
             titleController?.abort();
             process.exitCode = 130;
             if (interrupts > 1)
@@ -338,8 +340,16 @@ async function main() {
         process.on('SIGINT', interrupt);
         try {
             do {
-                if (interactive)
-                    prompt = await requireTerminal().question('> ');
+                if (interactive) {
+                    try {
+                        prompt = await terminal.run(undefined, (ask) => ask('> '));
+                    }
+                    catch (error) {
+                        if (error instanceof TerminalInputClosed)
+                            break;
+                        throw error;
+                    }
+                }
                 if (!prompt.trim())
                     break;
                 const invocation = parseExecutionInvocation(prompt);
@@ -409,7 +419,7 @@ async function main() {
         }
     }
     finally {
-        terminal?.close();
+        terminal.close();
         await agent.dispose();
     }
 }

package/dist/cli/subagent/control.js

@@ -49,7 +49,7 @@ export function registerControlTools(context, agent, observations, warmObservati
         name: 'agent_send',
         description: 'Send a message to a direct child or report to the direct parent.',
         allowedCallers: ['direct', 'programmatic'],
-        parallelSafety: 'serial',
+        parallelSafety: 'safe',
         inputSchema: {
             type: 'object',
             properties: {
@@ -70,7 +70,7 @@ export function registerControlTools(context, agent, observations, warmObservati
         name: 'agent_stop',
         description: 'Stop a direct child execution and wait for its cleanup.',
         allowedCallers: ['direct', 'programmatic'],
-        parallelSafety: 'serial',
+        parallelSafety: 'safe',
         inputSchema: {
             type: 'object',
             properties: {

package/dist/cli/subagent/start.js

@@ -44,7 +44,7 @@ export function registerStart(context, agent, admission) {
         name: 'agent_start',
         description: 'Start a child Session and return its identity without waiting for completion.',
         allowedCallers: ['direct', 'programmatic'],
-        parallelSafety: 'serial',
+        parallelSafety: 'safe',
         inputSchema: {
             type: 'object',
             properties: {

package/dist/cli/terminal-input.d.ts

@@ -0,0 +1,12 @@
+import { createInterface } from 'node:readline/promises';
+export declare class TerminalInputClosed extends Error {
+    constructor();
+}
+/** One interactive transaction at a time per terminal, including multi-question requests. */
+export declare class TerminalInput {
+    #private;
+    private readonly create;
+    constructor(create: () => ReturnType<typeof createInterface>);
+    run<T>(signal: AbortSignal | undefined, work: (ask: (prompt: string) => Promise<string>) => Promise<T>): Promise<T>;
+    close(): void;
+}

package/dist/cli/terminal-input.js

@@ -0,0 +1,86 @@
+export class TerminalInputClosed extends Error {
+    constructor() {
+        super('Terminal input is closed.');
+    }
+}
+/** One interactive transaction at a time per terminal, including multi-question requests. */
+export class TerminalInput {
+    create;
+    #terminal;
+    #tail = Promise.resolve();
+    #lines = [];
+    #waiter;
+    #closed = false;
+    constructor(create) {
+        this.create = create;
+    }
+    run(signal, work) {
+        const operation = this.#tail.then(async () => {
+            signal?.throwIfAborted();
+            return work((prompt) => this.#ask(prompt, signal));
+        });
+        this.#tail = operation.then(() => undefined, () => undefined);
+        if (!signal)
+            return operation;
+        return new Promise((resolve, reject) => {
+            const aborted = () => reject(signal.reason);
+            if (signal.aborted)
+                aborted();
+            else
+                signal.addEventListener('abort', aborted, { once: true });
+            operation.then(resolve, reject).finally(() => signal.removeEventListener('abort', aborted));
+        });
+    }
+    #ask(prompt, signal) {
+        signal?.throwIfAborted();
+        if (this.#closed) {
+            const line = this.#lines.shift();
+            return line === undefined ? Promise.reject(new TerminalInputClosed()) : Promise.resolve(line);
+        }
+        if (!this.#terminal) {
+            this.#terminal = this.create();
+            this.#terminal.on('line', (line) => {
+                const waiter = this.#waiter;
+                if (waiter) {
+                    this.#waiter = undefined;
+                    waiter.resolve(line);
+                }
+                else
+                    this.#lines.push(line);
+            });
+            this.#terminal.on('close', () => {
+                this.#closed = true;
+                const waiter = this.#waiter;
+                this.#waiter = undefined;
+                waiter?.reject(new TerminalInputClosed());
+            });
+        }
+        this.#terminal.setPrompt(prompt);
+        this.#terminal.prompt();
+        const line = this.#lines.shift();
+        if (line !== undefined)
+            return Promise.resolve(line);
+        return new Promise((resolve, reject) => {
+            const finish = (callback) => {
+                signal?.removeEventListener('abort', abort);
+                callback();
+            };
+            const abort = () => {
+                this.#waiter = undefined;
+                finish(() => reject(signal.reason));
+            };
+            this.#waiter = {
+                resolve: (value) => finish(() => resolve(value)),
+                reject: (error) => finish(() => reject(error))
+            };
+            signal?.addEventListener('abort', abort, { once: true });
+            if (signal?.aborted)
+                abort();
+        });
+    }
+    close() {
+        this.#closed = true;
+        this.#lines = [];
+        this.#terminal?.close();
+    }
+}

package/dist/host/local-tool-registry.js

@@ -71,8 +71,8 @@ export class LocalToolRegistry {
             ],
             [
                 'apply_patch',
-                async (arguments_) => {
-                    const result = await patch.execute(applyPatchToolInput(arguments_));
+                async (arguments_, context) => {
+                    const result = await patch.execute(applyPatchToolInput(arguments_), context.signal);
                     return { content: JSON.stringify(result), data: result };
                 }
             ],

package/dist/tools/agent/question.js

@@ -4,7 +4,7 @@ import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
 export const questionToolDefinition = {
     name: 'question',
     allowedCallers: ['direct'],
-    parallelSafety: 'serial',
+    parallelSafety: 'safe',
     description: 'Pause for one to three tightly related user-owned decisions that materially change the result and cannot be inferred from the request, conversation, or relevant safe discovery. Prefer asking over guessing in Plan mode; do not avoid clarification by inventing configuration, branches, abstractions, or support for multiple outcomes. Provide 2-3 mutually exclusive options with consequences, put the recommended option first and identify it in its label or description, and use another question round if key ambiguity remains. This is not a permission/approval tool and should not interrupt routine in-scope work.',
     inputSchema: {
         type: 'object',

package/dist/tools/agent/sleep.js

@@ -4,7 +4,7 @@ import { waitForToolCondition } from '../wait.js';
 export const sleepToolDefinition = {
     name: 'sleep',
     allowedCallers: ['direct'],
-    parallelSafety: 'serial',
+    parallelSafety: 'safe',
     description: 'Pause for up to durationMs milliseconds. Returns early when user input or a new public subagent message is available. Returns elapsed time and the wake reason.',
     inputSchema: {
         type: 'object',

package/dist/tools/agent/todo-write.js

@@ -3,7 +3,7 @@ import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
 export const todoWriteToolDefinition = {
     name: 'todo_write',
     allowedCallers: ['direct', 'programmatic'],
-    parallelSafety: 'serial',
+    parallelSafety: 'safe',
     description: 'Replace this session’s entire Todo list with the supplied items; no prior read is required. Preserve stable IDs and statuses only when extending the same objective. For a materially different objective, include only the new objective’s items. Do not retain completed items from an earlier objective; when all current items are completed, default a substantive new request to replacement unless the user explicitly asks to continue, extend, verify, or follow up. Use only after Todo has been chosen for coordination-heavy work; straightforward bounded work does not need it. Keep at most one in_progress item and update statuses after meaningful stage changes. When another substantive tool call is already ready and does not depend on the Todo result, include both in the same model response instead of spending a response only for Todo bookkeeping.',
     inputSchema: {
         type: 'object',

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

@@ -78,7 +78,7 @@ observe.result(patched);
         additionalProperties: false
     },
     allowedCallers: ['direct'],
-    parallelSafety: 'serial'
+    parallelSafety: 'safe'
 };
 export const codeExecWaitToolDefinition = {
     name: 'code_exec_wait',

package/dist/tools/contracts.d.ts

@@ -13,6 +13,7 @@ export interface ClientToolDefinition extends ModelToolDefinition {
     eventInputFields?: readonly string[];
     /** Runtime-only exposure override; retains both permitted entry points with Code Mode enabled. */
     codeModeExposure?: 'both';
+    /** Runtime-only scheduling policy; defaults to safe. Serial calls are exclusive barriers. */
     parallelSafety?: 'safe' | 'serial';
     /** Preserved business-schema eligibility after framework metadata projection. */
     parameterless?: boolean;

package/dist/tools/local/apply-patch.d.ts

@@ -15,5 +15,5 @@ export declare class ApplyPatchTool {
     #private;
     private readonly paths;
     constructor(paths: WorkspacePathResolver, operations?: Partial<PatchFileOperations>);
-    execute(patch: string): Promise<ApplyPatchResult>;
+    execute(patch: string, signal?: AbortSignal): Promise<ApplyPatchResult>;
 }

package/dist/tools/local/apply-patch.js

@@ -10,7 +10,7 @@ export const applyPatchToolDefinition = {
     name: 'apply_patch',
     allowedCallers: ['direct', 'programmatic'],
     codeModeExposure: 'both',
-    parallelSafety: 'serial',
+    parallelSafety: 'safe',
     description: `Preferred for precise, reviewable local edits. Do not batch all task files merely to reduce tool calls. Group only a few tightly coupled edits whose combined patch is quick to generate and review; split broad or independent work into successive bounded patches before composing them. Submit a raw *** Begin Patch / *** End Patch patch, each marker on its own line. Surrounding marker whitespace and an optional trailing *** are accepted; incomplete markers or extra text are rejected. Add File content lines, including blank lines, must start with +. Syntax errors include line/column and a bounded excerpt of the submitted patch with a caret at the error. Supports Add File, Update File, Delete File, and Move to. Add File may replace an existing regular file, and Move to may replace an existing regular destination; duplicate operations on the same resolved path remain invalid. Update hunks accept @@ or @@ <change context>. Context-only hunks, including trailing hunks, and unchanged file sections are validated in order but are not written or reported as edits. The patch must include a change or move. Context is searched forward with Codex-style exact, whitespace-tolerant, then common Unicode punctuation-tolerant matching. Syntax and resolved paths are validated before writing, then file units are committed in order. Each file unit is atomic, and a Move keeps its source and destination atomic. On MAR_AGENT_PATCH_PARTIAL, earlier files remain applied; the error lists applied, failed, and pending paths, so retry only failed and pending paths. Existing file permissions, line endings, and final-newline state are preserved. Returns changed file paths and operations with per-file and total line counts when all units succeed. In Code Mode, the Promise resolves on success and rejects with code/message on failure; the returned envelope has data.files and data.totals, not an ok or success flag. Oversized patches are rejected without advertising defensive limits as recommended patch sizes. A first-unit MAR_AGENT_PATCH_CONFLICT applies nothing; hunk match conflicts identify the affected path and hunk so you can reread only that file before retrying.`,
     inputMode: 'freeform',
     outputSchema: {
@@ -67,11 +67,20 @@ const utf8Decoder = new TextDecoder('utf-8', { fatal: true });
 export class ApplyPatchTool {
     paths;
     #fileOperations;
+    #tail = Promise.resolve();
     constructor(paths, operations = {}) {
         this.paths = paths;
         this.#fileOperations = { ...defaultFileOperations, ...operations };
     }
-    async execute(patch) {
+    execute(patch, signal) {
+        const result = this.#tail.then(() => {
+            signal?.throwIfAborted();
+            return this.#apply(patch);
+        });
+        this.#tail = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    async #apply(patch) {
         const changes = parsePatch(patch);
         reserveFileChangePaths(changes.flatMap((change) => change.kind === 'update' && change.targetPath
             ? [change.path, change.targetPath]

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

@@ -25,7 +25,7 @@ export const toolSearchToolDefinition = {
         additionalProperties: false
     },
     allowedCallers: ['direct'],
-    parallelSafety: 'serial',
+    parallelSafety: 'safe',
     nativeType: 'tool_search'
 };
 export function parseToolSearchInput(input) {

package/dist/tools/scheduler.js

@@ -35,7 +35,7 @@ export function createSessionToolScheduler() {
         const inherited = leases.getStore();
         const parent = inherited?.ingress === sessionToolIngress.getStore() ? inherited : undefined;
         const result = (parent?.active ? parent.schedule : root)({
-            name: definition?.parallelSafety === 'safe' ? 'safe' : 'serial',
+            name: definition?.parallelSafety === 'serial' ? 'serial' : 'safe',
             run
         });
         if (parent?.active) {
@@ -52,7 +52,7 @@ export function createToolCallScheduler(definitions, execute) {
     let barrier = Promise.resolve();
     const readers = new Set();
     return (call) => {
-        const safe = safety.get(call.name) === 'safe';
+        const safe = safety.get(call.name) !== 'serial';
         const gate = safe ? barrier : Promise.all([barrier, ...readers]).then(() => undefined);
         const result = gate.then(() => execute(call));
         const settled = result.then(() => undefined, () => undefined);
@@ -72,13 +72,13 @@ export async function scheduleToolCallBatch(calls, definitions, execute) {
     const results = new Array(calls.length);
     let index = 0;
     while (index < calls.length) {
-        if (safety.get(calls[index].name) !== 'safe') {
+        if (safety.get(calls[index].name) === 'serial') {
             results[index] = await execute(calls[index]);
             index++;
             continue;
         }
         let end = index + 1;
-        while (end < calls.length && safety.get(calls[end].name) === 'safe')
+        while (end < calls.length && safety.get(calls[end].name) !== 'serial')
             end++;
         const segment = await Promise.all(calls.slice(index, end).map((call) => execute(call)));
         for (let segmentIndex = 0; segmentIndex < segment.length; segmentIndex++)

package/package.json

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