@myagentroam/agent 0.11.33 → 0.11.35

package/dist/subagent/task.d.ts

@@ -0,0 +1,134 @@
+import type { AgentReasoningEffort } from '../model/configuration.js';
+import type { ExecutionResult } from '../runtime/contracts.js';
+import type { AgentEvent } from '../runtime/events.js';
+import type { SubagentTaskInput, SubagentTaskSnapshot, SubagentLatestMessage, SubagentLatestActivity } from './contracts.js';
+import type { SubagentOrigin, SubagentMessageDelivery, SubagentMailboxMessage, SubagentParentExecution, SubagentTurnHandle } from './turn-contracts.js';
+interface TurnState {
+    readonly turnId: string;
+    readonly ownerInstanceId?: string;
+    readonly origin?: SubagentOrigin;
+    readonly delivery?: SubagentMessageDelivery;
+    readonly prompt: string;
+    readonly start: SubagentParentExecution['startTurn'];
+    readonly pendingMessages: SubagentMailboxMessage[];
+    readonly handleReady: Promise<void>;
+    readonly completion: Promise<void>;
+    resolve(): void;
+    resolveHandleReady(): void;
+    handle?: SubagentTurnHandle;
+    cancelRequested?: boolean;
+}
+export type TurnView = Readonly<Omit<TurnState, 'pendingMessages' | 'resolve' | 'resolveHandleReady' | 'cancelRequested'>>;
+type TurnInput = Omit<TurnState, 'handleReady' | 'completion' | 'resolve' | 'resolveHandleReady' | 'handle' | 'cancelRequested'>;
+export interface SubagentTaskState {
+    detailsEvicted?: boolean | undefined;
+    restorable?: boolean | undefined;
+    permissionStop?: ExecutionResult['permissionStop'] | undefined;
+    readonly agentId: string;
+    readonly description: string;
+    readonly role: SubagentTaskInput['role'];
+    readonly ownerInstanceId?: string | undefined;
+    readonly extensionId?: string | undefined;
+    status: SubagentTaskSnapshot['status'];
+    modelId?: string | undefined;
+    modelName?: string | undefined;
+    reasoningEffort?: AgentReasoningEffort | undefined;
+    latestMessage?: SubagentLatestMessage | undefined;
+    latestActivity?: SubagentLatestActivity | undefined;
+    messageRevision: number;
+    observedMessageRevision: number;
+    latestMessageActivityRevision: number;
+    summary?: string | undefined;
+    changedFiles: string[];
+    verification: string[];
+    evidence: Array<{
+        path: string;
+        startLine?: number;
+        endLine?: number;
+    }>;
+    errorCode?: string | undefined;
+    errorMessage?: string | undefined;
+    terminalPending: boolean;
+    observedTerminalRevision: number;
+    terminalRevision?: number | undefined;
+    resourceRevision: number;
+    turn?: TurnState | undefined;
+    controlTail?: Promise<unknown> | undefined;
+    receipt?: {
+        messageId: string;
+        turnId: string;
+        deliveryStatus: 'accepted' | 'applied' | 'cancelled' | 'failed';
+    } | undefined;
+}
+export type TaskView = Omit<SubagentTaskState, 'turn' | 'receipt' | 'changedFiles' | 'verification' | 'evidence'> & {
+    readonly turn?: TurnView | undefined;
+    readonly receipt?: Readonly<NonNullable<SubagentTaskState['receipt']>> | undefined;
+    readonly changedFiles: readonly string[];
+    readonly verification: readonly string[];
+    readonly evidence: readonly Readonly<SubagentTaskState['evidence'][number]>[];
+};
+/** Owns the mutable state and transitions of one child task. */
+export declare class SubagentTask {
+    #private;
+    private readonly state;
+    get detailsEvicted(): SubagentTaskState['detailsEvicted'];
+    get restorable(): SubagentTaskState['restorable'];
+    get permissionStop(): SubagentTaskState['permissionStop'];
+    get agentId(): SubagentTaskState['agentId'];
+    get description(): SubagentTaskState['description'];
+    get role(): SubagentTaskState['role'];
+    get ownerInstanceId(): SubagentTaskState['ownerInstanceId'];
+    get extensionId(): SubagentTaskState['extensionId'];
+    get status(): SubagentTaskState['status'];
+    get modelId(): SubagentTaskState['modelId'];
+    get modelName(): SubagentTaskState['modelName'];
+    get reasoningEffort(): SubagentTaskState['reasoningEffort'];
+    get latestMessage(): SubagentTaskState['latestMessage'];
+    get latestActivity(): SubagentTaskState['latestActivity'];
+    get messageRevision(): SubagentTaskState['messageRevision'];
+    get observedMessageRevision(): SubagentTaskState['observedMessageRevision'];
+    get latestMessageActivityRevision(): SubagentTaskState['latestMessageActivityRevision'];
+    get summary(): SubagentTaskState['summary'];
+    get changedFiles(): readonly string[];
+    get verification(): readonly string[];
+    get evidence(): readonly Readonly<SubagentTaskState['evidence'][number]>[];
+    get errorCode(): SubagentTaskState['errorCode'];
+    get errorMessage(): SubagentTaskState['errorMessage'];
+    get terminalPending(): SubagentTaskState['terminalPending'];
+    get observedTerminalRevision(): SubagentTaskState['observedTerminalRevision'];
+    get terminalRevision(): SubagentTaskState['terminalRevision'];
+    get resourceRevision(): SubagentTaskState['resourceRevision'];
+    get turn(): TurnView | undefined;
+    get controlTail(): SubagentTaskState['controlTail'];
+    get receipt(): Readonly<NonNullable<SubagentTaskState['receipt']>> | undefined;
+    constructor(state: SubagentTaskState);
+    runTurn(turn: TurnView, nextActivityRevision: () => number, onMessage: () => void, onTerminal: () => void): Promise<'opening-failed' | 'settled'>;
+    acknowledgeMessage(revision: number): void;
+    acknowledgeTerminal(revision: number): void;
+    selectModel(model: {
+        id: string;
+        name: string;
+        reasoningEffort?: AgentReasoningEffort;
+    }): void;
+    setReceipt(receipt: NonNullable<SubagentTaskState['receipt']>): void;
+    updateDelivery(receipt: NonNullable<SubagentTaskState['receipt']>, status: 'applied' | 'cancelled' | 'failed'): boolean;
+    requestCancel(expected: TurnView): void;
+    settleQueuedTurn(expected: TurnView): void;
+    settleTurn(expected: TurnView): void;
+    appendMessage(message: SubagentMailboxMessage): void;
+    control<T>(operation: () => Promise<T>): Promise<T>;
+    cancelQueued(publish: boolean): void;
+    queueTurn(input: TurnInput, onComplete: () => void): TurnView;
+    markRunning(expected: TurnView): boolean;
+    releaseTurn(expected: TurnView): void;
+    observeEvent(event: AgentEvent, revision: number): boolean;
+    complete(result: ExecutionResult, terminal: 'completed' | 'failed' | 'cancelled' | undefined, persisted: boolean, previousActivity: SubagentTaskState['latestActivity'], previousRevision: number): void;
+    fail(error: unknown): void;
+    touch(revision: number, terminal?: boolean): void;
+    terminalPublished(revision: number | undefined): void;
+    evictDetails(): void;
+    restoreDetails(restored: SubagentTaskState): void;
+    copyWaitState(): TaskView;
+}
+export declare function observeAgentEvent(state: SubagentTaskState, event: AgentEvent): boolean;
+export {};

package/dist/subagent/task.js

@@ -0,0 +1,436 @@
+import { describeAgentError } from '../error.js';
+/** Owns the mutable state and transitions of one child task. */
+export class SubagentTask {
+    state;
+    get detailsEvicted() {
+        return this.state.detailsEvicted;
+    }
+    get restorable() {
+        return this.state.restorable;
+    }
+    get permissionStop() {
+        return this.state.permissionStop;
+    }
+    get agentId() {
+        return this.state.agentId;
+    }
+    get description() {
+        return this.state.description;
+    }
+    get role() {
+        return this.state.role;
+    }
+    get ownerInstanceId() {
+        return this.state.ownerInstanceId;
+    }
+    get extensionId() {
+        return this.state.extensionId;
+    }
+    get status() {
+        return this.state.status;
+    }
+    get modelId() {
+        return this.state.modelId;
+    }
+    get modelName() {
+        return this.state.modelName;
+    }
+    get reasoningEffort() {
+        return this.state.reasoningEffort;
+    }
+    get latestMessage() {
+        return this.state.latestMessage;
+    }
+    get latestActivity() {
+        return this.state.latestActivity;
+    }
+    get messageRevision() {
+        return this.state.messageRevision;
+    }
+    get observedMessageRevision() {
+        return this.state.observedMessageRevision;
+    }
+    get latestMessageActivityRevision() {
+        return this.state.latestMessageActivityRevision;
+    }
+    get summary() {
+        return this.state.summary;
+    }
+    get changedFiles() {
+        return this.state.changedFiles;
+    }
+    get verification() {
+        return this.state.verification;
+    }
+    get evidence() {
+        return this.state.evidence;
+    }
+    get errorCode() {
+        return this.state.errorCode;
+    }
+    get errorMessage() {
+        return this.state.errorMessage;
+    }
+    get terminalPending() {
+        return this.state.terminalPending;
+    }
+    get observedTerminalRevision() {
+        return this.state.observedTerminalRevision;
+    }
+    get terminalRevision() {
+        return this.state.terminalRevision;
+    }
+    get resourceRevision() {
+        return this.state.resourceRevision;
+    }
+    get turn() {
+        return this.state.turn;
+    }
+    get controlTail() {
+        return this.state.controlTail;
+    }
+    get receipt() {
+        return this.state.receipt;
+    }
+    constructor(state) {
+        this.state = state;
+    }
+    async runTurn(turn, nextActivityRevision, onMessage, onTerminal) {
+        try {
+            const handle = await turn.start({
+                turnId: turn.turnId,
+                ...(turn.delivery === undefined ? {} : { delivery: turn.delivery }),
+                ...(turn.origin === undefined ? {} : { origin: turn.origin }),
+                sessionId: this.agentId,
+                prompt: turn.prompt,
+                modelId: this.modelId,
+                reasoningEffort: this.reasoningEffort,
+                role: this.role,
+                initialMailbox: this.#takePendingMessages(turn)
+            });
+            this.#attachHandle(turn, handle);
+        }
+        catch (error) {
+            this.#settleHandleReady(turn);
+            this.fail(error);
+            onTerminal();
+            return 'opening-failed';
+        }
+        this.#cancelPending(turn);
+        this.#settleHandleReady(turn);
+        const previousActivity = this.latestActivity;
+        const previousMessageRevision = this.messageRevision;
+        let terminal;
+        try {
+            const consume = (async () => {
+                for await (const event of turn.handle) {
+                    if (event.type === 'execution.completed')
+                        terminal = 'completed';
+                    else if (event.type === 'execution.failed')
+                        terminal = 'failed';
+                    else if (event.type === 'execution.cancelled')
+                        terminal = 'cancelled';
+                    if (this.observeEvent(event, nextActivityRevision()))
+                        onMessage();
+                }
+            })();
+            const [result, stream] = await Promise.allSettled([
+                Promise.resolve().then(() => turn.handle.result()),
+                consume
+            ]);
+            if (result.status === 'rejected')
+                throw result.reason;
+            if (stream.status === 'rejected')
+                throw stream.reason;
+            this.complete(result.value, terminal, turn.handle.persistedEvents === true, previousActivity, previousMessageRevision);
+        }
+        catch (error) {
+            this.fail(error);
+        }
+        onTerminal();
+        return 'settled';
+    }
+    acknowledgeMessage(revision) {
+        this.state.observedMessageRevision = Math.max(this.state.observedMessageRevision, revision);
+    }
+    acknowledgeTerminal(revision) {
+        this.state.observedTerminalRevision = Math.max(this.state.observedTerminalRevision, revision);
+    }
+    selectModel(model) {
+        this.state.modelId = model.id;
+        this.state.modelName = model.name;
+        if (model.reasoningEffort !== undefined)
+            this.state.reasoningEffort = model.reasoningEffort;
+    }
+    setReceipt(receipt) {
+        this.state.receipt = receipt;
+    }
+    updateDelivery(receipt, status) {
+        if (status !== 'applied' && receipt.deliveryStatus !== 'accepted')
+            return false;
+        receipt.deliveryStatus = status;
+        return true;
+    }
+    requestCancel(expected) {
+        const turn = this.state.turn;
+        if (turn !== expected)
+            return;
+        if (turn.handle)
+            turn.handle.cancel();
+        else
+            turn.cancelRequested = true;
+    }
+    #attachHandle(expected, handle) {
+        const turn = this.state.turn;
+        if (turn !== expected)
+            return;
+        turn.handle = handle;
+    }
+    #cancelPending(expected) {
+        const turn = this.state.turn;
+        if (turn === expected && turn.cancelRequested)
+            turn.handle.cancel();
+    }
+    #takePendingMessages(expected) {
+        const turn = this.state.turn;
+        return turn === expected ? turn.pendingMessages.splice(0) : [];
+    }
+    #settleHandleReady(expected) {
+        if (this.state.turn === expected)
+            this.state.turn.resolveHandleReady();
+    }
+    settleQueuedTurn(expected) {
+        this.#settleHandleReady(expected);
+        this.settleTurn(expected);
+    }
+    settleTurn(expected) {
+        if (this.state.turn === expected)
+            this.state.turn.resolve();
+    }
+    appendMessage(message) {
+        this.state.turn.pendingMessages.push(message);
+    }
+    control(operation) {
+        const result = (this.state.controlTail ?? Promise.resolve()).then(operation);
+        const tail = result.then(() => undefined, () => undefined);
+        this.state.controlTail = tail;
+        void tail.then(() => {
+            if (this.state.controlTail === tail)
+                delete this.state.controlTail;
+        });
+        return result;
+    }
+    cancelQueued(publish) {
+        this.state.status = 'cancelled';
+        if (publish)
+            this.state.terminalPending = true;
+    }
+    queueTurn(input, onComplete) {
+        let resolve;
+        let resolveHandleReady;
+        const completion = new Promise((done) => (resolve = done));
+        const handleReady = new Promise((done) => (resolveHandleReady = done));
+        const turn = {
+            ...input,
+            handleReady,
+            completion,
+            resolve: () => {
+                onComplete();
+                resolve();
+            },
+            resolveHandleReady
+        };
+        this.state.status = 'queued';
+        this.state.restorable = false;
+        delete this.state.summary;
+        delete this.state.permissionStop;
+        delete this.state.errorCode;
+        delete this.state.errorMessage;
+        this.state.changedFiles = [];
+        this.state.verification = [];
+        this.state.evidence = [];
+        this.state.terminalPending = false;
+        this.state.turn = turn;
+        return turn;
+    }
+    markRunning(expected) {
+        if (this.state.turn !== expected || this.state.status !== 'queued')
+            return false;
+        this.state.status = 'running';
+        return true;
+    }
+    releaseTurn(expected) {
+        if (this.state.turn === expected)
+            delete this.state.turn;
+    }
+    observeEvent(event, revision) {
+        if (!observeAgentEvent(this.state, event))
+            return false;
+        this.state.messageRevision++;
+        this.state.latestMessageActivityRevision = revision;
+        return true;
+    }
+    complete(result, terminal, persisted, previousActivity, previousRevision) {
+        if (result.status === 'completed') {
+            this.state.status = 'completed';
+            this.state.summary = result.finalAnswer;
+            if (result.permissionStop)
+                this.state.permissionStop = result.permissionStop;
+            else
+                delete this.state.permissionStop;
+        }
+        else if (result.status === 'cancelled')
+            this.state.status = 'cancelled';
+        else {
+            this.state.status = 'failed';
+            this.state.errorCode = result.errorCode ?? 'MAR_AGENT_SUBAGENT_FAILED';
+            this.state.errorMessage = result.errorMessage ?? 'Subagent execution failed.';
+        }
+        this.state.restorable =
+            persisted &&
+                terminal === this.state.status &&
+                (previousActivity === undefined || this.state.latestActivity !== previousActivity) &&
+                (this.state.latestMessage === undefined || this.state.messageRevision > previousRevision) &&
+                (this.state.status !== 'completed' ||
+                    (this.state.latestMessage?.phase === 'final_answer' &&
+                        this.state.summary === this.state.latestMessage.text));
+        this.state.terminalPending = true;
+    }
+    fail(error) {
+        const diagnostic = describeAgentError(error, 'MAR_AGENT_SUBAGENT_FAILED');
+        this.state.status = 'failed';
+        this.state.restorable = false;
+        this.state.errorCode = diagnostic.code;
+        this.state.errorMessage = diagnostic.message;
+        this.state.terminalPending = true;
+    }
+    touch(revision, terminal = false) {
+        this.state.resourceRevision = revision;
+        if (terminal)
+            this.state.terminalRevision = revision;
+    }
+    terminalPublished(revision) {
+        if (this.state.terminalRevision === revision)
+            this.state.terminalPending = false;
+    }
+    evictDetails() {
+        for (const key of DETAIL_FIELDS)
+            delete this.state[key];
+        this.state.changedFiles = [];
+        this.state.verification = [];
+        this.state.evidence = [];
+        this.state.detailsEvicted = true;
+    }
+    restoreDetails(restored) {
+        for (const key of DETAIL_FIELDS) {
+            if (key in restored)
+                Object.assign(this.state, { [key]: restored[key] });
+            else
+                delete this.state[key];
+        }
+        delete this.state.detailsEvicted;
+    }
+    copyWaitState() {
+        return {
+            ...this.state,
+            changedFiles: [...this.state.changedFiles],
+            verification: [...this.state.verification],
+            evidence: this.state.evidence.map((item) => ({ ...item }))
+        };
+    }
+}
+const DETAIL_FIELDS = [
+    'latestMessage',
+    'latestActivity',
+    'summary',
+    'changedFiles',
+    'verification',
+    'evidence',
+    'permissionStop',
+    'errorMessage'
+];
+export function observeAgentEvent(state, event) {
+    if (event.type === 'message.completed') {
+        state.latestMessage = latestMessageFromEvent(event);
+        state.latestActivity = {
+            kind: 'message',
+            timestamp: event.timestamp,
+            phase: event.phase
+        };
+        return true;
+    }
+    if (event.type === 'tool.started') {
+        state.latestActivity = {
+            kind: 'tool',
+            timestamp: event.timestamp,
+            toolName: event.toolName,
+            status: 'started'
+        };
+        return false;
+    }
+    if (event.type === 'tool.failed') {
+        state.latestActivity = {
+            kind: 'tool',
+            timestamp: event.timestamp,
+            toolName: event.toolName,
+            status: 'failed'
+        };
+        return false;
+    }
+    if (event.type !== 'tool.completed')
+        return false;
+    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 : [];
+        for (const file of files) {
+            if (!isRecord(file))
+                continue;
+            for (const path of [file.path, file.targetPath])
+                if (typeof path === 'string' && path.length > 0 && !state.changedFiles.includes(path))
+                    state.changedFiles.push(path);
+        }
+    }
+    else if (event.toolName === 'read' && isRecord(event.data)) {
+        const data = event.data;
+        const results = Array.isArray(data.results) ? data.results : [];
+        for (const result of results) {
+            if (!isRecord(result) || typeof result.path !== 'string' || result.error !== undefined)
+                continue;
+            const evidence = {
+                path: result.path,
+                ...(isPositiveInteger(result.startLine) ? { startLine: result.startLine } : {}),
+                ...(isPositiveInteger(result.endLine) ? { endLine: result.endLine } : {})
+            };
+            if (!state.evidence.some((item) => item.path === evidence.path &&
+                item.startLine === evidence.startLine &&
+                item.endLine === evidence.endLine))
+                state.evidence.push(evidence);
+        }
+    }
+    else if (event.toolName === 'exec')
+        state.verification.push(event.summary);
+    return false;
+}
+function latestMessageFromEvent(event) {
+    const text = event.text;
+    return {
+        itemId: event.itemId,
+        turnId: event.turnId ?? '',
+        phase: event.phase,
+        text,
+        timestamp: event.timestamp,
+        truncated: text !== event.text
+    };
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isPositiveInteger(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 1;
+}

package/dist/subagent/turn-contracts.d.ts

@@ -0,0 +1,64 @@
+import type { AgentReasoningEffort } from '../model/configuration.js';
+import type { ExecutionResult } from '../runtime/contracts.js';
+import type { AgentEvent } from '../runtime/events.js';
+import type { SubagentTaskInput, SubagentTaskSnapshot } from './contracts.js';
+export interface SubagentModelOption {
+    readonly id: string;
+    readonly name: string;
+    readonly conversationModel?: boolean;
+    readonly reasoningEfforts: readonly AgentReasoningEffort[];
+    readonly defaultReasoningEffort: AgentReasoningEffort;
+}
+export interface SubagentTurnHandle extends AsyncIterable<AgentEvent> {
+    readonly executionId: string;
+    readonly turnId: string;
+    /** True only after the child terminal event was durably appended. */
+    readonly persistedEvents?: boolean;
+    result(): Promise<ExecutionResult>;
+    cancel(): void;
+    enqueueMessage(message: string, delivery?: SubagentMessageDelivery): boolean;
+}
+/** Caller-owned correlation is opaque to Subagent; the adapter restores it at delivery. */
+export interface SubagentOrigin {
+    readonly signal: AbortSignal;
+    readonly correlation: unknown;
+}
+export interface SubagentMessageDelivery {
+    readonly messageId: string;
+    readonly origin?: SubagentOrigin;
+    readonly signal?: AbortSignal;
+    applied(): void;
+    settled?(status: 'cancelled' | 'failed'): void;
+}
+export interface SubagentMailboxMessage {
+    readonly text: string;
+    readonly delivery?: SubagentMessageDelivery;
+}
+export interface SubagentParentExecution {
+    readonly executionId: string;
+    readonly modelId: string;
+    readonly reasoningEffort: AgentReasoningEffort;
+    readonly models: ReadonlyMap<string, SubagentModelOption>;
+    emitTerminal(snapshot: SubagentTaskSnapshot): Promise<void>;
+    startTurn(input: {
+        readonly sessionId: string;
+        readonly prompt: string;
+        readonly modelId: string;
+        readonly reasoningEffort: AgentReasoningEffort;
+        readonly role: SubagentTaskInput['role'];
+        readonly initialMailbox: readonly SubagentMailboxMessage[];
+        readonly turnId: string;
+        readonly delivery?: SubagentMessageDelivery;
+        readonly origin?: SubagentOrigin;
+    }): Promise<SubagentTurnHandle>;
+}
+/** A native operation has its own provenance even when no parent Execution is active. */
+export interface SubagentParentOperation extends Omit<SubagentParentExecution, 'executionId'> {
+    readonly operationId: string;
+    readonly executionId?: string;
+    readonly ownerInstanceId?: string;
+    readonly extensionId?: string;
+    readonly signal: AbortSignal;
+    readonly origin?: SubagentOrigin;
+}
+export type SubagentParentContext = SubagentParentExecution | SubagentParentOperation;

package/dist/subagent/turn-contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/subagent/wait-targets.d.ts

@@ -0,0 +1,10 @@
+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;
+};

package/dist/subagent/wait-targets.js

@@ -0,0 +1,26 @@
+import { AgentError } 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 AgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Agent wait targets are invalid.');
+}