@myagentroam/agent 0.9.65 → 0.9.66

package/dist/subagent/session-controller.js

@@ -8,6 +8,7 @@ export class SubagentSessionController {
     limits;
     #agents = new Map();
     #queue = [];
+    #completionWaiters = new Set();
     #running = 0;
     #disposed = false;
     #createdInExecution = 0;
@@ -20,7 +21,8 @@ export class SubagentSessionController {
     }
     static async open(input) {
         const controller = new SubagentSessionController(input.parentSessionId, input.rootSessionId, input.backend, input.limits);
-        for (const session of await input.backend.listChildren(input.parentSessionId))
+        const sessions = await input.backend.listChildren(input.parentSessionId);
+        for (const session of sessions)
             controller.#agents.set(session.id, restoreAgentState(session));
         return controller;
     }
@@ -130,9 +132,27 @@ export class SubagentSessionController {
         if (waitMs !== undefined &&
             state.turn &&
             (state.status === 'queued' || state.status === 'running'))
-            await waitForCompletion(state.turn.completion, waitMs, options.signal);
+            await this.#waitForCompletion(state, waitMs, options.signal);
         return this.#snapshot(state);
     }
+    async outputAny(options = {}) {
+        options.signal?.throwIfAborted();
+        validateOutputOptions(options);
+        const states = [...this.#agents.values()];
+        if (states.length === 0)
+            throw new MarAgentError('MAR_AGENT_SUBAGENT_NOT_FOUND', 'Subagent was not found.');
+        const live = states.filter((state) => state.status === 'queued' || state.status === 'running');
+        if (live.length === 0 || options.waitMs === 0)
+            return this.#snapshot(live.at(-1) ?? states.at(-1));
+        const waitMs = options.waitMs === undefined
+            ? undefined
+            : Math.max(options.waitMs, TOOL_EXECUTION_LIMITS.agentWaitWaitFloorMs);
+        if (waitMs !== undefined) {
+            await this.#waitForAnyCompletion(live, waitMs, options.signal);
+        }
+        const completed = live.find((state) => state.status !== 'queued' && state.status !== 'running');
+        return this.#snapshot(completed ?? live.at(-1));
+    }
     async message(agentId, message, options = {}) {
         const execution = this.#requireExecution();
         if (typeof message !== 'string' ||
@@ -211,6 +231,7 @@ export class SubagentSessionController {
             state.terminalPending = true;
             await this.#publishTerminal(state);
             state.turn.resolve();
+            this.#notifyCompletion(state);
             delete state.turn;
             this.#drain();
         }
@@ -241,6 +262,7 @@ export class SubagentSessionController {
             state.status = 'cancelled';
             this.#closeReceipt(state);
             state.turn?.resolve();
+            this.#notifyCompletion(state);
             delete state.turn;
         }
         for (const state of this.#agents.values()) {
@@ -347,6 +369,7 @@ export class SubagentSessionController {
             this.#closeReceipt(state);
             this.#running--;
             turn.resolve();
+            this.#notifyCompletion(state);
             if (state.turn === turn)
                 delete state.turn;
             this.#drain();
@@ -359,6 +382,7 @@ export class SubagentSessionController {
         delete state.turn;
         this.#running--;
         turn?.resolve();
+        this.#notifyCompletion(state);
         await this.#publishTerminal(state);
         this.#drain();
     }
@@ -369,6 +393,16 @@ export class SubagentSessionController {
         state.errorMessage = diagnostic.message;
         state.terminalPending = true;
     }
+    #waitForAnyCompletion(candidates, waitMs, signal) {
+        return waitForCompletionNotification(this.#completionWaiters, (state) => candidates.includes(state), waitMs, signal);
+    }
+    #waitForCompletion(state, waitMs, signal) {
+        return waitForCompletionNotification(this.#completionWaiters, (completed) => completed === state, waitMs, signal);
+    }
+    #notifyCompletion(state) {
+        for (const waiter of this.#completionWaiters)
+            waiter(state);
+    }
     #closeReceipt(state) {
         if (state.receipt?.deliveryStatus === 'accepted' && state.receipt.turnId === state.turn?.turnId)
             state.receipt.deliveryStatus = state.status === 'cancelled' ? 'cancelled' : 'failed';
@@ -404,6 +438,15 @@ export class SubagentSessionController {
         return this.#execution;
     }
     #snapshot(state) {
+        const terminal = state.status === 'completed' ||
+            state.status === 'failed' ||
+            state.status === 'cancelled' ||
+            state.status === 'interrupted';
+        const latestMessage = state.latestMessage === undefined
+            ? undefined
+            : terminal
+                ? { ...state.latestMessage }
+                : compactRunningLatestMessage(state.latestMessage);
         return {
             agentId: state.agentId,
             description: state.description,
@@ -412,11 +455,18 @@ export class SubagentSessionController {
             ...(state.modelId === undefined ? {} : { modelId: state.modelId }),
             ...(state.modelName === undefined ? {} : { modelName: state.modelName }),
             ...(state.reasoningEffort === undefined ? {} : { reasoningEffort: state.reasoningEffort }),
-            ...(state.latestMessage === undefined ? {} : { latestMessage: { ...state.latestMessage } }),
+            ...(latestMessage === undefined ? {} : { latestMessage }),
+            ...(state.latestActivity === undefined
+                ? {}
+                : { latestActivity: { ...state.latestActivity } }),
             ...(state.summary === undefined ? {} : { summary: state.summary }),
-            ...(state.changedFiles.length === 0 ? {} : { changedFiles: [...state.changedFiles] }),
-            ...(state.verification.length === 0 ? {} : { verification: [...state.verification] }),
-            ...(state.evidence.length === 0
+            ...(!terminal || state.changedFiles.length === 0
+                ? {}
+                : { changedFiles: [...state.changedFiles] }),
+            ...(!terminal || state.verification.length === 0
+                ? {}
+                : { verification: [...state.verification] }),
+            ...(!terminal || state.evidence.length === 0
                 ? {}
                 : { evidence: state.evidence.map((item) => ({ ...item })) }),
             ...(state.errorCode === undefined ? {} : { errorCode: state.errorCode }),
@@ -435,6 +485,16 @@ export class SubagentSessionController {
         }
     }
 }
+function compactRunningLatestMessage(message) {
+    if (message.phase !== 'commentary')
+        return { ...message };
+    const text = truncateCharacters(message.text, TOOL_EXECUTION_LIMITS.subagentRunningLatestMessageMaxCharacters);
+    return {
+        ...message,
+        text,
+        truncated: message.truncated === true || text !== message.text
+    };
+}
 function validateTaskInput(input) {
     if (input.parentSubagentId ||
         !input.description.trim() ||
@@ -486,10 +546,6 @@ function restoreAgentState(session) {
     const header = session.records.findLast((record) => record.type === 'execution.header' && isRecord(record.payload))?.payload;
     const terminal = currentRecords.findLast((record) => ['execution.completed', 'execution.failed', 'execution.cancelled'].includes(eventType(record) ?? ''));
     const terminalType = eventType(terminal);
-    const latestMessageRecord = session.records.findLast((record) => eventType(record) === 'message.completed');
-    const latestMessage = latestMessageRecord && isRecord(latestMessageRecord.payload)
-        ? latestMessageFromPayload(latestMessageRecord.payload)
-        : undefined;
     const state = {
         agentId: session.id,
         description: session.source.description,
@@ -515,36 +571,64 @@ function restoreAgentState(session) {
         ...(isReasoningEffort(header?.reasoningEffort)
             ? { reasoningEffort: header.reasoningEffort }
             : {}),
-        ...(latestMessage === undefined ? {} : { latestMessage }),
         changedFiles: [],
         verification: [],
         evidence: [],
         terminalPending: false
     };
-    if (state.status === 'completed' && latestMessage?.phase === 'final_answer')
-        state.summary = truncateUtf8(latestMessage.text, TOOL_EXECUTION_LIMITS.subagentSummaryMaxBytes);
+    for (const record of currentRecords) {
+        if (!isRecord(record.payload) ||
+            !['message.completed', 'tool.started', 'tool.completed', 'tool.failed'].includes(eventType(record) ?? ''))
+            continue;
+        const event = record.payload;
+        observeAgentEvent(state, event);
+    }
+    if (state.status === 'completed' && state.latestMessage?.phase === 'final_answer')
+        state.summary = truncateUtf8(state.latestMessage.text, TOOL_EXECUTION_LIMITS.subagentSummaryMaxBytes);
     if (state.status === 'failed' && terminal && isRecord(terminal.payload)) {
         if (typeof terminal.payload.code === 'string')
             state.errorCode = terminal.payload.code;
         if (typeof terminal.payload.message === 'string')
             state.errorMessage = terminal.payload.message;
     }
-    for (const record of currentRecords) {
-        if (!isRecord(record.payload) || eventType(record) !== 'tool.completed')
-            continue;
-        const event = record.payload;
-        if (event.type === 'tool.completed')
-            observeAgentEvent(state, event);
-    }
     return state;
 }
 function observeAgentEvent(state, event) {
     if (event.type === 'message.completed') {
         state.latestMessage = latestMessageFromEvent(event);
+        state.latestActivity = {
+            kind: 'message',
+            timestamp: event.timestamp,
+            phase: event.phase
+        };
+        return;
+    }
+    if (event.type === 'tool.started') {
+        state.latestActivity = {
+            kind: 'tool',
+            timestamp: event.timestamp,
+            toolName: event.toolName,
+            status: 'started'
+        };
+        return;
+    }
+    if (event.type === 'tool.failed') {
+        state.latestActivity = {
+            kind: 'tool',
+            timestamp: event.timestamp,
+            toolName: event.toolName,
+            status: 'failed'
+        };
         return;
     }
     if (event.type !== 'tool.completed')
         return;
+    state.latestActivity = {
+        kind: 'tool',
+        timestamp: event.timestamp,
+        toolName: event.toolName,
+        status: 'completed'
+    };
     if (event.toolName === 'apply_patch' && isRecord(event.data)) {
         const data = event.data;
         const files = Array.isArray(data.files) ? data.files : [];
@@ -643,7 +727,7 @@ function truncateCharacters(value, maximumCharacters) {
         ? value
         : characters.slice(0, maximumCharacters).join('');
 }
-function waitForCompletion(completion, waitMs, signal) {
+function waitForCompletionNotification(waiters, accepts, waitMs, signal) {
     return new Promise((resolve, reject) => {
         let settled = false;
         const finish = (error) => {
@@ -652,20 +736,32 @@ function waitForCompletion(completion, waitMs, signal) {
             settled = true;
             clearTimeout(timer);
             signal?.removeEventListener('abort', abort);
+            waiters.delete(notify);
             if (error === undefined)
                 resolve();
             else
                 reject(error);
         };
+        const notify = (value) => {
+            if (accepts(value))
+                finish();
+        };
         const abort = () => finish(signal?.reason ?? new MarAgentError('MAR_AGENT_EXECUTION_CANCELLED', 'Execution cancelled.'));
         const timer = setTimeout(finish, waitMs);
         timer.unref();
+        waiters.add(notify);
         signal?.addEventListener('abort', abort, { once: true });
-        void completion.then(() => finish());
         if (signal?.aborted)
             abort();
     });
 }
+function validateOutputOptions(options) {
+    if (options.waitMs !== undefined &&
+        (!Number.isInteger(options.waitMs) ||
+            options.waitMs < TOOL_EXECUTION_LIMITS.agentWaitMinWaitMs ||
+            options.waitMs > TOOL_EXECUTION_LIMITS.agentWaitMaxWaitMs))
+        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Task wait is invalid.');
+}
 function linkAbort(signal, abort) {
     const listener = () => abort();
     signal.addEventListener('abort', listener, { once: true });

package/dist/tools/agent-wait.js

@@ -3,7 +3,7 @@ import { TOOL_EXECUTION_LIMITS } from './execution-limits.js';
 export const agentWaitToolDefinition = {
     name: 'agent_wait',
     parallelSafety: 'serial',
-    description: 'Read or wait a bounded time for a child agent result using the agentId returned by agent_start. For an exec processId, use exec with action:"poll" instead. Omitting waitMs waits up to 30 seconds by default; waitMs=0 returns the current snapshot immediately. Positive waits range up to 5 minutes, and positive values below 10 seconds are raised to 10 seconds. Every result includes agentId and description. A queued or running result is not completion; wait again only when useful, or cancel if no longer needed. Terminal results include bounded summary, changedFiles, verification, and read evidence with path/line ranges; use that evidence to avoid repeating the full exploration, while independently checking consequential edits and claims. Preserve agentId and avoid busy polling.',
+    description: 'Read or wait a bounded time for a child agent result. Omit agentId to wait for whichever live child returns first, matching Codex-style untargeted waiting and avoiding UUID transcription; provide the exact agentId returned by agent_start only when observing a specific child. If no child is live, untargeted waiting reads the most recently created child. For an exec processId, use exec with action:"poll" instead. Omitting waitMs waits up to 30 seconds by default; waitMs=0 returns the current snapshot immediately. Positive waits range up to 5 minutes, and positive values below 10 seconds are raised to 10 seconds. Every result includes the real agentId and description. latestMessage is the most recent public assistant commentary/final message, never hidden reasoning or a tool result; latestActivity identifies whether the latest observed activity was a public message or a bounded tool started/completed/failed status. To request a fresh textual progress report, send an append agent_message and then wait. A queued or running result is not completion; wait again only when useful, or cancel if no longer needed. Terminal results include bounded summary, changedFiles, verification, and read evidence with path/line ranges; use that evidence to avoid repeating the full exploration, while independently checking consequential edits and claims. Avoid busy polling.',
     inputSchema: {
         type: 'object',
         properties: {
@@ -16,18 +16,21 @@ export const agentWaitToolDefinition = {
                 description: `Timeout in milliseconds. Defaults to ${TOOL_EXECUTION_LIMITS.agentWaitDefaultWaitMs}, min ${TOOL_EXECUTION_LIMITS.agentWaitMinWaitMs}, max ${TOOL_EXECUTION_LIMITS.agentWaitMaxWaitMs}. Zero returns immediately. Positive values below ${TOOL_EXECUTION_LIMITS.agentWaitWaitFloorMs} are raised to ${TOOL_EXECUTION_LIMITS.agentWaitWaitFloorMs}.`
             }
         },
-        required: ['agentId'],
         additionalProperties: false
     }
 };
 export async function executeAgentWait(arguments_, context) {
     const value = parseAgentWaitInput(arguments_);
-    if (!context.subagents)
+    const subagents = context.subagents;
+    if (!subagents)
         throw new MarAgentError('MAR_AGENT_SUBAGENT_RECURSION_DISABLED', 'Subagents cannot recurse.');
-    const task = await context.subagents.output(value.agentId, {
+    const options = {
         waitMs: value.waitMs ?? TOOL_EXECUTION_LIMITS.agentWaitDefaultWaitMs,
         signal: context.signal
-    });
+    };
+    const task = value.agentId === undefined
+        ? await subagents.outputAny(options)
+        : await subagents.output(value.agentId, options);
     return { content: JSON.stringify(task), data: task };
 }
 function parseAgentWaitInput(value) {
@@ -35,8 +38,9 @@ function parseAgentWaitInput(value) {
         return invalidAgentWait();
     const input = value;
     if (Object.keys(input).some((key) => !['agentId', 'waitMs'].includes(key)) ||
-        typeof input.agentId !== 'string' ||
-        input.agentId.trim().length === 0 ||
+        (input.agentId !== undefined &&
+            input.agentId !== null &&
+            (typeof input.agentId !== 'string' || input.agentId.trim().length === 0)) ||
         (input.waitMs !== undefined &&
             input.waitMs !== null &&
             (!Number.isInteger(input.waitMs) ||
@@ -44,7 +48,7 @@ function parseAgentWaitInput(value) {
                 input.waitMs > TOOL_EXECUTION_LIMITS.agentWaitMaxWaitMs)))
         return invalidAgentWait();
     return {
-        agentId: input.agentId,
+        ...(typeof input.agentId === 'string' ? { agentId: input.agentId.trim() } : {}),
         ...(typeof input.waitMs === 'number' ? { waitMs: input.waitMs } : {})
     };
 }

package/dist/tools/execution-limits.d.ts

@@ -34,6 +34,7 @@ export declare const TOOL_EXECUTION_LIMITS: Readonly<{
     subagentMessageMaxBytes: 131072;
     subagentReasoningEffortMaxCharacters: 64;
     subagentSummaryMaxBytes: 16384;
+    subagentRunningLatestMessageMaxCharacters: 2000;
     subagentEvidenceMaxItems: 64;
     subagentVerificationMaxItems: 16;
     subagentChangedFilesMaxItems: 200;

package/dist/tools/execution-limits.js

@@ -34,6 +34,7 @@ export const TOOL_EXECUTION_LIMITS = Object.freeze({
     subagentMessageMaxBytes: 131_072,
     subagentReasoningEffortMaxCharacters: 64,
     subagentSummaryMaxBytes: 16_384,
+    subagentRunningLatestMessageMaxCharacters: 2_000,
     subagentEvidenceMaxItems: 64,
     subagentVerificationMaxItems: 16,
     subagentChangedFilesMaxItems: 200,

package/dist/tools/view-image.js

@@ -44,7 +44,7 @@ export class ViewImageTool {
                 sha256: createHash('sha256').update(data).digest('hex')
             };
             return {
-                content: `Viewed image ${input.path} (${mimeType}, ${data.byteLength} bytes, sha256 ${metadata.sha256}).`,
+                content: `Viewed image ${input.path} (${mimeType}, ${data.byteLength} bytes).`,
                 data: metadata,
                 images: [{ mimeType, dataBase64: data.toString('base64') }]
             };

package/package.json

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