@myagentroam/agent 0.11.38 → 0.11.40

package/dist/subagent/task.d.ts

@@ -1,134 +0,0 @@
-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

@@ -1,436 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

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

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

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

@@ -1,26 +0,0 @@
-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.');
-}