@myagentroam/agent 0.11.39 → 0.11.41

package/dist/subagent/wait.d.ts

@@ -1,26 +0,0 @@
-import { waitForToolCondition, type ToolWaitInterrupt } from '../runtime/wait.js';
-export { parseAgentWaitTargets } from './wait-targets.js';
-export { waitDeadline } from '../runtime/wait.js';
-/** Waiters own notification and aggregation, never child state. */
-export declare class SubagentWaitCoordinator<T, A> {
-    #private;
-    subscribeActivity(listener: (activity: A) => void): () => void;
-    notifyCompletion(value: T): void;
-    notifyActivity(value: A): void;
-    waitCompletion(accepts: (value: T) => boolean, current: () => T | undefined, waitMs: number, signal?: AbortSignal, interrupt?: ToolWaitInterrupt): Promise<T | undefined>;
-    waitActivity(accepts: (value: A) => boolean, current: () => A | undefined, waitMs: number, signal?: AbortSignal, interrupt?: ToolWaitInterrupt): Promise<A | undefined>;
-}
-/** A group owns one listener and one deadline; readiness never consumes observations. */
-export declare function waitForAgentGroup<T>(input: {
-    targets: readonly T[];
-    mode: 'any' | 'all';
-    waitMs: number | undefined;
-    signal: AbortSignal | undefined;
-    interrupt: Parameters<typeof waitForToolCondition>[0]['interrupt'];
-    refresh(): void;
-    ready(target: T): boolean;
-    subscribe(notify: () => void): () => void;
-}): Promise<{
-    snapshot: boolean;
-    satisfied: boolean;
-}>;

package/dist/subagent/wait.js

@@ -1,73 +0,0 @@
-import { waitForToolCondition } from '../runtime/wait.js';
-export { parseAgentWaitTargets } from './wait-targets.js';
-export { waitDeadline } from '../runtime/wait.js';
-/** Waiters own notification and aggregation, never child state. */
-export class SubagentWaitCoordinator {
-    #completions = new Set();
-    #activities = new Set();
-    subscribeActivity(listener) {
-        this.#activities.add(listener);
-        return () => {
-            this.#activities.delete(listener);
-        };
-    }
-    notifyCompletion(value) {
-        for (const listener of this.#completions)
-            listener(value);
-    }
-    notifyActivity(value) {
-        for (const listener of this.#activities)
-            listener(value);
-    }
-    waitCompletion(accepts, current, waitMs, signal, interrupt) {
-        return waitForNotification(this.#completions, accepts, current, waitMs, signal, interrupt);
-    }
-    waitActivity(accepts, current, waitMs, signal, interrupt) {
-        return waitForNotification(this.#activities, accepts, current, waitMs, signal, interrupt);
-    }
-}
-async function waitForNotification(waiters, accepts, current, waitMs, signal, interrupt) {
-    let value;
-    await waitForToolCondition({
-        ready: () => {
-            value ??= current();
-            return value !== undefined;
-        },
-        subscribe: (notify) => {
-            const listener = (next) => {
-                if (accepts(next)) {
-                    value = next;
-                    notify();
-                }
-            };
-            waiters.add(listener);
-            return () => {
-                waiters.delete(listener);
-            };
-        },
-        waitMs,
-        signal,
-        interrupt
-    });
-    return value;
-}
-/** A group owns one listener and one deadline; readiness never consumes observations. */
-export async function waitForAgentGroup(input) {
-    const snapshot = input.waitMs === undefined || input.waitMs === 0;
-    const satisfied = () => input.mode === 'all' ? input.targets.every(input.ready) : input.targets.some(input.ready);
-    if (!snapshot) {
-        await waitForToolCondition({
-            waitMs: input.waitMs,
-            signal: input.signal,
-            interrupt: input.interrupt,
-            ready: () => {
-                input.refresh();
-                return satisfied();
-            },
-            subscribe: input.subscribe
-        });
-        input.signal?.throwIfAborted();
-    }
-    input.refresh();
-    return { snapshot, satisfied: !snapshot && satisfied() };
-}

package/dist/tools/agent/agent-cancel.d.ts

@@ -1,7 +0,0 @@
-import type { ClientToolDefinition } from '../contracts.js';
-import type { ToolRuntimeContext } from '../runtime-context.js';
-export declare const agentCancelToolDefinition: ClientToolDefinition;
-export declare function executeAgentCancel(arguments_: unknown, context: ToolRuntimeContext): Promise<{
-    content: string;
-    data: import("../../subagent/contracts.js").SubagentTaskSnapshot;
-}>;

package/dist/tools/agent/agent-cancel.js

@@ -1,29 +0,0 @@
-import { AgentError } from '../../error.js';
-export const agentCancelToolDefinition = {
-    name: 'agent_cancel',
-    allowedCallers: ['direct'],
-    parallelSafety: 'serial',
-    description: 'Idempotently cancel a child agent using the agentId returned by agent_start. For an exec processId, use exec_wait with action:"cancel" instead (tools.exec_wait in Code Mode). Waits for a running task to reach cancelled and returns its agentId and description.',
-    inputSchema: {
-        type: 'object',
-        properties: { agentId: { type: 'string' } },
-        required: ['agentId'],
-        additionalProperties: false
-    }
-};
-export async function executeAgentCancel(arguments_, context) {
-    if (!arguments_ || typeof arguments_ !== 'object' || Array.isArray(arguments_))
-        return invalid();
-    const input = arguments_;
-    if (Object.keys(input).some((key) => key !== 'agentId') ||
-        typeof input.agentId !== 'string' ||
-        input.agentId.trim().length === 0)
-        return invalid();
-    if (!context.subagents)
-        throw new AgentError('MAR_AGENT_SUBAGENT_RECURSION_DISABLED', 'Subagents cannot recurse.');
-    const task = await context.subagents.cancel(input.agentId);
-    return { content: JSON.stringify(task), data: task };
-}
-function invalid() {
-    throw new AgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Agent cancellation input is invalid.');
-}

package/dist/tools/agent/agent-message.d.ts

@@ -1,7 +0,0 @@
-import type { ClientToolDefinition } from '../contracts.js';
-import type { ToolRuntimeContext } from '../runtime-context.js';
-export declare const agentMessageToolDefinition: ClientToolDefinition;
-export declare function executeAgentMessage(arguments_: unknown, context: ToolRuntimeContext): Promise<{
-    content: string;
-    data: import("../../subagent/contracts.js").SubagentTaskSnapshot;
-}>;

package/dist/tools/agent/agent-message.js

@@ -1,57 +0,0 @@
-import { AgentError } from '../../error.js';
-import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
-export const agentMessageToolDefinition = {
-    name: 'agent_message',
-    allowedCallers: ['direct'],
-    parallelSafety: 'serial',
-    description: 'Send a real user message to an existing child agent. Default delivery=append inserts guidance into a running child turn at the next safe boundary after the current model response or complete tool batch. Explicit delivery=replace immediately requests cancellation, waits for the old turn to close, then starts a new turn in the same Session. When idle, either mode starts a new turn using persisted history. Returns messageId, turnId, deliveryStatus, current status, and model metadata without repeating the child’s previous latestMessage, latestActivity, summary, or verification evidence. accepted means queued in memory; applied means persisted in model context, not that the guidance has been executed. Use agent_wait for subsequent progress or completion. Does not wait for the new task to complete or roll back existing side effects.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            agentId: { type: 'string' },
-            delivery: { type: 'string', enum: ['append', 'replace'], default: 'append' },
-            message: {
-                type: 'string',
-                description: 'Non-empty follow-up message for the existing child Session.'
-            }
-        },
-        required: ['agentId', 'message'],
-        additionalProperties: false
-    }
-};
-export async function executeAgentMessage(arguments_, context) {
-    const input = parseAgentMessageInput(arguments_);
-    if (!context.subagents)
-        throw new AgentError('MAR_AGENT_SUBAGENT_RECURSION_DISABLED', 'Subagents cannot recurse.');
-    const task = await context.subagents.message(input.agentId, input.message, {
-        delivery: input.delivery ?? 'append',
-        signal: context.signal
-    });
-    return { content: JSON.stringify(task), data: task };
-}
-function parseAgentMessageInput(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return invalid();
-    const input = value;
-    if (Object.keys(input).some((key) => !['agentId', 'message', 'delivery'].includes(key)) ||
-        (input.delivery !== undefined &&
-            input.delivery !== null &&
-            input.delivery !== 'append' &&
-            input.delivery !== 'replace') ||
-        typeof input.agentId !== 'string' ||
-        input.agentId.trim().length === 0 ||
-        typeof input.message !== 'string' ||
-        input.message.trim().length === 0 ||
-        Buffer.byteLength(input.message) > TOOL_EXECUTION_LIMITS.subagentMessageMaxBytes)
-        return invalid();
-    return {
-        agentId: input.agentId.trim(),
-        message: input.message,
-        ...(input.delivery === 'append' || input.delivery === 'replace'
-            ? { delivery: input.delivery }
-            : {})
-    };
-}
-function invalid() {
-    throw new AgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Agent message input is invalid.');
-}

package/dist/tools/agent/agent-start.d.ts

@@ -1,12 +0,0 @@
-import type { ClientToolDefinition } from '../contracts.js';
-import type { ToolRuntimeContext } from '../runtime-context.js';
-export declare const agentStartToolDefinition: ClientToolDefinition;
-export declare function agentStartToolDefinitionWithModels(models: readonly {
-    readonly id: string;
-    readonly name: string;
-    readonly reasoningEfforts: readonly string[];
-}[]): ClientToolDefinition;
-export declare function executeAgentStart(arguments_: unknown, context: ToolRuntimeContext): Promise<{
-    content: string;
-    data: import("../../subagent/contracts.js").SubagentRunResult;
-}>;

package/dist/tools/agent/agent-start.js

@@ -1,106 +0,0 @@
-import { AgentError } from '../../error.js';
-import { agentReasoningEffortSchema } from '../../model/configuration.js';
-import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
-export const agentStartToolDefinition = {
-    name: 'agent_start',
-    allowedCallers: ['direct'],
-    parallelSafety: 'serial',
-    description: 'Start one bounded, non-recursive child agent with self-contained context. Startup does not wait for task completion. Returns agentId for agent_wait, agent_message, or agent_cancel, description, queued/running/completed/failed/cancelled/interrupted status, and effective model metadata, not task results. Use agent_wait to read results and verification evidence. The optional reasoningEffort overrides the parent effort and must be supported by the selected model; omit it to inherit.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            description: {
-                type: 'string',
-                maxLength: TOOL_EXECUTION_LIMITS.subagentDescriptionMaxCharacters
-            },
-            prompt: {
-                type: 'string',
-                description: 'Self-contained bounded objective, necessary facts, relevant paths, read/write scope, constraints, expected output, and verification responsibility. The child does not inherit parent history.'
-            },
-            role: { enum: ['general-purpose', 'explore'] },
-            modelId: { type: 'string' },
-            reasoningEffort: {
-                type: 'string',
-                enum: agentReasoningEffortSchema.options,
-                maxLength: TOOL_EXECUTION_LIMITS.subagentReasoningEffortMaxCharacters,
-                description: 'Reasoning effort override for the subagent. Omit to inherit the parent effort.'
-            }
-        },
-        required: ['description', 'prompt', 'role'],
-        additionalProperties: false
-    }
-};
-export function agentStartToolDefinitionWithModels(models) {
-    if (models.length === 0)
-        return agentStartToolDefinition;
-    const modelLines = [...models]
-        .sort((left, right) => (left.id < right.id ? -1 : left.id > right.id ? 1 : 0))
-        .map((model) => {
-        const efforts = model.reasoningEfforts.length === 0
-            ? ''
-            : `; reasoning efforts: ${model.reasoningEfforts.join(', ')}`;
-        return `- ${JSON.stringify(model.id)} (${JSON.stringify(model.name)}${efforts})`;
-    });
-    return {
-        ...agentStartToolDefinition,
-        description: [
-            agentStartToolDefinition.description,
-            'The optional modelId may select an enabled model below. Omit modelId to use the current agent model. Only use a listed reasoning effort for the selected model.',
-            'Enabled subagent models:',
-            ...modelLines
-        ].join('\n')
-    };
-}
-export async function executeAgentStart(arguments_, context) {
-    const value = parseAgentStartInput(arguments_);
-    if (!context.subagents)
-        throw new AgentError('MAR_AGENT_SUBAGENT_RECURSION_DISABLED', 'Subagents cannot recurse.');
-    const task = await context.subagents.run(value, {
-        signal: context.signal,
-        onCreated: async (created) => context.emit({
-            type: 'subagent.started',
-            agentId: created.agentId,
-            description: created.description,
-            ...(created.modelId === undefined ? {} : { modelId: created.modelId }),
-            ...(created.modelName === undefined ? {} : { modelName: created.modelName }),
-            ...(created.reasoningEffort === undefined
-                ? {}
-                : { reasoningEffort: created.reasoningEffort })
-        })
-    });
-    return { content: JSON.stringify(task), data: task };
-}
-function parseAgentStartInput(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return invalidAgentStart();
-    const input = value;
-    if (Object.keys(input).some((key) => !['description', 'prompt', 'role', 'modelId', 'reasoningEffort'].includes(key)) ||
-        typeof input.description !== 'string' ||
-        input.description.trim().length === 0 ||
-        input.description.length > TOOL_EXECUTION_LIMITS.subagentDescriptionMaxCharacters ||
-        typeof input.prompt !== 'string' ||
-        input.prompt.trim().length === 0 ||
-        Buffer.byteLength(input.prompt) > TOOL_EXECUTION_LIMITS.subagentPromptMaxBytes ||
-        !['general-purpose', 'explore'].includes(String(input.role)) ||
-        (input.modelId !== undefined &&
-            input.modelId !== null &&
-            (typeof input.modelId !== 'string' || input.modelId.trim().length === 0)) ||
-        (input.reasoningEffort !== undefined &&
-            input.reasoningEffort !== null &&
-            (typeof input.reasoningEffort !== 'string' ||
-                !agentReasoningEffortSchema.safeParse(input.reasoningEffort.trim()).success)))
-        return invalidAgentStart();
-    return {
-        description: input.description.trim(),
-        prompt: input.prompt,
-        role: input.role,
-        ...(typeof input.modelId === 'string' ? { modelId: input.modelId } : {}),
-        ...(typeof input.reasoningEffort === 'string'
-            ? { reasoningEffort: agentReasoningEffortSchema.parse(input.reasoningEffort.trim()) }
-            : {}),
-        background: true
-    };
-}
-function invalidAgentStart() {
-    throw new AgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Agent start input is invalid.');
-}

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

@@ -1,7 +0,0 @@
-import type { ClientToolDefinition } from '../contracts.js';
-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 | import("../../subagent/contracts.js").SubagentManyOutput;
-}>;

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

@@ -1,91 +0,0 @@
-import { AgentError } from '../../error.js';
-import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
-import { parseAgentWaitTargets } from '../../subagent/wait-targets.js';
-export const agentWaitToolDefinition = {
-    name: 'agent_wait',
-    allowedCallers: ['direct'],
-    parallelSafety: 'serial',
-    description: 'Read or wait a bounded time for a child agent result. Unread child messages and terminal results are supplied automatically before the next model request. 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 or timeout with unread progress includes the newly observed public message; first terminal results follow the result projection below. 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. waitOutcome distinguishes snapshot, message, completion, and timeout. A foreground steer may return interrupted with reason=steer without cancelling any child. Do not use message waits as heartbeat checks or request progress merely to confirm that a child is still running. First terminal results retain bounded summary and changedFiles, without automatic command or read records. A final latestMessage fully covered by the complete summary is omitted while its turnId is retained. Use public child conclusions and relevant file references 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'],
-                default: 'completion',
-                description: 'Wait for terminal completion or for the latest unread public message. Terminal state ends either wait.'
-            },
-            waitMs: {
-                type: 'integer',
-                minimum: TOOL_EXECUTION_LIMITS.agentWaitMinWaitMs,
-                maximum: TOOL_EXECUTION_LIMITS.agentWaitMaxWaitMs,
-                default: TOOL_EXECUTION_LIMITS.agentWaitDefaultWaitMs,
-                description: `Timeout in milliseconds. Defaults to ${TOOL_EXECUTION_LIMITS.agentWaitDefaultWaitMs}, min ${TOOL_EXECUTION_LIMITS.agentWaitMinWaitMs}, max ${TOOL_EXECUTION_LIMITS.agentWaitMaxWaitMs}. Zero returns immediately. Positive values below ${TOOL_EXECUTION_LIMITS.agentWaitWaitFloorMs} are raised to ${TOOL_EXECUTION_LIMITS.agentWaitWaitFloorMs}.`
-            }
-        },
-        additionalProperties: false
-    }
-};
-export async function executeAgentWait(arguments_, context) {
-    const value = parseAgentWaitInput(arguments_);
-    const subagents = context.subagents;
-    if (!subagents)
-        throw new AgentError('MAR_AGENT_SUBAGENT_RECURSION_DISABLED', 'Subagents cannot recurse.');
-    const options = {
-        waitMs: value.waitMs ?? TOOL_EXECUTION_LIMITS.agentWaitDefaultWaitMs,
-        waitFor: value.waitFor ?? 'completion',
-        signal: context.signal,
-        waitInterrupt: context.waitInterrupt
-    };
-    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', 'agentIds', 'mode', 'waitFor', 'waitMs'].includes(key)) ||
-        (input.agentId !== undefined &&
-            input.agentId !== null &&
-            (typeof input.agentId !== 'string' || input.agentId.trim().length === 0)) ||
-        (input.waitFor !== undefined &&
-            input.waitFor !== null &&
-            input.waitFor !== 'completion' &&
-            input.waitFor !== 'message') ||
-        (input.waitMs !== undefined &&
-            input.waitMs !== null &&
-            (!Number.isInteger(input.waitMs) ||
-                input.waitMs < TOOL_EXECUTION_LIMITS.agentWaitMinWaitMs ||
-                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 }
-            : {}),
-        ...(typeof input.waitMs === 'number' ? { waitMs: input.waitMs } : {})
-    };
-}
-function invalidAgentWait() {
-    throw new AgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Agent wait input is invalid.');
-}