@myagentroam/agent 0.11.39 → 0.11.40

package/dist/tools/contracts.d.ts

@@ -9,6 +9,8 @@ export interface ClientToolDefinition extends ModelToolDefinition {
     outputSchema?: Record<string, unknown>;
     /** Runtime-only policy. MCP defaults to both callers; other tools default to direct only. */
     allowedCallers?: readonly ToolCaller[];
+    /** Runtime-only allowlist of scalar fields in the public tool.started input. */
+    eventInputFields?: readonly string[];
     /** Runtime-only exposure override; retains both permitted entry points with Code Mode enabled. */
     codeModeExposure?: 'both';
     parallelSafety?: 'safe' | 'serial';
@@ -95,12 +97,24 @@ export interface ExecOutputSnapshot {
     stdout: string;
     stderr: string;
     truncated: boolean;
+    displayOutput?: ExecDisplayOutput;
+}
+/** Bounded, non-consuming tail for public presentation, not model output. */
+export interface ExecDisplayOutput {
+    stdout: string;
+    stderr: string;
+    stdoutDroppedBytes: number;
+    stderrDroppedBytes: number;
 }
 export interface ToolExecutionResult {
     calls?: readonly import('../session/code-observation-contract.js').CodeToolCallRecord[];
     content: string;
     observations?: readonly import('../session/code-observation-contract.js').CodeObservation[];
+    /** Explicit, bounded public structured projection; never inferred from data. */
+    eventData?: Readonly<Record<string, unknown>>;
     data?: unknown;
+    /** Explicit public event summary, separate from model-visible content. */
+    eventSummary?: string;
     /** Runtime-only definitions used to encode a Tool Search output. */
     toolSearchTools?: readonly ClientToolDefinition[];
     truncated?: boolean;
@@ -117,7 +131,12 @@ export interface CodeCellEventData {
     waitOutcome?: import('./wait.js').ToolWaitOutcome;
     reason?: 'steer';
     cached?: boolean;
+    truncated?: boolean;
     observations?: readonly import('../session/code-observation-contract.js').CodeObservation[];
+    error?: {
+        code: string;
+        message: string;
+    };
 }
 export interface ExecResult {
     status: 'running' | 'completed' | 'cancelled';
@@ -134,6 +153,7 @@ export interface ExecResult {
     stderrDroppedBytes: number;
     /** A terminal snapshot replay rather than new process output. */
     cached?: boolean;
+    displayOutput?: ExecDisplayOutput;
 }
 export interface ApplyPatchFileResult {
     path: string;

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

@@ -1,24 +1,4 @@
 export declare const TOOL_EXECUTION_LIMITS: Readonly<{
-    sleepMaxDurationMs: 1800000;
-    questionMaxTextCharacters: 1000;
-    questionMaxOptionCharacters: 500;
-    todoMaxItems: 100;
-    todoMaxTextCharacters: 1000;
-    agentWaitMinWaitMs: 0;
-    agentWaitWaitFloorMs: 10000;
-    agentWaitDefaultWaitMs: 30000;
-    agentWaitMaxWaitMs: 300000;
-    agentWaitMaxAgents: 8;
-    subagentDescriptionMaxCharacters: 80;
-    subagentPromptMaxBytes: 131072;
-    subagentMessageMaxBytes: 131072;
-    subagentReasoningEffortMaxCharacters: 64;
-    subagentSummaryMaxBytes: 16384;
-    subagentUpdateMaxBytes: 32768;
-    subagentRunningLatestMessageMaxCharacters: 2000;
-    subagentEvidenceMaxItems: 64;
-    subagentVerificationMaxItems: 16;
-    subagentChangedFilesMaxItems: 200;
     readDefaultLines: 200;
     readMaxLines: 2000;
     readMaxBytes: 1048576;
@@ -66,4 +46,9 @@ export declare const TOOL_EXECUTION_LIMITS: Readonly<{
     patchMaxFiles: 100;
     patchMaxFileBytes: 8388608;
     patchMaxTotalBytes: 33554432;
+    sleepMaxDurationMs: 1800000;
+    questionMaxTextCharacters: 1000;
+    questionMaxOptionCharacters: 500;
+    todoMaxItems: 100;
+    todoMaxTextCharacters: 1000;
 }>;

package/dist/tools/execution-limits.js

@@ -1,6 +1,5 @@
 import { CODE_STATE_LIMITS } from '../session/code-state.js';
 import { HISTORY_INPUT_LIMITS } from '../session/history-input-limits.js';
-import { SUBAGENT_LIMITS } from '../subagent/limits.js';
 export const TOOL_EXECUTION_LIMITS = Object.freeze({
     readDefaultLines: 200,
     readMaxLines: 2_000,
@@ -49,7 +48,6 @@ export const TOOL_EXECUTION_LIMITS = Object.freeze({
     patchMaxFiles: 100,
     patchMaxFileBytes: 8_388_608,
     patchMaxTotalBytes: 33_554_432,
-    ...SUBAGENT_LIMITS,
     sleepMaxDurationMs: 1_800_000,
     questionMaxTextCharacters: 1_000,
     questionMaxOptionCharacters: 500,

package/dist/tools/execution.js

@@ -3,7 +3,7 @@ import { toolEventSummary } from '../runtime/event-projection.js';
 import { allowsToolCaller } from './callers.js';
 import { CodeCellExecutionError } from './code-mode/cells.js';
 import { createCodeToolDispatch } from './code-mode/dispatch.js';
-import { boundedModelToolOutput, structuredToolArtifacts, structuredToolEventData, structuredToolFailureData } from './output-projection.js';
+import { boundedModelToolOutput, publicToolEventInput, structuredToolArtifacts, publicExtensionToolEventData, structuredToolEventData, structuredToolFailureData } from './output-projection.js';
 import { publishModelResources } from '../runtime/resource-publication.js';
 import { executeRegisteredTool } from './runtime.js';
 import { failedToolResultExtensions } from './result-extensions.js';
@@ -78,12 +78,16 @@ export async function createRoundToolRuntimeContext(scope, call, signal) {
 /** Complete every call in model order even if individual execution fails. */
 export async function executeRoundTools(calls, scope) {
     const executeCall = async (call, signal = scope.context.signal, caller = 'direct', parentCallId) => {
+        const inputFields = scope.tools.find((tool) => tool.name === call.name)?.eventInputFields;
+        const publicInput = inputFields === undefined
+            ? call.arguments
+            : publicToolEventInput(call.arguments, inputFields);
         await scope.emit({
             type: 'tool.started',
             toolName: call.name,
             callId: call.callId,
             ...(parentCallId === undefined ? {} : { parentCallId }),
-            input: call.arguments
+            input: publicInput
         });
         try {
             if (call.argumentError)
@@ -109,8 +113,16 @@ export async function executeRoundTools(calls, scope) {
                     ...(publishedImages === undefined ? {} : { images: publishedImages })
                 };
             const modelOutput = boundedModelToolOutput(call.name, output.content, output.data);
-            const eventSummary = toolEventSummary(output.content);
-            const structuredData = structuredToolEventData(call.name, output.data);
+            const eventSummary = toolEventSummary(output.eventSummary === undefined
+                ? output.content
+                : typeof output.eventSummary === 'string'
+                    ? output.eventSummary
+                    : '');
+            const structuredData = call.name === 'exec' || call.name === 'exec_wait'
+                ? structuredToolEventData(call.name, output.eventData ?? output.data)
+                : output.eventData === undefined
+                    ? structuredToolEventData(call.name, output.data)
+                    : publicExtensionToolEventData(output.eventData);
             const artifacts = structuredToolArtifacts(output.artifacts);
             await scope.emit({
                 type: 'tool.completed',

package/dist/tools/local/exec.js

@@ -2,7 +2,8 @@ import { AgentError } from '../../error.js';
 import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
 /** Share the model-facing body across direct calls and original Code Mode observations. */
 export function formatExecResult(result) {
-    const visible = { ...result };
+    const { displayOutput, ...modelResult } = result;
+    const visible = { ...modelResult };
     if (result.stderr === '')
         delete visible.stderr;
     if (!result.truncated) {
@@ -19,7 +20,12 @@ export function formatExecResult(result) {
         delete visible.stderrDroppedBytes;
     if (result.cached === false)
         delete visible.cached;
-    return { content: JSON.stringify(visible), data: result, truncated: result.truncated };
+    return {
+        content: JSON.stringify(visible),
+        data: displayOutput === undefined ? result : modelResult,
+        ...(displayOutput === undefined ? {} : { eventData: { ...modelResult, displayOutput } }),
+        truncated: result.truncated
+    };
 }
 export const execToolDefinition = {
     name: 'exec',

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

@@ -1,16 +1,19 @@
-import type { SubagentTaskSnapshot, SubagentManyOutput } from '../subagent/contracts.js';
 import type { ApplyPatchResult, ApplyPatchPartialResult, CodeCellEventData, ExecResult, AgentToolArtifact, ToolExecutionResult, ReadEventData, ViewImageResult } from './contracts.js';
 import type { ToolRuntimeImage } from './runtime-context.js';
 import type { SleepResult } from './agent/sleep.js';
 import { type PublicToolMetadata } from '../runtime/public-tool-metadata.js';
 import type { ModelImage } from '../model/image.js';
+/** Copy an explicitly public JSON object without exposing the full tool result. */
+export declare function publicExtensionToolEventData(value: unknown): Readonly<Record<string, unknown>> | undefined;
 export declare function currentExecutionImages(modelInputImages: readonly ModelImage[] | undefined, toolImages: readonly ToolRuntimeImage[]): ToolRuntimeImage[];
 export declare function boundedModelToolOutput(toolName: string, value: string, data: unknown): {
     content: string;
     truncated: boolean;
 };
+/** The opted-in allowlist fails closed and never mutates the invocation arguments. */
+export declare function publicToolEventInput(value: unknown, fields: readonly string[]): Readonly<Record<string, unknown>>;
 /** Project only known, validated tool result shapes into public structured events. */
-export declare function structuredToolEventData(toolName: string, value: unknown): CodeCellEventData | ExecResult | ApplyPatchResult | ReadEventData | ViewImageResult | SubagentTaskSnapshot | SubagentManyOutput | SleepResult | PublicToolMetadata | undefined;
+export declare function structuredToolEventData(toolName: string, value: unknown): CodeCellEventData | ExecResult | ApplyPatchResult | ReadEventData | ViewImageResult | SleepResult | PublicToolMetadata | undefined;
 /** Partial patch facts are allowlisted; arbitrary error details never become public event data. */
 export declare function structuredToolFailureData(toolName: string, error: unknown): ApplyPatchPartialResult | undefined;
 export declare function structuredToolArtifacts(value: readonly AgentToolArtifact[] | undefined): readonly AgentToolArtifact[] | undefined;

package/dist/tools/output-projection.js

@@ -4,6 +4,21 @@ import { AGENT_EXECUTION_POLICY } from '../runtime/execution-policy.js';
 import { countModelTokens, countTextLines, truncateModelText } from '../runtime/token-budget.js';
 import { TOOL_EXECUTION_LIMITS } from './execution-limits.js';
 import { publicToolMetadata } from '../runtime/public-tool-metadata.js';
+/** Copy an explicitly public JSON object without exposing the full tool result. */
+export function publicExtensionToolEventData(value) {
+    if (!isRecord(value))
+        return undefined;
+    try {
+        const json = JSON.stringify(value);
+        if (Buffer.byteLength(json, 'utf8') > 8192)
+            return undefined;
+        const copy = JSON.parse(json);
+        return isRecord(copy) ? copy : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function currentExecutionImages(modelInputImages, toolImages) {
     return [
         ...(modelInputImages ?? [])
@@ -34,6 +49,105 @@ export function boundedModelToolOutput(toolName, value, data) {
     const result = truncateModelText(value, AGENT_EXECUTION_POLICY.modelToolOutputTokens, 'tool output', execDiagnostics);
     return { content: result.content, truncated: result.truncated };
 }
+/** The opted-in allowlist fails closed and never mutates the invocation arguments. */
+export function publicToolEventInput(value, fields) {
+    try {
+        if (!isRecord(value))
+            return {};
+        const projected = Object.fromEntries(fields
+            .filter((key) => Object.hasOwn(value, key) &&
+            (typeof value[key] === 'string' ||
+                typeof value[key] === 'boolean' ||
+                (typeof value[key] === 'number' && Number.isFinite(value[key])) ||
+                value[key] === null))
+            .map((key) => [key, value[key]]));
+        return publicExtensionToolEventData(projected) ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Explicit observations are public, but their event projection must remain bounded. */
+function publicCodeObservations(values, data) {
+    if (!Array.isArray(values))
+        return data;
+    const retained = new Set(data.observations ?? []);
+    const selected = [];
+    let displayedCount = 0;
+    let remaining = 10_000;
+    let truncated = false;
+    const clip = (text) => {
+        let start = Math.max(0, text.length - remaining);
+        if (start > 0 && /[\uDC00-\uDFFF]/u.test(text[start]))
+            start++;
+        const result = text.slice(start);
+        remaining -= result.length;
+        truncated ||= start > 0;
+        return result;
+    };
+    for (let index = values.length - 1; index >= 0; index--) {
+        const entry = values[index];
+        if (!isRecord(entry))
+            continue;
+        if (entry.type === 'value' &&
+            typeof entry.value === 'string' &&
+            typeof entry.id === 'string' &&
+            (entry.format === 'text' || entry.format === 'json' || entry.format === 'image')) {
+            if (displayedCount >= 32) {
+                truncated = true;
+                continue;
+            }
+            displayedCount++;
+            truncated ||= entry.truncated === true;
+            const value = clip(entry.value);
+            selected.unshift({
+                type: 'value',
+                id: entry.id,
+                format: entry.format,
+                value,
+                ...(entry.truncated === true || value.length < entry.value.length
+                    ? { truncated: true }
+                    : {})
+            });
+        }
+        else if (entry.type === 'tool_result' && isRecord(entry.source) && isRecord(entry.result)) {
+            const name = entry.source.toolName;
+            if (name !== 'exec' && name !== 'exec_wait') {
+                if (retained.has(entry))
+                    selected.unshift(entry);
+            }
+            else if ((name === 'exec' || name === 'exec_wait') &&
+                typeof entry.id === 'string' &&
+                typeof entry.source.callId === 'string' &&
+                (entry.outcome === 'completed' || entry.outcome === 'failed')) {
+                if (displayedCount >= 32) {
+                    truncated = true;
+                    continue;
+                }
+                displayedCount++;
+                truncated ||= entry.result.truncated === true;
+                const data = isRecord(entry.result.data) ? entry.result.data : undefined;
+                const stderr = typeof data?.stderr === 'string' ? clip(data.stderr) : undefined;
+                const stdout = typeof data?.stdout === 'string' ? clip(data.stdout) : undefined;
+                const content = stdout === undefined && stderr === undefined && typeof entry.result.content === 'string'
+                    ? clip(entry.result.content)
+                    : '';
+                selected.unshift({
+                    type: 'tool_result',
+                    id: entry.id,
+                    source: { callId: entry.source.callId, toolName: name, input: null },
+                    outcome: entry.outcome,
+                    result: {
+                        content,
+                        ...(stdout === undefined && stderr === undefined ? {} : { data: { stdout, stderr } }),
+                        ...(entry.result.truncated === true || truncated ? { truncated: true } : {})
+                    }
+                });
+            }
+        }
+    }
+    return { ...data, observations: selected, ...(truncated ? { truncated: true } : {}) };
+}
 /** Project only known, validated tool result shapes into public structured events. */
 export function structuredToolEventData(toolName, value) {
     if (!isRecord(value))
@@ -57,22 +171,10 @@ export function structuredToolEventData(toolName, value) {
             elapsedMs: value.elapsedMs,
             wakeReason: value.wakeReason
         };
-    if (toolName === 'agent_wait' &&
-        (value.mode === 'any' || value.mode === 'all') &&
-        (value.waitFor === 'completion' || value.waitFor === 'message') &&
-        ['snapshot', 'message', 'completion', 'timeout', 'interrupted'].includes(String(value.waitOutcome)) &&
-        Array.isArray(value.agents) &&
-        value.agents.length > 0 &&
-        value.agents.length <= TOOL_EXECUTION_LIMITS.agentWaitMaxAgents &&
-        value.agents.every((agent) => isRecord(agent) && isSubagentTaskSnapshot(agent)) &&
-        Array.isArray(value.pendingAgentIds) &&
-        value.pendingAgentIds.every((id) => typeof id === 'string' &&
-            value.agents.some((agent) => agent.agentId === id)))
-        return value;
     if ((toolName === 'code_exec' || toolName === 'code_exec_wait') &&
         typeof value.cellId === 'string' &&
         ['running', 'completed', 'failed', 'cancelled'].includes(String(value.status)))
-        return {
+        return publicCodeObservations(value.observations, {
             cellId: value.cellId,
             status: value.status,
             cached: value.cached === true,
@@ -82,6 +184,21 @@ export function structuredToolEventData(toolName, value) {
             ...(value.waitOutcome === 'interrupted' && value.reason === 'steer'
                 ? { reason: 'steer' }
                 : {}),
+            ...(value.truncated === true ? { truncated: true } : {}),
+            ...(isRecord(value.error) &&
+                typeof value.error.code === 'string' &&
+                value.error.code.length > 0 &&
+                typeof value.error.message === 'string'
+                ? {
+                    ...(value.error.code.length > 80 || value.error.message.length > 1000
+                        ? { truncated: true }
+                        : {}),
+                    error: {
+                        code: value.error.code.slice(0, 80).replace(/[\uD800-\uDBFF]$/u, ''),
+                        message: value.error.message.slice(0, 1000).replace(/[\uD800-\uDBFF]$/u, '')
+                    }
+                }
+                : {}),
             ...(isRecord(value.permissionStop)
                 ? {
                     permissionStop: value.permissionStop
@@ -90,15 +207,7 @@ export function structuredToolEventData(toolName, value) {
             ...(Array.isArray(value.calls)
                 ? {
                     calls: value.calls.filter((entry) => isRecord(entry) &&
-                        [
-                            'apply_patch',
-                            'todo_read',
-                            'todo_write',
-                            'agent_start',
-                            'agent_wait',
-                            'agent_message',
-                            'agent_cancel'
-                        ].includes(String(entry.toolName)))
+                        ['apply_patch', 'todo_read', 'todo_write'].includes(String(entry.toolName)))
                 }
                 : {}),
             ...(Array.isArray(value.observations)
@@ -106,24 +215,10 @@ export function structuredToolEventData(toolName, value) {
                     observations: value.observations.filter((entry) => isRecord(entry) &&
                         entry.type === 'tool_result' &&
                         isRecord(entry.source) &&
-                        [
-                            'apply_patch',
-                            'todo_read',
-                            'todo_write',
-                            'agent_start',
-                            'agent_wait',
-                            'agent_message',
-                            'agent_cancel'
-                        ].includes(String(entry.source.toolName)))
+                        ['apply_patch', 'todo_read', 'todo_write'].includes(String(entry.source.toolName)))
                 }
                 : {})
-        };
-    if ((toolName === 'agent_start' ||
-        toolName === 'agent_wait' ||
-        toolName === 'agent_message' ||
-        toolName === 'agent_cancel') &&
-        isSubagentTaskSnapshot(value))
-        return value;
+        });
     if (toolName === 'read' &&
         value.mode === 'batch' &&
         Array.isArray(value.results) &&
@@ -282,60 +377,6 @@ export function validateToolResult(value) {
 function isRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
-function isSubagentTaskSnapshot(value) {
-    return (typeof value.agentId === 'string' &&
-        value.agentId.length > 0 &&
-        value.agentId.length <= 128 &&
-        typeof value.description === 'string' &&
-        value.description.length > 0 &&
-        value.description.length <= TOOL_EXECUTION_LIMITS.subagentDescriptionMaxCharacters &&
-        (value.status === 'queued' ||
-            value.status === 'running' ||
-            value.status === 'completed' ||
-            value.status === 'failed' ||
-            value.status === 'cancelled' ||
-            value.status === 'interrupted') &&
-        (value.modelId === undefined || typeof value.modelId === 'string') &&
-        (value.modelName === undefined || typeof value.modelName === 'string') &&
-        (value.reasoningEffort === undefined ||
-            (typeof value.reasoningEffort === 'string' &&
-                ['low', 'medium', 'high', 'xhigh', 'max', 'ultra'].includes(value.reasoningEffort))) &&
-        (value.waitOutcome === undefined ||
-            value.waitOutcome === 'snapshot' ||
-            value.waitOutcome === 'message' ||
-            value.waitOutcome === 'completion' ||
-            value.waitOutcome === 'timeout' ||
-            value.waitOutcome === 'interrupted') &&
-        (value.latestMessage === undefined ||
-            (isRecord(value.latestMessage) &&
-                typeof value.latestMessage.itemId === 'string' &&
-                typeof value.latestMessage.turnId === 'string' &&
-                (value.latestMessage.phase === 'commentary' ||
-                    value.latestMessage.phase === 'final_answer') &&
-                typeof value.latestMessage.text === 'string' &&
-                typeof value.latestMessage.timestamp === 'string' &&
-                typeof value.latestMessage.truncated === 'boolean')) &&
-        (value.summary === undefined || typeof value.summary === 'string') &&
-        (value.changedFiles === undefined ||
-            (Array.isArray(value.changedFiles) &&
-                value.changedFiles.every((path) => typeof path === 'string'))) &&
-        (value.verification === undefined ||
-            (Array.isArray(value.verification) &&
-                value.verification.every((item) => typeof item === 'string'))) &&
-        (value.evidence === undefined ||
-            (Array.isArray(value.evidence) &&
-                value.evidence.every((item) => isRecord(item) &&
-                    typeof item.path === 'string' &&
-                    (item.startLine === undefined ||
-                        (typeof item.startLine === 'number' &&
-                            Number.isInteger(item.startLine) &&
-                            item.startLine >= 1)) &&
-                    (item.endLine === undefined ||
-                        (typeof item.endLine === 'number' &&
-                            Number.isInteger(item.endLine) &&
-                            item.endLine >= 1))))) &&
-        (value.errorCode === undefined || typeof value.errorCode === 'string'));
-}
 function isNonnegativeInteger(value) {
     return typeof value === 'number' && Number.isInteger(value) && value >= 0;
 }

package/dist/tools/registry.js

@@ -1,7 +1,3 @@
-import { agentCancelToolDefinition, executeAgentCancel } from './agent/agent-cancel.js';
-import { agentMessageToolDefinition, executeAgentMessage } from './agent/agent-message.js';
-import { agentStartToolDefinition, executeAgentStart } from './agent/agent-start.js';
-import { agentWaitToolDefinition, executeAgentWait } from './agent/agent-wait.js';
 import { applyPatchToolDefinition } from './local/apply-patch.js';
 import { codeExecWaitToolDefinition, codeModeToolDefinition } from './code-mode/index.js';
 import { execToolDefinition, execWaitToolDefinition } from './local/exec.js';
@@ -27,10 +23,6 @@ export const BUILTIN_TOOL_DEFINITIONS = [
     questionToolDefinition,
     todoReadToolDefinition,
     todoWriteToolDefinition,
-    agentStartToolDefinition,
-    agentWaitToolDefinition,
-    agentMessageToolDefinition,
-    agentCancelToolDefinition,
     smartCompactToolDefinition,
     sleepToolDefinition
 ];
@@ -41,9 +33,5 @@ export const AGENT_TOOL_HANDLERS = new Map([
     ['tool_search', executeToolSearch],
     ['question', executeQuestion],
     ['todo_read', (_arguments, context) => executeTodoRead(context)],
-    ['todo_write', executeTodoWrite],
-    ['agent_start', executeAgentStart],
-    ['agent_wait', executeAgentWait],
-    ['agent_message', executeAgentMessage],
-    ['agent_cancel', executeAgentCancel]
+    ['todo_write', executeTodoWrite]
 ]);

package/dist/tools/runtime-context.d.ts

@@ -1,7 +1,6 @@
 import type { ResourcePublisher, ResourceStore } from '../runtime/resource-publication.js';
 import type { ExecutionMode } from '../runtime/contracts.js';
 import type { AgentSkill } from '../runtime/context/instructions.js';
-import type { SubagentController, SubagentLatestMessage } from '../subagent/contracts.js';
 import type { TodoStore } from './agent/todo.js';
 import type { McpToolCallContext, ToolCall, ToolExecutionContext, ToolExecutionResult } from './contracts.js';
 export interface ToolHost extends ResourcePublisher {
@@ -40,24 +39,6 @@ export type ToolRuntimeEvent = {
 } | {
     type: 'user_input.resolved';
     requestId: string;
-} | {
-    type: 'subagent.started';
-    agentId: string;
-    description: string;
-    modelId?: string;
-    modelName?: string;
-    reasoningEffort?: import('../model/configuration.js').AgentReasoningEffort;
-} | {
-    type: 'subagent.completed';
-    agentId: string;
-    description: string;
-    status: string;
-    modelId?: string;
-    modelName?: string;
-    reasoningEffort?: import('../model/configuration.js').AgentReasoningEffort;
-    latestMessage?: SubagentLatestMessage;
-    errorCode?: string;
-    errorMessage?: string;
 };
 export interface ToolRuntimeImage {
     readonly mimeType: string;
@@ -68,14 +49,13 @@ export interface ToolRuntimeContext {
     imageStore?: ToolImageStore;
     todo: TodoStore;
     requestSmartCompact?: () => void;
-    subagents?: SubagentController;
     mode: ExecutionMode;
     sessionId: string;
     executionId: string;
     modelId?: string;
     signal: AbortSignal;
     waitInterrupt?: import('./wait.js').ToolWaitInterrupt | undefined;
-    subagentMessages?: import('./wait.js').ToolWaitInterrupt;
+    contextUpdates?: import('./wait.js').ToolWaitInterrupt;
     permissionPolicy?: import('./permissions.js').ExecutionToolPermissions;
     parentCallId?: string;
     writeToolResultResource?: import('./result-extensions.js').ToolResultResourceWriter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/agent",
-  "version": "0.11.39",
+  "version": "0.11.40",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",
@@ -58,7 +58,7 @@
     "vitest": "^4.0.14"
   },
   "scripts": {
-    "build": "node ../scripts/clean-build-output.mjs dist && tsc -p tsconfig.json",
+    "build": "node ../scripts/clean-build-output.mjs dist && tsc -p tsconfig.json && tsc -p extensions/subagent/tsconfig.json --outDir dist/cli/subagent",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test:unit": "pnpm build && vitest run --config vitest.config.ts test/unit",
     "analyze:session": "node test/tools/session-analyzer.mjs",