@myagentroam/agent 0.11.32 → 0.11.34

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

@@ -1,14 +0,0 @@
-import { waitForToolCondition } from '../tools/wait.js';
-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;
-};
-export { waitDeadline } from '../tools/wait.js';
-/** A group owns one listener and one deadline; readiness never consumes observations. */
-export declare function waitForAgentCondition(input: Parameters<typeof waitForToolCondition>[0]): Promise<boolean>;

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

@@ -1,32 +0,0 @@
-import { waitForToolCondition } from '../tools/wait.js';
-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.');
-}
-export { waitDeadline } from '../tools/wait.js';
-/** A group owns one listener and one deadline; readiness never consumes observations. */
-export async function waitForAgentCondition(input) {
-    return (await waitForToolCondition(input)) === 'ready';
-}

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

@@ -1,7 +0,0 @@
-import type { ClientToolDefinition } from '../../model/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/agent-core/tools/agent/agent-cancel.js

@@ -1,29 +0,0 @@
-import { MarAgentError } 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 MarAgentError('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 MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Agent cancellation input is invalid.');
-}

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

@@ -1,7 +0,0 @@
-import type { ClientToolDefinition } from '../../model/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/agent-core/tools/agent/agent-message.js

@@ -1,57 +0,0 @@
-import { MarAgentError } 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 MarAgentError('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 MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Agent message input is invalid.');
-}

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

@@ -1,12 +0,0 @@
-import type { ClientToolDefinition } from '../../model/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/agent-core/tools/agent/agent-start.js

@@ -1,106 +0,0 @@
-import { MarAgentError } from '../../error.js';
-import { marAgentReasoningEffortSchema } 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: marAgentReasoningEffortSchema.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 MarAgentError('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' ||
-                !marAgentReasoningEffortSchema.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: marAgentReasoningEffortSchema.parse(input.reasoningEffort.trim()) }
-            : {}),
-        background: true
-    };
-}
-function invalidAgentStart() {
-    throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Agent start input is invalid.');
-}

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

@@ -1,7 +0,0 @@
-import type { ClientToolDefinition } from '../../model/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/agent-core/tools/agent/agent-wait.js

@@ -1,91 +0,0 @@
-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. 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 MarAgentError('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 MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Agent wait input is invalid.');
-}

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

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

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

@@ -1,125 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { MarAgentError } from '../../error.js';
-import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
-export const questionToolDefinition = {
-    name: 'question',
-    allowedCallers: ['direct'],
-    parallelSafety: 'serial',
-    description: 'Pause for one to three tightly related user-owned decisions that materially change the result and cannot be inferred from the request, conversation, or relevant safe discovery. Prefer asking over guessing in Plan mode; do not avoid clarification by inventing configuration, branches, abstractions, or support for multiple outcomes. Provide 2-3 mutually exclusive options with consequences, put the recommended option first and identify it in its label or description, and use another question round if key ambiguity remains. This is not a permission/approval tool and should not interrupt routine in-scope work.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            questions: {
-                type: 'array',
-                minItems: 1,
-                maxItems: 3,
-                items: {
-                    type: 'object',
-                    properties: {
-                        id: { type: 'string' },
-                        header: { type: 'string' },
-                        question: {
-                            type: 'string',
-                            maxLength: TOOL_EXECUTION_LIMITS.questionMaxTextCharacters
-                        },
-                        options: {
-                            type: 'array',
-                            minItems: 2,
-                            maxItems: 3,
-                            description: 'Provide 2-3 mutually exclusive choices with consequences. Put the recommended option first and identify it in its label or description.',
-                            items: {
-                                type: 'object',
-                                properties: {
-                                    label: { type: 'string', maxLength: 80 },
-                                    description: {
-                                        type: 'string',
-                                        maxLength: TOOL_EXECUTION_LIMITS.questionMaxOptionCharacters
-                                    }
-                                },
-                                required: ['label', 'description'],
-                                additionalProperties: false
-                            }
-                        }
-                    },
-                    required: ['id', 'header', 'question', 'options'],
-                    additionalProperties: false
-                }
-            }
-        },
-        required: ['questions'],
-        additionalProperties: false
-    }
-};
-export async function executeQuestion(arguments_, context) {
-    const value = parseQuestionInput(arguments_);
-    if (!context.host.requestUserInput)
-        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Question Host capability is unavailable.');
-    const requestId = randomUUID();
-    await context.emit({ type: 'user_input.requested', requestId, questions: value.questions });
-    const answers = await context.host.requestUserInput({ requestId, questions: value.questions }, context.signal);
-    await context.emit({ type: 'user_input.resolved', requestId });
-    if (!answers || typeof answers !== 'object' || Array.isArray(answers))
-        throw new MarAgentError('MAR_AGENT_USER_INPUT_INVALID', 'Question answers are invalid.');
-    const expectedIds = value.questions.map((question) => question.id).sort();
-    const answerIds = Object.keys(answers).sort();
-    if (expectedIds.length !== answerIds.length ||
-        expectedIds.some((id, index) => id !== answerIds[index]))
-        throw new MarAgentError('MAR_AGENT_USER_INPUT_INVALID', 'Question answers are incomplete.');
-    if (Object.values(answers).some((answer) => typeof answer !== 'string' || !answer.trim()))
-        throw new MarAgentError('MAR_AGENT_USER_INPUT_INVALID', 'Question answers are invalid.');
-    return { content: JSON.stringify(answers), data: answers };
-}
-function parseQuestionInput(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return invalidQuestion();
-    const input = value;
-    if (Object.keys(input).some((key) => key !== 'questions') || !Array.isArray(input.questions))
-        return invalidQuestion();
-    if (input.questions.length < 1 || input.questions.length > 3)
-        return invalidQuestion();
-    const questions = input.questions.map((question) => {
-        if (!question || typeof question !== 'object' || Array.isArray(question))
-            return invalidQuestion();
-        const record = question;
-        if (Object.keys(record).some((key) => !['id', 'header', 'question', 'options'].includes(key)) ||
-            typeof record.id !== 'string' ||
-            record.id.trim().length === 0 ||
-            record.id.length > 128 ||
-            typeof record.header !== 'string' ||
-            record.header.trim().length === 0 ||
-            record.header.length > 80 ||
-            typeof record.question !== 'string' ||
-            record.question.trim().length === 0 ||
-            record.question.length > TOOL_EXECUTION_LIMITS.questionMaxTextCharacters ||
-            !Array.isArray(record.options) ||
-            record.options.length < 2 ||
-            record.options.length > 3)
-            return invalidQuestion();
-        const options = record.options.map((option) => {
-            if (!option || typeof option !== 'object' || Array.isArray(option))
-                return invalidQuestion();
-            const item = option;
-            if (Object.keys(item).some((key) => !['label', 'description'].includes(key)) ||
-                typeof item.label !== 'string' ||
-                item.label.trim().length === 0 ||
-                item.label.length > 80 ||
-                typeof item.description !== 'string' ||
-                item.description.trim().length === 0 ||
-                item.description.length > TOOL_EXECUTION_LIMITS.questionMaxOptionCharacters)
-                return invalidQuestion();
-            return { label: item.label, description: item.description };
-        });
-        return {
-            id: record.id,
-            header: record.header,
-            question: record.question,
-            options
-        };
-    });
-    if (new Set(questions.map((question) => question.id)).size !== questions.length)
-        return invalidQuestion();
-    return { questions };
-}
-function invalidQuestion() {
-    throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Question input is invalid.');
-}

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

@@ -1,11 +0,0 @@
-import type { ClientToolDefinition } from '../../model/contracts.js';
-import type { ToolRuntimeContext } from '../runtime-context.js';
-export declare const skillToolDefinition: ClientToolDefinition;
-export declare function executeSkill(arguments_: unknown, context: ToolRuntimeContext): Promise<{
-    content: string;
-    data: {
-        name: string;
-        description: string;
-        source: string;
-    };
-}>;

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

@@ -1,38 +0,0 @@
-import { MarAgentError } from '../../error.js';
-import { agentSkillSource, loadAgentSkill } from '../../runtime/context/instructions.js';
-export const skillToolDefinition = {
-    name: 'skill',
-    allowedCallers: ['direct'],
-    parallelSafety: 'safe',
-    description: "Load a Skill's instructions by its exact catalog name.",
-    inputSchema: {
-        type: 'object',
-        properties: {
-            name: { type: 'string', minLength: 1, maxLength: 128 }
-        },
-        required: ['name'],
-        additionalProperties: false
-    }
-};
-export async function executeSkill(arguments_, context) {
-    context.signal.throwIfAborted();
-    if (arguments_ === null || typeof arguments_ !== 'object' || Array.isArray(arguments_))
-        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Skill input must be an object.');
-    const input = arguments_;
-    if (typeof input.name !== 'string' ||
-        input.name.length === 0 ||
-        input.name.length > 128 ||
-        Object.keys(input).some((key) => key !== 'name'))
-        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Skill input is invalid.');
-    const skill = context.skills.get(input.name);
-    if (!skill)
-        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Skill is not available.');
-    const content = await loadAgentSkill(skill);
-    if (!content)
-        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Skill could not be loaded.');
-    context.signal.throwIfAborted();
-    return {
-        content,
-        data: { name: skill.name, description: skill.description, source: agentSkillSource(skill) }
-    };
-}

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

@@ -1,12 +0,0 @@
-import type { ClientToolDefinition } from '../../model/contracts.js';
-import type { ToolRuntimeContext } from '../runtime-context.js';
-export interface SleepResult {
-    durationMs: number;
-    elapsedMs: number;
-    wakeReason: 'elapsed' | 'steer' | 'subagent_message';
-}
-export declare const sleepToolDefinition: ClientToolDefinition;
-export declare function executeSleep(arguments_: unknown, context: ToolRuntimeContext, callId: string): Promise<{
-    content: string;
-    data: SleepResult;
-}>;

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

@@ -1,54 +0,0 @@
-import { MarAgentError } from '../../error.js';
-import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
-import { waitForToolCondition } from '../wait.js';
-export const sleepToolDefinition = {
-    name: 'sleep',
-    allowedCallers: ['direct'],
-    parallelSafety: 'serial',
-    description: 'Pause for up to durationMs milliseconds. Returns early when user input or a new public subagent message is available. Returns elapsed time and the wake reason.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            durationMs: {
-                type: 'integer',
-                minimum: 1,
-                maximum: TOOL_EXECUTION_LIMITS.sleepMaxDurationMs
-            }
-        },
-        required: ['durationMs'],
-        additionalProperties: false
-    }
-};
-export async function executeSleep(arguments_, context, callId) {
-    const durationMs = arguments_ && typeof arguments_ === 'object' && !Array.isArray(arguments_)
-        ? arguments_.durationMs
-        : undefined;
-    if (typeof durationMs !== 'number' ||
-        !Number.isInteger(durationMs) ||
-        durationMs < 1 ||
-        durationMs > TOOL_EXECUTION_LIMITS.sleepMaxDurationMs)
-        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Sleep duration is out of range.');
-    context.signal.throwIfAborted();
-    const started = performance.now();
-    await context.emit({
-        type: 'sleep.started',
-        callId,
-        durationMs,
-        startedAt: new Date().toISOString()
-    });
-    const messages = context.subagentMessages;
-    const outcome = await waitForToolCondition({
-        ready: () => messages?.pending() ?? false,
-        subscribe: (notify) => messages?.subscribe(notify) ?? (() => { }),
-        waitMs: Math.max(0, durationMs - (performance.now() - started)),
-        signal: context.signal,
-        interrupt: context.waitInterrupt
-    });
-    context.signal.throwIfAborted();
-    const data = {
-        durationMs,
-        elapsedMs: Math.round(performance.now() - started),
-        wakeReason: outcome === 'ready' ? 'subagent_message' : outcome === 'interrupted' ? 'steer' : 'elapsed'
-    };
-    return { content: JSON.stringify(data), data };
-}

package/dist/agent-core/tools/agent/smart-compact.d.ts

@@ -1,9 +0,0 @@
-import type { ClientToolDefinition } from '../../model/contracts.js';
-import type { ToolRuntimeContext } from '../runtime-context.js';
-export declare const smartCompactToolDefinition: ClientToolDefinition;
-export declare function executeSmartCompact(arguments_: unknown, context: ToolRuntimeContext): Promise<{
-    content: string;
-    data: {
-        status: string;
-    };
-}>;