@myagentroam/agent 0.11.39 → 0.11.41

package/dist/session/store/jsonl/jsonl-store.d.ts

@@ -115,7 +115,7 @@ export declare class JsonlSessionStore implements SessionStore {
     /** A warm cell retains physical writer ownership between Executions of the same Agent. */
     acquireSessionLease(sessionId: string, owner?: object): Promise<() => Promise<void>>;
     hasRetainedSessionLease(sessionId: string, owner: object): boolean;
-    acquireSessionMaintenance(sessionId: string, kind: 'clear' | 'delete', owner?: object): Promise<SessionStoreMaintenance>;
+    acquireSessionMaintenance(sessionId: string, kind: 'clear' | 'delete', owner?: object, members?: readonly string[]): Promise<SessionStoreMaintenance>;
     /** Native writes join their Agent's sole writer, without admitting another Execution. */
     acquireSessionWriteLease(sessionId: string, owner: object): Promise<() => Promise<void>>;
     retainSessionLease(sessionId: string, owner: object): Promise<() => Promise<void>>;

package/dist/session/store/jsonl/jsonl-store.js

@@ -219,20 +219,21 @@ export class JsonlSessionStore {
     async createSession(input) {
         this.#assertOpen();
         const source = normalizeSessionSource(input.source);
-        if (source.type !== 'subagent')
+        if (source.parentSessionId === undefined)
             return this.#createSession(input, source);
+        const parentSessionId = source.parentSessionId;
         // Publish under the parent's existing serial domain so tree admission cannot miss a child.
-        return this.#serializeRecordOperation(source.parentSessionId, async () => {
+        return this.#serializeRecordOperation(parentSessionId, async () => {
             this.#assertOpen();
-            if (this.#shared.writerLeases.get(source.parentSessionId)?.maintenance)
+            if (this.#shared.writerLeases.get(parentSessionId)?.maintenance)
                 throw new AgentError('MAR_AGENT_SESSION_LOCKED', 'Session is under maintenance.');
-            const release = await this.#acquirePublicationGate(source.parentSessionId, 5000);
+            const release = await this.#acquirePublicationGate(parentSessionId, 5000);
             let failure;
             try {
-                await this.#recoverPendingTreeDelete(source.parentSessionId);
-                if (this.#shared.writerLeases.get(source.parentSessionId)?.maintenance)
+                await this.#recoverPendingTreeDelete(parentSessionId);
+                if (this.#shared.writerLeases.get(parentSessionId)?.maintenance)
                     throw new AgentError('MAR_AGENT_SESSION_LOCKED', 'Session is under maintenance.');
-                await this.getSession(source.parentSessionId);
+                await this.getSession(parentSessionId);
                 return await this.#createSession(input, source);
             }
             catch (error) {
@@ -1408,13 +1409,27 @@ export class JsonlSessionStore {
         const lease = this.#shared.writerLeases.get(sessionId);
         return lease?.owner === owner && lease.retained > 0;
     }
-    async acquireSessionMaintenance(sessionId, kind, owner) {
+    async acquireSessionMaintenance(sessionId, kind, owner, members) {
         this.#assertOpen();
+        const ids = members === undefined ? [sessionId] : [...members];
+        if (ids.length === 0 ||
+            !ids.includes(sessionId) ||
+            new Set(ids).size !== ids.length ||
+            (kind === 'clear' && (ids.length !== 1 || ids[0] !== sessionId)))
+            throw new AgentError('MAR_AGENT_SESSION_INVALID', 'Invalid Session maintenance members.');
+        ids.sort();
+        for (const id of ids)
+            this.#sessionRoot(id);
         await this.#recoverPendingTreeDelete(sessionId);
         return acquireTreeMaintenance({
             sessionId,
             kind,
-            tree: () => this.sessionTree(sessionId),
+            tree: async () => {
+                await this.#refreshIndex();
+                if (ids.some((id) => !this.#shared.index.sessions.some((session) => session.id === id)))
+                    throw new AgentError('MAR_AGENT_SESSION_NOT_FOUND', 'Session was not found.');
+                return ids;
+            },
             acquire: (id, holding, registerGate) => this.#serializeRecordOperation(id, async () => {
                 this.#assertOpen();
                 registerGate(await this.#acquirePublicationGate(id));

package/dist/session/store/jsonl/resources.js

@@ -53,7 +53,11 @@ export async function persistResource(directory, image) {
     const data = Buffer.from(image.dataBase64 ?? '', 'base64');
     if (data.toString('base64') !== image.dataBase64)
         throw new AgentError('MAR_AGENT_SESSION_INPUT_INVALID', 'Image resource data is not canonical base64.');
-    if (!mimeTypes.has(image.mimeType) || data.length === 0 || data.length > 20 * 1024 * 1024)
+    if (!mimeTypes.has(image.mimeType))
+        throw new AgentError('MAR_AGENT_SESSION_INPUT_INVALID', 'Unsupported image resource format. Use PNG, JPEG, GIF, or WebP.');
+    if (data.length === 0)
+        throw new AgentError('MAR_AGENT_SESSION_INPUT_INVALID', 'Image resource data must not be empty.');
+    if (data.length > 20 * 1024 * 1024)
         throw new AgentError('MAR_AGENT_HOST_LIMIT_EXCEEDED', 'Image resource exceeds supported limits.');
     const sha256 = createHash('sha256').update(data).digest('hex');
     const resourceId = resourceIdentity(image.mimeType, sha256);

package/dist/session/types.d.ts

@@ -1,6 +1,7 @@
 /** Public session provenance; storage may persist additional private metadata. */
 export type SessionSource = {
     readonly type: 'user';
+    readonly parentSessionId?: string;
 } | {
     readonly type: 'subagent';
     readonly parentSessionId: string;

package/dist/tools/agent/sleep.js

@@ -36,7 +36,7 @@ export async function executeSleep(arguments_, context, callId) {
         durationMs,
         startedAt: new Date().toISOString()
     });
-    const messages = context.subagentMessages;
+    const messages = context.contextUpdates;
     const outcome = await waitForToolCondition({
         ready: () => messages?.pending() ?? false,
         subscribe: (notify) => messages?.subscribe(notify) ?? (() => { }),

package/dist/tools/callers.js

@@ -15,18 +15,7 @@ export function toolCallers(tool) {
 export function allowsToolCaller(tool, caller) {
     // Control tools cannot be widened by a Host override or historical definition.
     if (caller === 'programmatic' &&
-        [
-            'code_exec',
-            'code_exec_wait',
-            'tool_search',
-            'question',
-            'skill',
-            'sleep',
-            'agent_start',
-            'agent_wait',
-            'agent_message',
-            'agent_cancel'
-        ].includes(tool.name))
+        ['code_exec', 'code_exec_wait', 'tool_search', 'question', 'skill', 'sleep'].includes(tool.name))
         return false;
     return toolCallers(tool).includes(caller);
 }

package/dist/tools/code-mode/dispatch.js

@@ -32,7 +32,9 @@ export function createCodeToolDispatch(input) {
                     ...(expected ? { expectedMcpTool: expected } : {})
                 }, 'programmatic');
                 const bounded = boundedModelToolOutput(call.name, result.content, result.data);
-                const data = structuredToolEventData(call.name, result.data);
+                const data = structuredToolEventData(call.name, call.name === 'exec' || call.name === 'exec_wait'
+                    ? (result.eventData ?? result.data)
+                    : result.data);
                 const preview = toolEventSummary(result.content);
                 input.assertLive();
                 await input.emit({
@@ -44,8 +46,9 @@ export function createCodeToolDispatch(input) {
                     truncated: result.truncated === true || bounded.truncated || preview.truncated,
                     ...(result.artifacts ? { artifacts: result.artifacts } : {})
                 });
+                const { eventData: _eventData, ...guestResult } = result;
                 return {
-                    ...result,
+                    ...guestResult,
                     content: bounded.content,
                     truncated: result.truncated === true || bounded.truncated
                 };

package/dist/tools/code-mode/index.d.ts

@@ -22,7 +22,7 @@ export declare class CodeModeTool {
     wait(value: unknown, context: ToolExecutionContext): Promise<ToolExecutionResult>;
     listSessionResources(sessionId: string): {
         cellId: string;
-        status: "completed" | "failed" | "cancelled" | "running";
+        status: "running" | "failed" | "cancelled" | "completed";
         executionId: string;
     }[];
     constructor(paths: WorkspacePathResolver, environment: NodeJS.ProcessEnv | undefined, executor: LocalProcessExecutor, signalProcessTree: (child: import('node:child_process').ChildProcessWithoutNullStreams, signal: NodeJS.Signals) => Promise<void>, engineFactory?: CodeModeEngineFactory);

package/dist/tools/code-mode/index.js

@@ -110,7 +110,7 @@ export const codeExecWaitToolDefinition = {
 function projectProgrammaticTool(tool) {
     return {
         name: tool.name,
-        description: `${allowsDirectTool(tool, true) ? `Call directly or as tools.${tool.name} inside code_exec.` : `Call only as tools.${tool.name} inside code_exec, never as a direct model tool.`}\nInside code_exec, pass a JavaScript value matching inputSchema.\n${tool.description}`,
+        description: `${allowsDirectTool(tool, true) ? `Call directly or as tools.${tool.name} inside code_exec.` : `Call only as tools.${tool.name} inside code_exec, never as a direct model tool.`}\n${tool.description}`,
         inputSchema: stableToolSchema(tool.inputSchema)
     };
 }
@@ -127,7 +127,7 @@ export function projectCodeModeTools(tools, residentTools = tools) {
         callableNames: programmatic.map((tool) => tool.name),
         tools: programmatic.map(projectProgrammaticTool)
     });
-    if (Buffer.byteLength(directory) > 32 * 1024)
+    if (Buffer.byteLength(directory) > 48 * 1024)
         throw new AgentError('MAR_AGENT_TOOL_EXPOSURE_LIMIT', 'Programmatic tool directory is too large.');
     return direct.map((tool) => tool.name === 'code_exec'
         ? {
@@ -399,6 +399,8 @@ export class CodeModeTool {
                     };
                     const indices = original.result.images?.map(addImage);
                     const data = [
+                        'exec',
+                        'exec_wait',
                         'apply_patch',
                         'todo_read',
                         'todo_write',

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;