@myagentroam/agent 0.10.26 → 0.10.28

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

@@ -1,13 +1,15 @@
 import type { MarAgentReasoningEffort } from '../model/configuration.js';
-import type { SubagentController, SubagentTaskSnapshot, SubagentHandledResult } from '../subagent/contracts.js';
+import type { SubagentController, SubagentTaskSnapshot, SubagentManyOutput, SubagentHandledResult } from '../subagent/contracts.js';
 import type { CoreOperationContext } from './operation.js';
 import type { ExtensionResourceScope } from './resources.js';
 import type { ExtensionHooks } from './hooks.js';
 import type { CoreDomainOperations, CoreDomainFacts, CoreCapabilitySnapshot } from './contracts.js';
 export type CoreAgentSnapshot = Readonly<SubagentTaskSnapshot>;
+export type CoreAgentManySnapshot = Readonly<SubagentManyOutput>;
+export type CoreAgentWaitResult = CoreAgentSnapshot | CoreAgentManySnapshot;
 export type CoreAgentHandledResult = SubagentHandledResult;
 export type CoreAgentSpawnResult = CoreAgentSnapshot | CoreAgentHandledResult;
-export declare function isHandledAgentResult(value: CoreAgentSpawnResult): value is CoreAgentHandledResult;
+export declare function isHandledAgentResult(value: CoreAgentSpawnResult | CoreAgentManySnapshot): value is CoreAgentHandledResult;
 export interface CoreAgentSpawnInput {
     readonly turnSignal?: AbortSignal;
     readonly waitFor?: 'start' | 'completion';
@@ -26,6 +28,8 @@ export interface CoreAgentTarget {
 export interface CoreAgentWaitInput {
     readonly untilSettled?: true;
     readonly agentId?: string;
+    readonly agentIds?: readonly string[];
+    readonly mode?: 'any' | 'all';
     readonly signal?: AbortSignal;
     readonly waitMs?: number;
     readonly waitFor?: 'completion' | 'message';
@@ -39,7 +43,7 @@ export interface CoreAgentsBackend {
     spawn(input: CoreAgentSpawnInput, call: CoreOperationContext): Promise<CoreAgentSnapshot>;
     list(call: CoreOperationContext): Promise<readonly CoreAgentSnapshot[]>;
     inspect(input: CoreAgentTarget, call: CoreOperationContext): Promise<CoreAgentSnapshot>;
-    wait(input: CoreAgentWaitInput, call: CoreOperationContext): Promise<CoreAgentSnapshot>;
+    wait(input: CoreAgentWaitInput, call: CoreOperationContext): Promise<CoreAgentWaitResult>;
     message(input: CoreAgentMessageInput, call: CoreOperationContext): Promise<CoreAgentSnapshot>;
     cancel(input: CoreAgentTarget, call: CoreOperationContext): Promise<CoreAgentSnapshot>;
 }
@@ -49,7 +53,13 @@ export interface CoreAgentsApi {
         readonly signal?: AbortSignal;
     }): Promise<readonly CoreAgentSnapshot[]>;
     inspect(input: CoreAgentTarget): Promise<CoreAgentSnapshot>;
-    wait(input: CoreAgentWaitInput): Promise<CoreAgentSnapshot>;
+    wait(input: CoreAgentWaitInput & {
+        readonly agentIds: readonly string[];
+    }): Promise<CoreAgentManySnapshot>;
+    wait(input: CoreAgentWaitInput & {
+        readonly agentIds?: undefined;
+    }): Promise<CoreAgentSnapshot>;
+    wait(input: CoreAgentWaitInput): Promise<CoreAgentWaitResult>;
     message(input: CoreAgentMessageInput): Promise<CoreAgentSnapshot>;
     cancel(input: CoreAgentTarget): Promise<CoreAgentSnapshot>;
 }

package/dist/agent-core/extensions/agents.js

@@ -1,6 +1,7 @@
 import { MarAgentError } from '../error.js';
+import { parseAgentWaitTargets } from '../subagent/wait.js';
 export function isHandledAgentResult(value) {
-    return value.outcome === 'handled' && !Object.hasOwn(value, 'agentId');
+    return 'outcome' in value && value.outcome === 'handled' && !Object.hasOwn(value, 'agentId');
 }
 /** All callers share one interception and authoritative leaf-completion boundary. */
 export function invokeCoreAgentOperation(hooks, key, input, call, leaf) {
@@ -8,12 +9,16 @@ export function invokeCoreAgentOperation(hooks, key, input, call, leaf) {
         const result = structuredClone(await leaf(input, effective));
         if (isHandledAgentResult(result))
             return result;
-        await hooks.emit('agent.completed', {
-            operation: key.slice('agent.'.length),
-            agentId: result.agentId,
-            status: result.status,
-            ...(result.deliveryStatus === undefined ? {} : { deliveryStatus: result.deliveryStatus })
-        }, effective);
+        const agents = Array.isArray(result.agents)
+            ? result.agents
+            : [result];
+        for (const agent of agents)
+            await hooks.emit('agent.completed', {
+                operation: key.slice('agent.'.length),
+                agentId: agent.agentId,
+                status: agent.status,
+                ...(agent.deliveryStatus === undefined ? {} : { deliveryStatus: agent.deliveryStatus })
+            }, effective);
         return result;
     });
 }
@@ -46,9 +51,18 @@ function resolveAgentSpawn(input) {
     };
 }
 export function bindAgentController(controller, action) {
-    const wait = (input) => action('agent.wait', input, (target, call) => target.agentId === undefined
-        ? controller.outputAny({ ...target, signal: call.signal })
-        : controller.output(target.agentId, { ...target, signal: call.signal }));
+    const wait = (input) => action('agent.wait', input, (target, call) => {
+        const selection = parseAgentWaitTargets(target);
+        return selection.agentIds !== undefined
+            ? controller.outputMany(selection.agentIds, {
+                ...target,
+                mode: selection.mode ?? 'any',
+                signal: call.signal
+            })
+            : target.agentId === undefined
+                ? controller.outputAny({ ...target, signal: call.signal })
+                : controller.output(target.agentId, { ...target, signal: call.signal });
+    });
     return {
         run: (input, options) => {
             return action('agent.spawn', {
@@ -83,6 +97,7 @@ export function bindAgentController(controller, action) {
         },
         output: (id, options) => wait({ ...options, agentId: id }),
         outputAny: (options) => wait({ ...options }),
+        outputMany: (ids, options) => wait({ ...options, agentIds: ids }),
         message: (id, message, options) => action('agent.message', { ...options, agentId: id, message }, (target, call) => controller.message(target.agentId, target.message, {
             ...(target.delivery === undefined ? {} : { delivery: target.delivery }),
             signal: call.signal
@@ -146,11 +161,12 @@ export function bindCoreAgents(backend, scope, run, hooks) {
             const copied = target(input);
             return run(async (call) => structuredClone(await backend.inspect(copied, call)), copied.signal);
         },
-        wait: async (input) => {
+        wait: (async (input) => {
             if (!input || typeof input !== 'object' || Array.isArray(input))
                 throw invalid('Agent wait input is invalid.');
-            return invoke('agent.wait', input.agentId === undefined ? { ...input } : target(input));
-        },
+            const selection = parseAgentWaitTargets(input);
+            return invoke('agent.wait', input.agentId === undefined ? { ...input, ...selection } : target(input));
+        }),
         message: async (input) => invoke('agent.message', target(input)),
         cancel: async (input) => invoke('agent.cancel', target(input))
     };

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

@@ -4,7 +4,7 @@ import type { CorePromptInput, CorePromptResult } from './prompt-input.js';
 import type { CoreModelEvent } from './model-stream.js';
 import type { CorePromptComposition, CorePromptSectionInput } from './prompt-composition.js';
 import type { CoreModelsApi } from './models.js';
-import type { CoreAgentsApi, CoreAgentSpawnInput, CoreAgentWaitInput, CoreAgentMessageInput, CoreAgentTarget, CoreAgentSnapshot, CoreAgentSpawnResult, CoreAgentCompletion } from './agents.js';
+import type { CoreAgentsApi, CoreAgentSpawnInput, CoreAgentWaitInput, CoreAgentWaitResult, CoreAgentMessageInput, CoreAgentTarget, CoreAgentSnapshot, CoreAgentSpawnResult, CoreAgentCompletion } from './agents.js';
 import type { CoreDataApi } from './data.js';
 import type { CoreMcpApi, CoreMcpConnectInput, CoreMcpConnectionInput, CoreMcpConnectionRef, CoreMcpCatalog, CoreMcpCompletion } from './mcp.js';
 import type { CoreFilesApi, CoreFileOperations, CoreFileCompletion } from './files.js';
@@ -38,7 +38,7 @@ export interface CoreDomainOperations extends CoreFileOperations {
     };
     'agent.wait': {
         input: CoreAgentWaitInput;
-        output: CoreAgentSnapshot;
+        output: CoreAgentWaitResult;
     };
     'agent.message': {
         input: CoreAgentMessageInput;

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

@@ -10,6 +10,7 @@ import { fetchModelResponse, modelRetryMaxAttempts, isRetryableModelRequestError
 import { anthropicThinkingBlock, assertAnthropicThinkingBudget } from './anthropic-thinking.js';
 import { resolveModelTextBlocks } from './text-blocks.js';
 import { reportModelAttempt } from './attempt-diagnostics.js';
+import { productUserAgent } from './product-user-agent.js';
 export class AnthropicMessagesAdapter {
     configuration;
     constructor(configuration) {
@@ -108,6 +109,7 @@ export class AnthropicMessagesAdapter {
                 'x-api-key': apiKey.reveal(),
                 'anthropic-version': '2023-06-01',
                 'content-type': 'application/json',
+                'user-agent': productUserAgent(),
                 accept: 'text/event-stream'
             },
             body: JSON.stringify({

package/dist/agent-core/model/openai-responses.js

@@ -12,6 +12,7 @@ import { acquireModelCredential, appendModelCredentialHeaders, modelCredentialSe
 import { resolveModelTextBlocks } from './text-blocks.js';
 import { jsonToolInput } from './tool-input.js';
 import { reportModelAttempt } from './attempt-diagnostics.js';
+import { productUserAgent } from './product-user-agent.js';
 const WEBSOCKET_IDLE_TIMEOUT_MS = 300_000;
 const WEBSOCKET_SEND_FRAME_BYTES = 1024 * 1024;
 export const OPENAI_RESPONSES_EARLY_EOF_REASON = 'OPENAI_RESPONSES_EARLY_EOF';
@@ -1554,6 +1555,7 @@ function responsesHeaders(credential, promptCacheKey, turnState) {
         authorization: `Bearer ${credential.bearer.reveal()}`,
         'content-type': 'application/json',
         accept: 'text/event-stream',
+        'user-agent': productUserAgent(),
         'x-client-request-id': randomUUID(),
         ...(promptCacheKey
             ? {

package/dist/agent-core/model/product-user-agent.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Product identity sent to upstream model endpoints. Runtime credential headers may
+ * override this value per request.
+ */
+export declare function productUserAgent(): string;

package/dist/agent-core/model/product-user-agent.js

@@ -0,0 +1,22 @@
+import { readFileSync } from 'node:fs';
+let cachedUserAgent;
+/**
+ * Product identity sent to upstream model endpoints. Runtime credential headers may
+ * override this value per request.
+ */
+export function productUserAgent() {
+    cachedUserAgent ??= resolveProductUserAgent();
+    return cachedUserAgent;
+}
+function resolveProductUserAgent() {
+    try {
+        const raw = readFileSync(new URL('../../../package.json', import.meta.url), 'utf8');
+        const version = JSON.parse(raw).version;
+        if (typeof version === 'string' && version.length > 0 && version.length <= 64)
+            return 'MyAgentRoam/' + version + ' (' + process.platform + '; ' + process.arch + ')';
+    }
+    catch {
+        // Fall through to the identity-preserving fallback below.
+    }
+    return 'MyAgentRoam/unknown (' + process.platform + '; ' + process.arch + ')';
+}

package/dist/agent-core/runtime/events.d.ts

@@ -83,7 +83,7 @@ export type MarAgentEvent = MarAgentEventBase & ({
     summary: string;
     truncated?: boolean;
     artifacts?: readonly MarAgentToolArtifact[];
-    data?: CodeCellEventData | import('../tools/contracts.js').ExecResult | Omit<import('../tools/contracts.js').ExecResult, 'stdout' | 'stderr'> | import('../tools/contracts.js').ApplyPatchResult | import('../tools/contracts.js').ReadEventData | import('../tools/contracts.js').ViewImageResult | import('../subagent/contracts.js').SubagentTaskSnapshot;
+    data?: CodeCellEventData | import('../tools/contracts.js').ExecResult | Omit<import('../tools/contracts.js').ExecResult, 'stdout' | 'stderr'> | import('../tools/contracts.js').ApplyPatchResult | import('../tools/contracts.js').ReadEventData | import('../tools/contracts.js').ViewImageResult | import('../subagent/contracts.js').SubagentTaskSnapshot | import('../subagent/contracts.js').SubagentManyOutput;
 } | {
     type: 'tool.failed';
     resultExtensions?: readonly import('../tools/result-extensions.js').ToolResultExtension[];

package/dist/agent-core/sdk/extension-agents.js

@@ -1,4 +1,5 @@
 import { MarAgentError } from '../error.js';
+import { parseAgentWaitTargets } from '../subagent/wait.js';
 /** Uses the Session's sole task controller, including its durable children and queue. */
 export function createExtensionAgentsBackend(input) {
     const withController = async (call, run) => {
@@ -30,12 +31,18 @@ export function createExtensionAgentsBackend(input) {
         list: (call) => withController(call, async (controller) => controller.inspectAll()),
         inspect: (target, call) => withController(call, (controller) => controller.inspect(target.agentId)),
         wait: (target, call) => withController(call, (controller) => {
+            const selection = parseAgentWaitTargets(target);
             const options = {
                 waitMs: target.waitMs ?? 30_000,
                 ...(target.untilSettled === undefined ? {} : { untilSettled: target.untilSettled }),
                 ...(target.waitFor === undefined ? {} : { waitFor: target.waitFor }),
                 signal: call.signal
             };
+            if (selection.agentIds !== undefined)
+                return controller.outputMany(selection.agentIds, {
+                    ...options,
+                    mode: selection.mode ?? 'any'
+                });
             if (target.untilSettled && target.agentId === undefined)
                 throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'An unbounded wait requires an agent id.');
             return target.agentId === undefined

package/dist/agent-core/sdk/session.js

@@ -267,6 +267,7 @@ export function createSessionOpener(services) {
             let sequence = 0;
             let manualCompactionStarted = false;
             let emitTail = Promise.resolve();
+            let releaseSession;
             let exhaustedModelAttempt;
             // Serialize durable events before either the local stream or Host observes them.
             const emit = (event, assertLive) => {
@@ -283,7 +284,7 @@ export function createSessionOpener(services) {
                 const operation = emitTail.then(async () => {
                     assertLive?.();
                     const persistent = eventForPersistence(full);
-                    if (persistent !== undefined)
+                    if (persistent !== undefined && releaseSession !== undefined)
                         await store.append(sessionId, {
                             type: full.type,
                             payload: persistent,
@@ -337,7 +338,6 @@ export function createSessionOpener(services) {
                 let finalAnswer = '';
                 let executionLoop;
                 let manualCompaction;
-                let releaseSession;
                 let executionToolSources;
                 let selectedTurn;
                 const contextGc = new ContextGcRuntime();

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

@@ -81,6 +81,17 @@ export interface SubagentOutputOptions {
     waitFor?: SubagentWaitFor;
     signal?: AbortSignal;
 }
+export type SubagentWaitMode = 'any' | 'all';
+export interface SubagentManyOutputOptions extends Omit<SubagentOutputOptions, 'untilSettled'> {
+    mode?: SubagentWaitMode;
+}
+export interface SubagentManyOutput {
+    mode: SubagentWaitMode;
+    waitFor: SubagentWaitFor;
+    waitOutcome: SubagentWaitOutcome;
+    agents: SubagentTaskSnapshot[];
+    pendingAgentIds: string[];
+}
 export interface SubagentHandledResult {
     readonly outcome: 'handled';
     readonly value?: unknown;
@@ -91,6 +102,7 @@ export interface SubagentController {
     run(input: SubagentTaskInput, options?: SubagentRunOptions): Promise<SubagentRunResult>;
     output(agentId: string, options?: SubagentOutputOptions): Promise<SubagentTaskSnapshot>;
     outputAny(options?: SubagentOutputOptions): Promise<SubagentTaskSnapshot>;
+    outputMany(agentIds: readonly string[], options?: SubagentManyOutputOptions): Promise<SubagentManyOutput>;
     message(agentId: string, message: string, options?: SubagentMessageOptions): Promise<SubagentTaskSnapshot>;
     cancel(agentId: string): Promise<SubagentTaskSnapshot>;
     listSessionResources(): readonly {

package/dist/agent-core/subagent/scheduler.d.ts

@@ -1,5 +1,6 @@
+import type { SubagentManyOutput, SubagentManyOutputOptions } from './contracts.js';
 import type { SubagentController, SubagentOutputOptions, SubagentRunOptions, SubagentTaskInput, SubagentTaskResult, SubagentTaskSnapshot } from './contracts.js';
-export type { SubagentController, SubagentLatestActivity, SubagentLatestMessage, SubagentMessageOptions, SubagentOutputOptions, SubagentRunOptions, SubagentTaskInput, SubagentTaskResult, SubagentTaskSnapshot, SubagentWaitFor, SubagentWaitOutcome } from './contracts.js';
+export type { SubagentController, SubagentLatestActivity, SubagentLatestMessage, SubagentMessageOptions, SubagentManyOutput, SubagentManyOutputOptions, SubagentOutputOptions, SubagentRunOptions, SubagentTaskInput, SubagentTaskResult, SubagentTaskSnapshot, SubagentWaitFor, SubagentWaitOutcome } from './contracts.js';
 export declare class SubagentScheduler implements SubagentController {
     #private;
     readonly limits: {
@@ -118,6 +119,7 @@ export declare class SubagentScheduler implements SubagentController {
         turnId?: string;
         deliveryStatus?: "accepted" | "applied" | "cancelled" | "failed";
     }>;
+    outputMany(agentIds: readonly string[], options?: SubagentManyOutputOptions): Promise<SubagentManyOutput>;
     cancel(agentId: string): Promise<SubagentTaskSnapshot>;
     message(_agentId: string, _message: string): Promise<SubagentTaskSnapshot>;
     listSessionResources(): {

package/dist/agent-core/subagent/scheduler.js

@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { describeMarAgentError, MarAgentError } from '../error.js';
 import { marAgentReasoningEffortSchema } from '../model/configuration.js';
 import { TOOL_EXECUTION_LIMITS } from '../tools/execution-limits.js';
+import { parseAgentWaitTargets, waitForAgentCondition } from './wait.js';
 export class SubagentScheduler {
     limits;
     #tasks = new Map();
@@ -111,6 +112,49 @@ export class SubagentScheduler {
             waitOutcome: completed ? 'completion' : 'timeout'
         };
     }
+    async outputMany(agentIds, options = {}) {
+        options.signal?.throwIfAborted();
+        const { agentIds: ids, mode = 'any' } = parseAgentWaitTargets({ agentIds, mode: options.mode });
+        validateOutputOptions(options);
+        rejectUnsupportedMessageWait(options);
+        if (!ids || 'untilSettled' in options)
+            throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Group waits require explicit targets and a bounded deadline.');
+        const tasks = ids.map((id) => {
+            const task = this.#tasks.get(id);
+            if (!task)
+                throw new MarAgentError('MAR_AGENT_SUBAGENT_NOT_FOUND', 'Subagent task was not found.');
+            return task;
+        });
+        const terminal = (task) => task.status !== 'queued' && task.status !== 'running';
+        const snapshot = options.waitMs === undefined || options.waitMs === 0;
+        const satisfied = !snapshot &&
+            (await waitForAgentCondition({
+                ready: () => (mode === 'all' ? tasks.every(terminal) : tasks.some(terminal)),
+                subscribe: (notify) => {
+                    this.#completionWaiters.add(notify);
+                    return () => this.#completionWaiters.delete(notify);
+                },
+                waitMs: Math.max(options.waitMs, TOOL_EXECUTION_LIMITS.agentWaitWaitFloorMs),
+                signal: options.signal
+            }));
+        options.signal?.throwIfAborted();
+        return {
+            mode,
+            waitFor: 'completion',
+            waitOutcome: snapshot ? 'snapshot' : satisfied ? 'completion' : 'timeout',
+            pendingAgentIds: tasks.filter((task) => !terminal(task)).map((task) => task.agentId),
+            agents: tasks.map((task) => ({
+                ...this.#public(task),
+                waitOutcome: snapshot
+                    ? 'snapshot'
+                    : terminal(task)
+                        ? 'completion'
+                        : satisfied
+                            ? 'snapshot'
+                            : 'timeout'
+            }))
+        };
+    }
     async cancel(agentId) {
         const task = this.#tasks.get(agentId);
         if (!task)

package/dist/agent-core/subagent/session-controller.d.ts

@@ -3,6 +3,7 @@ import type { MarAgentReasoningEffort } from '../model/configuration.js';
 import type { ExecutionResult } from '../runtime/contracts.js';
 import type { MarAgentEvent } from '../runtime/events.js';
 import type { SessionRecord, SessionSource } from '../session/jsonl-store.js';
+import type { SubagentManyOutput, SubagentManyOutputOptions } from './contracts.js';
 import type { SubagentController, SubagentMessageOptions, SubagentOutputOptions, SubagentRunOptions, SubagentTaskInput, SubagentTaskSnapshot } from './scheduler.js';
 export interface SubagentModelOption {
     readonly id: string;
@@ -112,6 +113,7 @@ export declare class SubagentSessionController implements SubagentController {
     run(input: SubagentTaskInput, options?: SubagentRunOptions): Promise<SubagentTaskSnapshot>;
     output(agentId: string, options?: SubagentOutputOptions): Promise<SubagentTaskSnapshot>;
     outputAny(options?: SubagentOutputOptions): Promise<SubagentTaskSnapshot>;
+    outputMany(agentIds: readonly string[], options?: SubagentManyOutputOptions): Promise<SubagentManyOutput>;
     message(agentId: string, message: string, options?: SubagentMessageOptions): Promise<SubagentTaskSnapshot>;
     cancel(agentId: string): Promise<SubagentTaskSnapshot>;
     listSessionResources(): {

package/dist/agent-core/subagent/session-controller.js

@@ -2,6 +2,7 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 import { randomUUID } from 'node:crypto';
 import { MarAgentError, describeMarAgentError } from '../error.js';
 import { TOOL_EXECUTION_LIMITS } from '../tools/execution-limits.js';
+import { parseAgentWaitTargets, waitForAgentCondition, waitDeadline } from './wait.js';
 export class SubagentSessionController {
     parentSessionId;
     rootSessionId;
@@ -52,6 +53,7 @@ export class SubagentSessionController {
             message: (id, message, options) => enter(() => this.message(id, message, options)),
             output: (id, options) => this.output(id, options),
             outputAny: (options) => this.outputAny(options),
+            outputMany: (ids, options) => this.outputMany(ids, options),
             cancel: (id) => this.cancel(id),
             listSessionResources: () => this.listSessionResources(),
             dispose: () => this.dispose()
@@ -166,7 +168,7 @@ export class SubagentSessionController {
             verification: [],
             evidence: [],
             terminalPending: false,
-            terminalObserved: false,
+            observedTerminalRevision: -1,
             resourceRevision: ++this.#resourceRevision
         };
         if (!native)
@@ -356,6 +358,109 @@ export class SubagentSessionController {
             waitOutcome: completed ? 'completion' : 'timeout'
         };
     }
+    async outputMany(agentIds, options = {}) {
+        options.signal?.throwIfAborted();
+        const { agentIds: ids, mode = 'any' } = parseAgentWaitTargets({ agentIds, mode: options.mode }, this.#retainedExecution.getStore()?.native
+            ? Infinity
+            : TOOL_EXECUTION_LIMITS.agentWaitMaxAgents);
+        validateOutputOptions(options, this.#retainedExecution.getStore()?.native === true);
+        if (!ids || 'untilSettled' in options)
+            throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Group waits require a bounded deadline.');
+        const states = await Promise.all(ids.map((id) => this.#find(id)));
+        options.signal?.throwIfAborted();
+        const waitFor = options.waitFor ?? 'completion';
+        const targets = states.map((state) => ({
+            state,
+            turn: state.turn,
+            view: copyWaitState(state),
+            observation: this.#nativeObservation(state)
+        }));
+        const refresh = () => {
+            for (const target of targets) {
+                if (!isTerminalState(target.view) &&
+                    (target.state.turn === target.turn ||
+                        (target.state.turn === undefined && isTerminalState(target.state))))
+                    target.view = copyWaitState(target.state);
+            }
+        };
+        const unread = (target) => target.view.messageRevision >
+            (target.observation?.messageRevision ?? target.state.observedMessageRevision);
+        const ready = (target) => isTerminalState(target.view) || (waitFor === 'message' && unread(target));
+        const snapshot = options.waitMs === undefined || options.waitMs === 0;
+        let satisfied = false;
+        if (!snapshot) {
+            const waitMs = this.#retainedExecution.getStore()?.native
+                ? options.waitMs
+                : Math.max(options.waitMs, TOOL_EXECUTION_LIMITS.agentWaitWaitFloorMs);
+            satisfied = await waitForAgentCondition({
+                waitMs,
+                signal: options.signal,
+                ready: () => {
+                    refresh();
+                    return mode === 'all' ? targets.every(ready) : targets.some(ready);
+                },
+                subscribe: (notify) => {
+                    const listener = () => notify();
+                    this.#activityWaiters.add(listener);
+                    return () => this.#activityWaiters.delete(listener);
+                }
+            });
+            options.signal?.throwIfAborted();
+        }
+        refresh();
+        const pendingAgentIds = targets
+            .filter((target) => !ready(target))
+            .map((target) => target.state.agentId);
+        const agents = targets.map((target) => {
+            const { state, view, observation } = target;
+            const terminal = isTerminalState(view);
+            const outcome = snapshot
+                ? 'snapshot'
+                : terminal
+                    ? 'completion'
+                    : ready(target)
+                        ? 'message'
+                        : satisfied
+                            ? 'snapshot'
+                            : 'timeout';
+            const includeLatestMessage = outcome !== 'snapshot' && unread(target);
+            const includeTerminalDetails = outcome === 'completion' &&
+                (observation
+                    ? observation.terminalRevision < view.resourceRevision
+                    : state.observedTerminalRevision < view.resourceRevision);
+            const result = {
+                ...this.#snapshot(view, { includeLatestMessage, includeTerminalDetails }),
+                ...(target.turn === undefined ? {} : { turnId: target.turn.turnId }),
+                waitOutcome: outcome
+            };
+            if (includeLatestMessage) {
+                if (observation)
+                    observation.messageRevision = Math.max(observation.messageRevision, view.messageRevision);
+                else
+                    state.observedMessageRevision = Math.max(state.observedMessageRevision, view.messageRevision);
+            }
+            if (includeTerminalDetails) {
+                if (observation)
+                    observation.terminalRevision = Math.max(observation.terminalRevision, view.resourceRevision);
+                else
+                    state.observedTerminalRevision = Math.max(state.observedTerminalRevision, view.resourceRevision);
+            }
+            return result;
+        });
+        return {
+            mode,
+            waitFor,
+            agents,
+            pendingAgentIds,
+            waitOutcome: snapshot
+                ? 'snapshot'
+                : !satisfied
+                    ? 'timeout'
+                    : agents.some((agent) => agent.waitOutcome === 'message')
+                        ? 'message'
+                        : 'completion'
+        };
+    }
     async message(agentId, message, options = {}) {
         const execution = this.#requireExecution();
         if (typeof message !== 'string' ||
@@ -529,7 +634,6 @@ export class SubagentSessionController {
         state.verification = [];
         state.evidence = [];
         state.terminalPending = false;
-        state.terminalObserved = false;
         state.turn = {
             turnId,
             ...(native?.ownerInstanceId === undefined ? {} : { ownerInstanceId: native.ownerInstanceId }),
@@ -730,9 +834,9 @@ export class SubagentSessionController {
             native.terminalRevision = state.resourceRevision;
             return true;
         }
-        if (!isTerminalState(state) || state.terminalObserved)
+        if (!isTerminalState(state) || state.observedTerminalRevision >= state.resourceRevision)
             return false;
-        state.terminalObserved = true;
+        state.observedTerminalRevision = state.resourceRevision;
         return true;
     }
     #createDelivery(state, execution, receipt, signal) {
@@ -1022,7 +1126,7 @@ function restoreAgentState(session) {
         verification: [],
         evidence: [],
         terminalPending: false,
-        terminalObserved: false,
+        observedTerminalRevision: -1,
         resourceRevision: 0
     };
     if (terminalType === 'execution.completed' && terminal) {
@@ -1268,20 +1372,12 @@ function waitForPromise(promise, signal) {
             abort();
     });
 }
-/** Explicit waits retain their deadline without overflowing the platform timer. */
-function waitDeadline(waitMs, finish) {
-    const deadline = performance.now() + waitMs;
-    let timer;
-    const tick = () => {
-        const remaining = deadline - performance.now();
-        if (remaining <= 0)
-            finish();
-        else
-            arm(remaining);
-    };
-    const arm = (remaining) => {
-        timer = setTimeout(tick, Math.min(remaining, 2_147_483_647));
+/** Retain the waited Turn's evidence when the live Session moves on to another Turn. */
+function copyWaitState(state) {
+    return {
+        ...state,
+        changedFiles: [...state.changedFiles],
+        verification: [...state.verification],
+        evidence: state.evidence.map((item) => ({ ...item }))
     };
-    arm(waitMs);
-    return () => clearTimeout(timer);
 }

package/dist/agent-core/subagent/wait.d.ts

@@ -0,0 +1,19 @@
+import type { SubagentWaitMode } from './contracts.js';
+/** Validate the entire target set before any observation can be consumed. */
+export declare function parseAgentWaitTargets(input: {
+    agentId?: unknown;
+    agentIds?: unknown;
+    mode?: unknown;
+}, maxAgents?: number): {
+    agentIds?: string[];
+    mode?: SubagentWaitMode;
+};
+/** A group owns one listener and one deadline; readiness never consumes observations. */
+export declare function waitForAgentCondition(input: {
+    ready(): boolean;
+    subscribe(notify: () => void): () => void;
+    waitMs: number;
+    signal?: AbortSignal | undefined;
+}): Promise<boolean>;
+/** Explicit waits retain their deadline without overflowing the platform timer. */
+export declare function waitDeadline(waitMs: number, finish: () => void): () => void;

package/dist/agent-core/subagent/wait.js

@@ -0,0 +1,77 @@
+import { MarAgentError } from '../error.js';
+/** Validate the entire target set before any observation can be consumed. */
+export function parseAgentWaitTargets(input, maxAgents = Infinity) {
+    if (input.agentIds === undefined || input.agentIds === null) {
+        if (input.mode !== undefined && input.mode !== null)
+            invalid();
+        return {};
+    }
+    if ((input.agentId !== undefined && input.agentId !== null) ||
+        !Array.isArray(input.agentIds) ||
+        input.agentIds.length === 0 ||
+        input.agentIds.length > maxAgents ||
+        input.agentIds.some((id) => typeof id !== 'string' || !id.trim()) ||
+        (input.mode !== undefined &&
+            input.mode !== null &&
+            input.mode !== 'any' &&
+            input.mode !== 'all'))
+        invalid();
+    const agentIds = input.agentIds.map((id) => id.trim());
+    if (new Set(agentIds).size !== agentIds.length)
+        invalid();
+    return { agentIds, mode: input.mode === 'all' ? 'all' : 'any' };
+}
+function invalid() {
+    throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Agent wait targets are invalid.');
+}
+/** A group owns one listener and one deadline; readiness never consumes observations. */
+export function waitForAgentCondition(input) {
+    input.signal?.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let unsubscribe = () => { };
+        let cancelTimer = () => { };
+        const finish = (ready, error) => {
+            if (settled)
+                return;
+            settled = true;
+            unsubscribe();
+            cancelTimer();
+            input.signal?.removeEventListener('abort', abort);
+            if (error === undefined)
+                resolve(ready);
+            else
+                reject(error);
+        };
+        const notify = () => {
+            if (input.ready())
+                finish(true);
+        };
+        const abort = () => finish(false, input.signal?.reason ??
+            new MarAgentError('MAR_AGENT_EXECUTION_CANCELLED', 'Execution cancelled.'));
+        unsubscribe = input.subscribe(notify);
+        cancelTimer = waitDeadline(input.waitMs, () => finish(input.ready()));
+        input.signal?.addEventListener('abort', abort, { once: true });
+        if (input.signal?.aborted)
+            abort();
+        else
+            notify();
+    });
+}
+/** Explicit waits retain their deadline without overflowing the platform timer. */
+export function waitDeadline(waitMs, finish) {
+    const deadline = performance.now() + waitMs;
+    let timer;
+    const tick = () => {
+        const remaining = deadline - performance.now();
+        if (remaining <= 0)
+            finish();
+        else
+            arm(remaining);
+    };
+    const arm = (remaining) => {
+        timer = setTimeout(tick, Math.min(remaining, 2_147_483_647));
+    };
+    arm(waitMs);
+    return () => clearTimeout(timer);
+}

package/dist/agent-core/tools/agent/agent-wait.d.ts

@@ -3,5 +3,5 @@ import type { ToolRuntimeContext } from '../runtime-context.js';
 export declare const agentWaitToolDefinition: ClientToolDefinition;
 export declare function executeAgentWait(arguments_: unknown, context: ToolRuntimeContext): Promise<{
     content: string;
-    data: import("../../subagent/contracts.js").SubagentTaskSnapshot;
+    data: import("../../subagent/contracts.js").SubagentTaskSnapshot | import("../../subagent/contracts.js").SubagentManyOutput;
 }>;

package/dist/agent-core/tools/agent/agent-wait.js

@@ -1,14 +1,29 @@
 import { MarAgentError } from '../../error.js';
 import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
+import { parseAgentWaitTargets } from '../../subagent/wait.js';
 export const agentWaitToolDefinition = {
     name: 'agent_wait',
     allowedCallers: ['direct'],
     parallelSafety: 'serial',
-    description: 'Read or wait a bounded time for a child agent result. Wait only when the next local step depends on the child result; otherwise continue useful non-overlapping work. waitFor defaults to "completion"; use "message" only when a fresh public commentary/final message would change the next decision. 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_wait instead (tools.exec_wait in Code Mode). 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. When blocked on a live child result, prefer one 300000 ms completion wait rather than repeated short waits. Every result includes waitOutcome as snapshot, message, completion, or timeout plus the real agentId and description. A message, timeout with unread progress, or first terminal completion result includes the newly observed latest public commentary/final message; snapshots and repeated observations omit previously observed message text. latestActivity can still identify a public message or bounded tool started/completed/failed status. A queued or running result is not completion. A message wait consumes only the latest unread public message in the current Session runtime; tool activity does not wake it, and parent cancellation preserves unread progress for a later Execution. Do not use message waits as heartbeat checks or request progress merely to confirm that a child is still running. First 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.',
+    description: 'Read or wait a bounded time for a child agent result. Wait only when the next local step depends on the child result; otherwise continue useful non-overlapping work. waitFor defaults to "completion"; use "message" only when a fresh public commentary/final message would change the next decision. 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_wait instead (tools.exec_wait in Code Mode). 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. When blocked on a live child result, prefer one 300000 ms completion wait rather than repeated short waits. Use agentIds with mode any (default) or all to wait for an explicit non-empty set of up to 8 distinct child IDs; never combine agentId and agentIds or use mode without agentIds. mode and waitFor are independent. A group uses one deadline and returns mode, waitFor, waitOutcome, agents in input order, and pendingAgentIds. Failed, cancelled and interrupted turns also satisfy completion; terminal state satisfies message waits too. Group waitMs=0 returns only snapshots without consuming messages. Single-target and untargeted results include waitOutcome as snapshot, message, completion, or timeout plus the real agentId and description. A message, timeout with unread progress, or first terminal completion result includes the newly observed latest public commentary/final message; snapshots and repeated observations omit previously observed message text. latestActivity can still identify a public message or bounded tool started/completed/failed status. A queued or running result is not completion. A message wait consumes only the latest unread public message in the current Session runtime; tool activity does not wake it, and parent cancellation preserves unread progress for a later Execution. Do not use message waits as heartbeat checks or request progress merely to confirm that a child is still running. First 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.',
     inputSchema: {
         type: 'object',
         properties: {
             agentId: { type: 'string' },
+            agentIds: {
+                type: 'array',
+                items: { type: 'string', minLength: 1 },
+                minItems: 1,
+                maxItems: TOOL_EXECUTION_LIMITS.agentWaitMaxAgents,
+                uniqueItems: true,
+                description: 'Explicit child-agent set. Mutually exclusive with agentId.'
+            },
+            mode: {
+                type: 'string',
+                enum: ['any', 'all'],
+                default: 'any',
+                description: 'For agentIds only: return when any or all selected children satisfy waitFor.'
+            },
             waitFor: {
                 type: 'string',
                 enum: ['completion', 'message'],
@@ -36,16 +51,18 @@ export async function executeAgentWait(arguments_, context) {
         waitFor: value.waitFor ?? 'completion',
         signal: context.signal
     };
-    const task = value.agentId === undefined
-        ? await subagents.outputAny(options)
-        : await subagents.output(value.agentId, options);
+    const task = value.agentIds !== undefined
+        ? await subagents.outputMany(value.agentIds, { ...options, mode: value.mode ?? 'any' })
+        : value.agentId === undefined
+            ? await subagents.outputAny(options)
+            : await subagents.output(value.agentId, options);
     return { content: JSON.stringify(task), data: task };
 }
 function parseAgentWaitInput(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         return invalidAgentWait();
     const input = value;
-    if (Object.keys(input).some((key) => !['agentId', 'waitFor', 'waitMs'].includes(key)) ||
+    if (Object.keys(input).some((key) => !['agentId', 'agentIds', 'mode', 'waitFor', 'waitMs'].includes(key)) ||
         (input.agentId !== undefined &&
             input.agentId !== null &&
             (typeof input.agentId !== 'string' || input.agentId.trim().length === 0)) ||
@@ -60,6 +77,7 @@ function parseAgentWaitInput(value) {
                 input.waitMs > TOOL_EXECUTION_LIMITS.agentWaitMaxWaitMs)))
         return invalidAgentWait();
     return {
+        ...parseAgentWaitTargets(input, TOOL_EXECUTION_LIMITS.agentWaitMaxAgents),
         ...(typeof input.agentId === 'string' ? { agentId: input.agentId.trim() } : {}),
         ...(input.waitFor === 'completion' || input.waitFor === 'message'
             ? { waitFor: input.waitFor }

package/dist/agent-core/tools/code-mode/quickjs-engine.js

@@ -638,9 +638,8 @@ function streamText(value, emit) {
         return;
     }
     const ancestors = new Set();
-    const write = (item, key, path) => {
-        if (item && typeof item === 'object' && typeof item.toJSON === 'function')
-            item = item.toJSON(key);
+    const toJSONValue = (item, key) => item && typeof item === 'object' && typeof item.toJSON === 'function' ? item.toJSON(key) : item;
+    const write = (item, path) => {
         if (['bigint', 'function', 'symbol', 'undefined'].includes(typeof item))
             throw Object.assign(new TypeError(`Only JSON values may be emitted; ${path} has type ${typeof item}. Omit optional fields or use null explicitly.`), {
                 code: 'MAR_AGENT_TOOL_INPUT_INVALID'
@@ -670,7 +669,7 @@ function streamText(value, emit) {
             for (let index = 0; index < length; index++) {
                 if (index)
                     emit(',');
-                write(item[index], String(index), `${path}[${index}]`.slice(0, 256));
+                write(toJSONValue(item[index], String(index)) ?? null, `${path}[${index}]`.slice(0, 256));
             }
             emit(']');
         }
@@ -683,23 +682,25 @@ function streamText(value, emit) {
                 typeof item.mimeType === 'string' &&
                 item.mimeType.startsWith('image/');
             for (const name of names) {
+                const field = toJSONValue(item[name], name);
+                if (field === undefined)
+                    continue;
                 if (!first)
                     emit(',');
                 first = false;
                 chunks(name, true);
                 emit(':');
-                const field = item[name];
                 write(imagePayload &&
                     (name === 'dataBase64' || (name === 'data' && item.type === 'image')) &&
                     typeof field === 'string'
                     ? '[image payload omitted; use observe.image]'
-                    : field, name, `${path}[${JSON.stringify(name.slice(0, 64))}]`.slice(0, 256));
+                    : field, `${path}[${JSON.stringify(name.slice(0, 64))}]`.slice(0, 256));
             }
             emit('}');
         }
         ancestors.delete(item);
     };
-    write(value, '', '$');
+    write(toJSONValue(value, ''), '$');
 }
 function compilerSourceLocation(error, source) {
     if (error?.name !== 'SyntaxError' ||

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

@@ -46,6 +46,7 @@ export declare const TOOL_EXECUTION_LIMITS: Readonly<{
     agentWaitWaitFloorMs: 10000;
     agentWaitDefaultWaitMs: 30000;
     agentWaitMaxWaitMs: 300000;
+    agentWaitMaxAgents: 8;
     subagentDescriptionMaxCharacters: 80;
     subagentPromptMaxBytes: 131072;
     subagentMessageMaxBytes: 131072;

package/dist/agent-core/tools/execution-limits.js

@@ -46,6 +46,7 @@ export const TOOL_EXECUTION_LIMITS = Object.freeze({
     agentWaitWaitFloorMs: 10_000,
     agentWaitDefaultWaitMs: 30_000,
     agentWaitMaxWaitMs: 300_000,
+    agentWaitMaxAgents: 8,
     subagentDescriptionMaxCharacters: 80,
     subagentPromptMaxBytes: 131_072,
     subagentMessageMaxBytes: 131_072,

package/dist/agent-core/tools/output-projection.d.ts

@@ -1,4 +1,4 @@
-import type { SubagentTaskSnapshot } from '../subagent/contracts.js';
+import type { SubagentTaskSnapshot, SubagentManyOutput } from '../subagent/contracts.js';
 import type { ApplyPatchResult, ApplyPatchPartialResult, CodeCellEventData, ExecResult, MarAgentToolArtifact, ToolExecutionResult, ReadEventData, ViewImageResult } from './contracts.js';
 import type { ToolRuntimeImage } from './runtime-context.js';
 export declare function currentExecutionImages(modelInputImages: readonly {
@@ -10,7 +10,7 @@ export declare function boundedModelToolOutput(toolName: string, value: string,
     truncated: boolean;
 };
 /** Project only known, validated tool result shapes into public structured events. */
-export declare function structuredToolEventData(toolName: string, value: unknown): CodeCellEventData | ExecResult | ApplyPatchResult | ReadEventData | ViewImageResult | SubagentTaskSnapshot | undefined;
+export declare function structuredToolEventData(toolName: string, value: unknown): CodeCellEventData | ExecResult | ApplyPatchResult | ReadEventData | ViewImageResult | SubagentTaskSnapshot | SubagentManyOutput | undefined;
 /** Partial patch facts are allowlisted; arbitrary error details never become public event data. */
 export declare function structuredToolFailureData(toolName: string, error: unknown): ApplyPatchPartialResult | undefined;
 export declare function structuredToolArtifacts(value: readonly MarAgentToolArtifact[] | undefined): readonly MarAgentToolArtifact[] | undefined;

package/dist/agent-core/tools/output-projection.js

@@ -35,6 +35,18 @@ export function boundedModelToolOutput(toolName, value, data) {
 export function structuredToolEventData(toolName, value) {
     if (!isRecord(value))
         return undefined;
+    if (toolName === 'agent_wait' &&
+        (value.mode === 'any' || value.mode === 'all') &&
+        (value.waitFor === 'completion' || value.waitFor === 'message') &&
+        ['snapshot', 'message', 'completion', 'timeout'].includes(String(value.waitOutcome)) &&
+        Array.isArray(value.agents) &&
+        value.agents.length > 0 &&
+        value.agents.length <= TOOL_EXECUTION_LIMITS.agentWaitMaxAgents &&
+        value.agents.every((agent) => isRecord(agent) && isSubagentTaskSnapshot(agent)) &&
+        Array.isArray(value.pendingAgentIds) &&
+        value.pendingAgentIds.every((id) => typeof id === 'string' &&
+            value.agents.some((agent) => agent.agentId === id)))
+        return value;
     if ((toolName === 'code_exec' || toolName === 'code_exec_wait') &&
         typeof value.cellId === 'string' &&
         ['running', 'completed', 'failed', 'cancelled'].includes(String(value.status)))

package/dist/cli/codex-auth-file.js

@@ -1,10 +1,11 @@
 import { execFile } from 'node:child_process';
 import { constants } from 'node:fs';
-import { lstat, open, readFile } from 'node:fs/promises';
+import { lstat, open } from 'node:fs/promises';
 import { promisify } from 'node:util';
 import { z } from 'zod';
 import { MarAgentError } from '../agent-core/error.js';
 import { SecretValue } from '../agent-core/model/configuration.js';
+import { productUserAgent } from '../agent-core/model/product-user-agent.js';
 const MAX_AUTH_FILE_BYTES = 1024 * 1024;
 const TOKEN_MAX_BYTES = 131_072;
 const AUTH_FALLBACK_LIFETIME_MS = 8 * 24 * 60 * 60 * 1000;
@@ -52,7 +53,7 @@ export class CodexAuthFileCredentialProvider {
             headers: {
                 'ChatGPT-Account-ID': new SecretValue(parsed.accountId),
                 originator: 'myagentroam',
-                'user-agent': await productUserAgent()
+                'user-agent': productUserAgent()
             }
         };
         this.#cached = { fingerprint: file.fingerprint, credential };
@@ -263,18 +264,6 @@ function record(value) {
         ? value
         : {};
 }
-let productUserAgentPromise;
-async function productUserAgent() {
-    productUserAgentPromise ??= readFile(new URL('../../package.json', import.meta.url), 'utf8')
-        .then((content) => {
-        const value = JSON.parse(content);
-        if (typeof value.version !== 'string')
-            throw new Error('package version unavailable');
-        return `MyAgentRoam/${value.version} (${process.platform}; ${process.arch})`;
-    })
-        .catch(() => `MyAgentRoam/unknown (${process.platform}; ${process.arch})`);
-    return await productUserAgentPromise;
-}
 function unsafeFile(cause) {
     return new MarAgentError('MAR_AGENT_CREDENTIAL_FILE_UNSAFE', 'Codex auth file permissions or file type are unsafe.', cause === undefined ? {} : { cause });
 }

package/dist/index.d.ts

@@ -29,7 +29,7 @@ export type { CoreFilesApi, CoreFilesBackend, CoreFilePath, CoreFileWrite, CoreF
 export type { CoreHostExtensionPorts, CoreHostToolSource, CoreHostToolsBackend } from './agent-core/host/contracts.js';
 export type { CoreEnvironmentApi, CoreEnvironmentBackend, CoreEnvironmentKey, CoreEnvironmentSet, CoreEnvironmentChange, CoreEnvironmentCompletion } from './agent-core/extensions/environment.js';
 export type { CoreMcpApi, CoreMcpBackend, CoreMcpConnectionBackend, CoreMcpToolCall, CoreMcpServerDefinition, CoreMcpServerRef, CoreMcpServerRegistration, CoreMcpConnectionRef, CoreMcpConnectInput, CoreMcpConnectionInput, CoreMcpCallInput, CoreMcpCatalog, CoreMcpCompletion } from './agent-core/extensions/mcp.js';
-export type { CoreAgentsApi, CoreAgentsBackend, CoreAgentSpawnInput, CoreAgentTarget, CoreAgentWaitInput, CoreAgentMessageInput, CoreAgentSnapshot, CoreAgentHandledResult, CoreAgentSpawnResult, CoreAgentCompletion } from './agent-core/extensions/agents.js';
+export type { CoreAgentsApi, CoreAgentsBackend, CoreAgentSpawnInput, CoreAgentTarget, CoreAgentWaitInput, CoreAgentWaitResult, CoreAgentManySnapshot, CoreAgentMessageInput, CoreAgentSnapshot, CoreAgentHandledResult, CoreAgentSpawnResult, CoreAgentCompletion } from './agent-core/extensions/agents.js';
 export type { CoreSettingsApi, CoreSettingsBackend, CoreSettingsReadInput, CoreSettingsUpdate, CoreSettingsDescription, CoreSettingDefinition, CoreSettingsSnapshot, CoreSettingsResult, CoreSettingsCompletion } from './agent-core/extensions/settings.js';
 export type { CoreNetworkApi, CoreNetworkBackend, CoreHttpRequest, CoreHttpResponse, CoreHttpCompletion } from './agent-core/extensions/network.js';
 export type { CoreSessionApi, CoreSessionReceipt, CoreSessionInspection, CoreSessionDescription, CoreSessionMessages, CoreSessionMessagesInput, CoreSessionMessage, CoreSessionOperationStatus, CoreAppendInput, CoreSubmitInput, CoreInputSource, CoreCompactInput, CoreSessionActionResult } from './agent-core/extensions/session-input.js';

package/package.json

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