@myagentroam/agent 0.11.39 → 0.11.41

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/permissions.d.ts

@@ -19,7 +19,6 @@ export declare const permissionSchema: {
         };
         reason: {
             type: string;
-            description: string;
         };
     };
     required: string[];

package/dist/tools/permissions.js

@@ -17,10 +17,7 @@ export const permissionSchema = {
     type: 'object',
     properties: {
         action: { type: 'string', enum: ['allow', 'ask', 'deny'] },
-        reason: {
-            type: 'string',
-            description: 'Brief public reason, required for ask/deny; never include secrets.'
-        }
+        reason: { type: 'string' }
     },
     required: ['action'],
     additionalProperties: false
@@ -49,11 +46,6 @@ export function projectPermissionTool(tool) {
         ...tool,
         inputMode: 'json',
         ...(parameterless ? { parameterless: true } : {}),
-        description: tool.description +
-            '\nAuto mode: use the declared JSON input. Omit permission (or set null) for routine or already authorized work. Use {action:"ask"|"deny",reason:"brief public reason"} only when required. ' +
-            (flat
-                ? 'Permission is metadata, not a business argument.'
-                : 'Place the unchanged business arguments in input; permission is separate metadata.'),
         inputSchema: flat
             ? {
                 ...tool.inputSchema,

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.41",
   "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",

package/dist/extensions/agents.d.ts

@@ -1,100 +0,0 @@
-import type { AgentReasoningEffort } from '../model/configuration.js';
-import type { SubagentTaskSnapshot, SubagentManyOutput, SubagentHandledResult } from '../subagent/contracts.js';
-import type { ExtensionOperationContext } from './operation.js';
-import type { ExtensionResourceScope } from './resources.js';
-import type { ExtensionHooks } from './hooks.js';
-import type { ExtensionCapabilitySnapshot } from './capabilities.js';
-export type ExtensionAgentSnapshot = Readonly<SubagentTaskSnapshot>;
-export type ExtensionAgentManySnapshot = Readonly<SubagentManyOutput>;
-export type ExtensionAgentWaitResult = ExtensionAgentSnapshot | ExtensionAgentManySnapshot;
-export type ExtensionAgentHandledResult = SubagentHandledResult;
-export type ExtensionAgentSpawnResult = ExtensionAgentSnapshot | ExtensionAgentHandledResult;
-export declare function isHandledAgentResult(value: ExtensionAgentSpawnResult | ExtensionAgentManySnapshot): value is ExtensionAgentHandledResult;
-export interface ExtensionAgentSpawnInput {
-    readonly turnSignal?: AbortSignal;
-    readonly waitFor?: 'start' | 'completion';
-    readonly background?: boolean;
-    readonly prompt: string;
-    readonly description?: string;
-    readonly modelId?: string;
-    readonly reasoningEffort?: AgentReasoningEffort;
-    readonly role?: 'general-purpose' | 'explore';
-    readonly signal?: AbortSignal;
-}
-export interface ExtensionAgentTarget {
-    readonly agentId: string;
-    readonly signal?: AbortSignal;
-}
-export interface ExtensionAgentWaitInput {
-    readonly untilSettled?: true;
-    readonly agentId?: string;
-    readonly agentIds?: readonly string[];
-    readonly mode?: 'any' | 'all';
-    readonly signal?: AbortSignal;
-    readonly waitMs?: number;
-    readonly waitFor?: 'completion' | 'message';
-}
-export interface ExtensionAgentMessageInput extends ExtensionAgentTarget {
-    readonly message: string;
-    readonly delivery?: 'append' | 'replace';
-}
-export interface ExtensionAgentsBackend {
-    own(ownerInstanceId: string): () => Promise<void>;
-    spawn(input: ExtensionAgentSpawnInput, call: ExtensionOperationContext): Promise<ExtensionAgentSnapshot>;
-    list(call: ExtensionOperationContext): Promise<readonly ExtensionAgentSnapshot[]>;
-    inspect(input: ExtensionAgentTarget, call: ExtensionOperationContext): Promise<ExtensionAgentSnapshot>;
-    wait(input: ExtensionAgentWaitInput, call: ExtensionOperationContext): Promise<ExtensionAgentWaitResult>;
-    message(input: ExtensionAgentMessageInput, call: ExtensionOperationContext): Promise<ExtensionAgentSnapshot>;
-    cancel(input: ExtensionAgentTarget, call: ExtensionOperationContext): Promise<ExtensionAgentSnapshot>;
-}
-export interface ExtensionAgentsApi {
-    spawn(input: ExtensionAgentSpawnInput): Promise<ExtensionAgentSpawnResult>;
-    list(input?: {
-        readonly signal?: AbortSignal;
-    }): Promise<readonly ExtensionAgentSnapshot[]>;
-    inspect(input: ExtensionAgentTarget): Promise<ExtensionAgentSnapshot>;
-    wait(input: ExtensionAgentWaitInput & {
-        readonly agentIds: readonly string[];
-    }): Promise<ExtensionAgentManySnapshot>;
-    wait(input: ExtensionAgentWaitInput & {
-        readonly agentIds?: undefined;
-    }): Promise<ExtensionAgentSnapshot>;
-    wait(input: ExtensionAgentWaitInput): Promise<ExtensionAgentWaitResult>;
-    message(input: ExtensionAgentMessageInput): Promise<ExtensionAgentSnapshot>;
-    cancel(input: ExtensionAgentTarget): Promise<ExtensionAgentSnapshot>;
-}
-export interface ExtensionAgentCompletion {
-    readonly operation: 'spawn' | 'wait' | 'message' | 'cancel';
-    readonly agentId: string;
-    readonly status: SubagentTaskSnapshot['status'];
-    readonly deliveryStatus?: SubagentTaskSnapshot['deliveryStatus'];
-}
-type AgentOperation = 'agent.spawn' | 'agent.wait' | 'agent.message' | 'agent.cancel';
-export type ExtensionAgentAction = <Key extends AgentOperation>(key: Key, input: DomainAgentOperations[Key]['input'], leaf: (input: DomainAgentOperations[Key]['input'], call: ExtensionOperationContext) => Promise<DomainAgentOperations[Key]['output']>) => Promise<DomainAgentOperations[Key]['output']>;
-/** All callers share one interception and authoritative leaf-completion boundary. */
-export declare function invokeCoreAgentOperation<Key extends AgentOperation>(hooks: Pick<ExtensionHooks<DomainAgentOperations, DomainAgentFacts>, 'invoke' | 'emit'>, key: Key, input: DomainAgentOperations[Key]['input'], call: ExtensionOperationContext, leaf: (input: DomainAgentOperations[Key]['input'], call: ExtensionOperationContext) => Promise<DomainAgentOperations[Key]['output']>): Promise<DomainAgentOperations[Key]['output']>;
-export declare function resolveAgentSpawn(input: ExtensionAgentSpawnInput): ExtensionAgentSpawnInput;
-export declare function agentCapabilities(capabilities: ExtensionCapabilitySnapshot, available: boolean): ExtensionCapabilitySnapshot;
-export declare function bindCoreAgents(backend: ExtensionAgentsBackend, scope: ExtensionResourceScope, run: <Value>(operation: (call: ExtensionOperationContext) => Promise<Value>, signal?: AbortSignal) => Promise<Value>, hooks: Pick<ExtensionHooks<DomainAgentOperations, DomainAgentFacts>, 'invoke' | 'emit'>): ExtensionAgentsApi;
-export interface DomainAgentOperations {
-    'agent.spawn': {
-        input: ExtensionAgentSpawnInput;
-        output: ExtensionAgentSpawnResult;
-    };
-    'agent.wait': {
-        input: ExtensionAgentWaitInput;
-        output: ExtensionAgentWaitResult;
-    };
-    'agent.message': {
-        input: ExtensionAgentMessageInput;
-        output: ExtensionAgentSnapshot;
-    };
-    'agent.cancel': {
-        input: ExtensionAgentTarget;
-        output: ExtensionAgentSnapshot;
-    };
-}
-export interface DomainAgentFacts {
-    'agent.completed': ExtensionAgentCompletion;
-}
-export {};

package/dist/extensions/agents.js

@@ -1,121 +0,0 @@
-import { AgentError } from '../error.js';
-import { parseAgentWaitTargets } from '../subagent/wait-targets.js';
-export function isHandledAgentResult(value) {
-    return 'outcome' in value && value.outcome === 'handled' && !Object.hasOwn(value, 'agentId');
-}
-/** All callers share one interception and authoritative leaf-completion boundary. */
-export function invokeCoreAgentOperation(hooks, key, input, call, leaf) {
-    return hooks.invoke(key, input, call, async (input, effective) => {
-        const result = structuredClone(await leaf(input, effective));
-        if (isHandledAgentResult(result))
-            return result;
-        const agents = Array.isArray(result.agents)
-            ? result.agents
-            : [result];
-        for (const agent of agents)
-            await hooks.emit('agent.completed', {
-                operation: key.slice('agent.'.length),
-                agentId: agent.agentId,
-                status: agent.status,
-                ...(agent.deliveryStatus === undefined ? {} : { deliveryStatus: agent.deliveryStatus })
-            }, effective);
-        return result;
-    });
-}
-export function resolveAgentSpawn(input) {
-    if (!input ||
-        typeof input !== 'object' ||
-        Array.isArray(input) ||
-        typeof input.prompt !== 'string' ||
-        !input.prompt.trim() ||
-        (input.turnSignal !== undefined && !(input.turnSignal instanceof AbortSignal)) ||
-        (input.description !== undefined &&
-            (typeof input.description !== 'string' || !input.description.trim())) ||
-        (input.modelId !== undefined && (typeof input.modelId !== 'string' || !input.modelId)) ||
-        (input.role !== undefined && input.role !== 'general-purpose' && input.role !== 'explore') ||
-        (input.background !== undefined && typeof input.background !== 'boolean') ||
-        (input.waitFor !== undefined && input.waitFor !== 'start' && input.waitFor !== 'completion') ||
-        (input.reasoningEffort !== undefined &&
-            !['low', 'medium', 'high', 'xhigh', 'max', 'ultra'].includes(input.reasoningEffort)))
-        throw invalid('Agent spawn input is invalid.');
-    return {
-        prompt: input.prompt,
-        ...(input.turnSignal === undefined ? {} : { turnSignal: input.turnSignal }),
-        ...(input.waitFor === undefined ? {} : { waitFor: input.waitFor }),
-        ...(input.background === undefined ? {} : { background: input.background }),
-        description: input.description ?? 'Extension agent',
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-        ...(input.modelId === undefined ? {} : { modelId: input.modelId }),
-        ...(input.reasoningEffort === undefined ? {} : { reasoningEffort: input.reasoningEffort }),
-        role: input.role ?? 'general-purpose'
-    };
-}
-export function agentCapabilities(capabilities, available) {
-    const values = Object.freeze(capabilities.list().filter((id) => id !== 'agents' || available));
-    return Object.freeze({ has: (id) => values.includes(id), list: () => values });
-}
-export function bindCoreAgents(backend, scope, run, hooks) {
-    scope.effect(() => backend.own(scope.instanceId));
-    const invoke = (key, input) => run((call) => invokeCoreAgentOperation(hooks, key, input, call, async (effectiveInput, effective) => {
-        let result;
-        switch (key) {
-            case 'agent.spawn':
-                result = await backend.spawn({
-                    ...resolveAgentSpawn(effectiveInput),
-                    ...(effectiveInput.turnSignal === undefined
-                        ? {}
-                        : {
-                            turnSignal: AbortSignal.any([
-                                scope.signal,
-                                effectiveInput.turnSignal
-                            ])
-                        })
-                }, effective);
-                break;
-            case 'agent.wait':
-                result = await backend.wait(effectiveInput, effective);
-                break;
-            case 'agent.message':
-                result = await backend.message(effectiveInput, effective);
-                break;
-            case 'agent.cancel':
-                result = await backend.cancel(effectiveInput, effective);
-                break;
-        }
-        return result;
-    }), input.signal);
-    const target = (input) => {
-        if (!input ||
-            typeof input !== 'object' ||
-            Array.isArray(input) ||
-            typeof input.agentId !== 'string' ||
-            !input.agentId)
-            throw invalid('Agent target is invalid.');
-        return { ...input };
-    };
-    return {
-        spawn: (input) => invoke('agent.spawn', { ...input }),
-        list: async (input = {}) => {
-            if (!input || typeof input !== 'object' || Array.isArray(input))
-                throw invalid('Agent list input is invalid.');
-            return run(async (call) => structuredClone(await backend.list(call)), input.signal);
-        },
-        inspect: async (input) => {
-            const copied = target(input);
-            return run(async (call) => structuredClone(await backend.inspect(copied, call)), copied.signal);
-        },
-        wait: (async (input) => {
-            if (!input || typeof input !== 'object' || Array.isArray(input))
-                throw invalid('Agent wait input is invalid.');
-            const selection = parseAgentWaitTargets(input);
-            return invoke('agent.wait', input.agentId === undefined
-                ? { ...input, ...selection }
-                : target(input));
-        }),
-        message: async (input) => invoke('agent.message', target(input)),
-        cancel: async (input) => invoke('agent.cancel', target(input))
-    };
-}
-function invalid(message) {
-    return new AgentError('MAR_AGENT_EXTENSION_AGENT_INPUT_INVALID', message);
-}

package/dist/runtime/context/gc-candidates-subagent.d.ts

@@ -1,6 +0,0 @@
-import { type ContextGcPlannerInput, type ContextCandidate, type CandidateSavings, type ToolGroup } from './gc-contracts.js';
-export declare function collectSubagentCandidates(input: ContextGcPlannerInput, groups: ReadonlyMap<string, ToolGroup>, existingTargets: ReadonlySet<string>, candidateSavings: CandidateSavings): {
-    eligible: ContextCandidate[];
-    protectedTokens: number;
-    retryAfterRollouts: number;
-};