@myagentroam/agent 0.11.44 → 0.11.45

package/dist/cli/subagent/index.js

@@ -7,6 +7,13 @@ import { registerQueryTools } from './query.js';
 import { nativeSubagentService, SUBAGENT_NATIVE_SERVICE } from './native.js';
 import { childResources } from './resources.js';
 import { sharedSessionHistory } from './history.js';
+const delegationPrompt = [
+    '# Delegation and coordination',
+    'Delegate bounded, self-contained tasks when independent progress or context savings materially helps. Keep simple or tightly coupled work local.',
+    'Give each child an objective, necessary context, expected output, and a read-only boundary or non-overlapping write scope.',
+    'While children run, continue meaningful non-overlapping work. Do not redo delegated work. Wait only when the next step needs the result.',
+    'Verify consequential findings and changes. Join or stop task-required child work before final delivery, and retain responsibility for the final result.'
+].join('\n\n');
 export { SUBAGENT_NATIVE_SERVICE } from './native.js';
 /** Optional local consumer of Core Session lifecycle and observation APIs. */
 export function createSubagentExtension(options) {
@@ -70,6 +77,18 @@ export function createSubagentExtension(options) {
                 registerControlTools(context, agent, observations, warmObservations, admission);
                 registerWait(context, agent, observations, history);
                 registerQueryTools(context, agent);
+                context.hooks.intercept('prompt.sections', (input, _call, next) => next({
+                    ...input,
+                    sections: [
+                        ...input.sections,
+                        {
+                            id: 'subagent:delegation',
+                            text: input.facts?.mode !== 'compact' && input.facts?.tools?.includes('agent_start')
+                                ? delegationPrompt
+                                : null
+                        }
+                    ]
+                }));
             }
             catch (error) {
                 disposed = true;

package/dist/runtime/event-projection.js

@@ -81,6 +81,7 @@ export function publicHostedToolEvents(event) {
             callId: event.itemId,
             summary,
             truncated,
+            ...(preview.truncated || event.truncated === true ? { summaryTruncated: true } : {}),
             data: started.data
         }
     ];

package/dist/runtime/events.d.ts

@@ -95,6 +95,7 @@ export type AgentEvent = AgentEventBase & ({
     callId: string;
     parentCallId?: string;
     output: import('../tools/contracts.js').ExecOutputSnapshot;
+    outputTruncation?: 'HEAD' | 'SOURCE';
 } | {
     type: 'tool.completed';
     resultExtensions?: readonly import('../tools/result-extension-contract.js').ToolResultExtension[];
@@ -103,6 +104,8 @@ export type AgentEvent = AgentEventBase & ({
     parentCallId?: string;
     summary: string;
     truncated?: boolean;
+    summaryTruncated?: boolean;
+    outputTruncation?: 'HEAD' | 'SOURCE';
     artifacts?: readonly AgentToolArtifact[];
     data?: CodeCellEventData | import('../tools/contracts.js').ExecResult | Omit<import('../tools/contracts.js').ExecResult, 'stdout' | 'stderr'> | import('../tools/contracts.js').ApplyPatchResult | import('../tools/contracts.js').ReadEventData | import('../tools/contracts.js').ViewImageResult | import('../tools/contracts.js').SleepResult | Readonly<Record<string, unknown>> | import('./public-tool-metadata.js').PublicToolMetadata;
 } | {
@@ -116,6 +119,7 @@ export type AgentEvent = AgentEventBase & ({
     message?: string;
     permissionStop?: import('../tools/permission-contract.js').PermissionStop;
     truncated?: boolean;
+    outputTruncation?: 'HEAD' | 'SOURCE';
 } | {
     type: 'sleep.started';
     callId: string;

package/dist/sdk/session-execution.js

@@ -241,6 +241,13 @@ export class SessionExecution {
                 const deliver = missed && full.output.displayOutput
                     ? {
                         ...full,
+                        ...(full.outputTruncation === 'SOURCE' ||
+                            full.output.displayOutput.stdoutDroppedBytes > 0 ||
+                            full.output.displayOutput.stderrDroppedBytes > 0
+                            ? {
+                                outputTruncation: full.outputTruncation === 'SOURCE' ? 'SOURCE' : 'HEAD'
+                            }
+                            : {}),
                         output: {
                             ...full.output,
                             mode: 'snapshot',

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

@@ -222,6 +222,14 @@ export class CodeCells {
                         cellId: cell.cellId,
                         status: cell.status,
                         observations,
+                        outputSourceKnown: true,
+                        ...(cell.display?.outputSourceTruncated ||
+                            (!displayHeadTruncated &&
+                                (display.type === 'value'
+                                    ? display.truncated === true
+                                    : display.result.truncated === true))
+                            ? { outputSourceTruncated: true }
+                            : {}),
                         ...(cell.display?.outputHeadTruncated || displayHeadTruncated
                             ? { outputHeadTruncated: true }
                             : {})

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

@@ -2,7 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { AgentError, describeAgentError } from '../../error.js';
 import { toolEventSummary } from '../../runtime/event-projection.js';
 import { allowsToolCaller } from '../callers.js';
-import { boundedModelToolOutput, structuredToolEventData, structuredToolFailureData } from '../output-projection.js';
+import { boundedModelToolOutput, publicToolEventInput, publicExtensionToolEventData, publicEventOutputData, publicOutputTruncation, structuredToolEventData, structuredToolFailureData } from '../output-projection.js';
 import { executeRegisteredTool } from '../runtime.js';
 import { failedToolResultExtensions } from '../result-extensions.js';
 import { permissionStopFromError } from '../permissions.js';
@@ -19,7 +19,13 @@ export function createCodeToolDispatch(input) {
             signal.throwIfAborted();
             const callId = call.callId ?? randomUUID();
             const identity = { toolName: call.name, callId, parentCallId: input.parentCallId };
-            await input.emit({ type: 'tool.started', ...identity, input: call.arguments });
+            await input.emit({
+                type: 'tool.started',
+                ...identity,
+                input: definition.eventInputFields === undefined
+                    ? call.arguments
+                    : publicToolEventInput(call.arguments, definition.eventInputFields)
+            });
             try {
                 input.assertLive();
                 signal.throwIfAborted();
@@ -32,17 +38,26 @@ export function createCodeToolDispatch(input) {
                     ...(expected ? { expectedMcpTool: expected } : {})
                 }, 'programmatic');
                 const bounded = boundedModelToolOutput(call.name, result.content, 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);
+                const data = call.name === 'exec' || call.name === 'exec_wait'
+                    ? structuredToolEventData(call.name, result.eventData ?? result.data)
+                    : result.eventData === undefined
+                        ? structuredToolEventData(call.name, result.data)
+                        : publicExtensionToolEventData(result.eventData);
+                const preview = toolEventSummary(result.eventSummary === undefined
+                    ? result.content
+                    : typeof result.eventSummary === 'string'
+                        ? result.eventSummary
+                        : '');
+                const outputTruncation = publicOutputTruncation(call.name, data);
                 input.assertLive();
                 await input.emit({
                     type: 'tool.completed',
                     ...(result.resultExtensions ? { resultExtensions: result.resultExtensions } : {}),
                     ...identity,
                     summary: preview.summary,
-                    ...(data === undefined ? {} : { data }),
+                    ...(preview.truncated ? { summaryTruncated: true } : {}),
+                    ...(outputTruncation ? { outputTruncation } : {}),
+                    ...(data === undefined ? {} : { data: publicEventOutputData(data) }),
                     truncated: result.truncated === true || bounded.truncated || preview.truncated,
                     ...(result.artifacts ? { artifacts: result.artifacts } : {})
                 });

package/dist/tools/contracts.d.ts

@@ -9,7 +9,7 @@ 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. */
+    /** Runtime-only allowlist of scalars and bounded string arrays in public tool.started input. */
     eventInputFields?: readonly string[];
     /** Runtime-only exposure override; retains both permitted entry points with Code Mode enabled. */
     codeModeExposure?: 'both';
@@ -145,6 +145,9 @@ export interface CodeCellEventData {
     truncated?: boolean;
     /** Public output projection discarded older text; not inferred from source truncation. */
     outputHeadTruncated?: boolean;
+    /** Internal public-observation source fact, separate from local head clipping. */
+    outputSourceKnown?: boolean;
+    outputSourceTruncated?: boolean;
     observations?: readonly import('../session/code-observation-contract.js').CodeObservation[];
     error?: {
         code: string;

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, publicToolEventInput, structuredToolArtifacts, publicExtensionToolEventData, structuredToolEventData, structuredToolFailureData } from './output-projection.js';
+import { boundedModelToolOutput, publicToolEventInput, structuredToolArtifacts, publicExtensionToolEventData, publicOutputTruncation, publicEventOutputData, structuredToolEventData, structuredToolFailureData } from './output-projection.js';
 import { publishModelResources } from '../runtime/resource-publication.js';
 import { executeRegisteredTool } from './runtime.js';
 import { failedToolResultExtensions } from './result-extensions.js';
@@ -137,6 +137,7 @@ export async function executeRoundTools(calls, scope) {
                     ? structuredToolEventData(call.name, output.data)
                     : publicExtensionToolEventData(output.eventData);
             const artifacts = structuredToolArtifacts(output.artifacts);
+            const outputTruncation = publicOutputTruncation(call.name, structuredData);
             await scope.emit({
                 type: 'tool.completed',
                 ...(output.resultExtensions ? { resultExtensions: output.resultExtensions } : {}),
@@ -145,8 +146,10 @@ export async function executeRoundTools(calls, scope) {
                 ...(parentCallId === undefined ? {} : { parentCallId }),
                 summary: eventSummary.summary,
                 truncated: output.truncated === true || modelOutput.truncated || eventSummary.truncated,
+                ...(eventSummary.truncated ? { summaryTruncated: true } : {}),
+                ...(outputTruncation ? { outputTruncation } : {}),
                 ...(artifacts === undefined ? {} : { artifacts }),
-                ...(structuredData === undefined ? {} : { data: structuredData })
+                ...(structuredData === undefined ? {} : { data: publicEventOutputData(structuredData) })
             });
             return {
                 call,
@@ -173,6 +176,7 @@ export async function executeRoundTools(calls, scope) {
                 (partial?.data === undefined
                     ? undefined
                     : structuredToolEventData(call.name, partial.eventData ?? partial.data));
+            const outputTruncation = publicOutputTruncation(call.name, eventData);
             await scope.emit({
                 type: 'tool.failed',
                 ...(failedToolResultExtensions(error)
@@ -186,7 +190,8 @@ export async function executeRoundTools(calls, scope) {
                 ...(permissionStopFromError(error)
                     ? { permissionStop: permissionStopFromError(error) }
                     : {}),
-                ...(eventData === undefined ? {} : { data: eventData })
+                ...(outputTruncation ? { outputTruncation } : {}),
+                ...(eventData === undefined ? {} : { data: publicEventOutputData(eventData) })
             });
             return {
                 call,

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

@@ -14,6 +14,11 @@ export declare function boundedModelToolOutput(toolName: string, value: string,
 export declare function publicToolEventInput(value: unknown, fields: readonly string[]): Readonly<Record<string, unknown>>;
 /** Explicit observations are public, but their event projection must remain bounded. */
 export declare function publicCodeObservations(values: unknown, data: CodeCellEventData): CodeCellEventData;
+/** Classify only facts about the public body, never model or summary limits. */
+export declare function publicOutputTruncation(toolName: string, data: unknown): 'HEAD' | 'SOURCE' | undefined;
+/** Remove the internal display direction from published structured data. */
+export declare function publicEventOutputData<T>(data: T): T;
+export declare function liveOutputTruncation(output: import('./contracts.js').ExecOutputSnapshot): 'HEAD' | 'SOURCE' | undefined;
 /** Project only known, validated tool result shapes into public structured events. */
 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. */

package/dist/tools/output-projection.js

@@ -58,6 +58,9 @@ export function publicToolEventInput(value, fields) {
             .filter((key) => Object.hasOwn(value, key) &&
             (typeof value[key] === 'string' ||
                 typeof value[key] === 'boolean' ||
+                (Array.isArray(value[key]) &&
+                    value[key].length <= 100 &&
+                    value[key].every((item) => typeof item === 'string')) ||
                 (typeof value[key] === 'number' && Number.isFinite(value[key])) ||
                 value[key] === null))
             .map((key) => [key, value[key]]));
@@ -77,6 +80,7 @@ export function publicCodeObservations(values, data) {
     let remaining = 10_000;
     let truncated = false;
     let headTruncated = data.outputHeadTruncated === true;
+    let sourceTruncated = data.outputSourceTruncated === true;
     const clip = (text) => {
         let start = Math.max(0, text.length - remaining);
         if (start > 0 && /[\uDC00-\uDFFF]/u.test(text[start]))
@@ -101,6 +105,8 @@ export function publicCodeObservations(values, data) {
                 continue;
             }
             displayedCount++;
+            if (!data.outputSourceKnown && entry.truncated === true)
+                sourceTruncated = true;
             truncated ||= entry.truncated === true;
             const value = clip(entry.value);
             selected.unshift({
@@ -116,8 +122,11 @@ export function publicCodeObservations(values, data) {
         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))
+                if (retained.has(entry)) {
+                    if (!data.outputSourceKnown && entry.result.truncated === true)
+                        sourceTruncated = true;
                     selected.unshift(entry);
+                }
             }
             else if ((name === 'exec' || name === 'exec_wait') &&
                 typeof entry.id === 'string' &&
@@ -129,10 +138,12 @@ export function publicCodeObservations(values, data) {
                     continue;
                 }
                 displayedCount++;
+                if (!data.outputSourceKnown && entry.result.truncated === true)
+                    sourceTruncated = true;
                 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 resultData = isRecord(entry.result.data) ? entry.result.data : undefined;
+                const stderr = typeof resultData?.stderr === 'string' ? clip(resultData.stderr) : undefined;
+                const stdout = typeof resultData?.stdout === 'string' ? clip(resultData.stdout) : undefined;
                 const content = stdout === undefined && stderr === undefined && typeof entry.result.content === 'string'
                     ? clip(entry.result.content)
                     : '';
@@ -153,10 +164,48 @@ export function publicCodeObservations(values, data) {
     return {
         ...data,
         observations: selected,
+        outputSourceKnown: true,
+        ...(sourceTruncated ? { outputSourceTruncated: true } : {}),
         ...(truncated ? { truncated: true } : {}),
         ...(headTruncated ? { outputHeadTruncated: true } : {})
     };
 }
+/** Classify only facts about the public body, never model or summary limits. */
+export function publicOutputTruncation(toolName, data) {
+    if (!isRecord(data))
+        return undefined;
+    if (toolName === 'code_exec' || toolName === 'code_exec_wait') {
+        if (data.outputSourceTruncated === true)
+            return 'SOURCE';
+        if (data.outputHeadTruncated === true)
+            return 'HEAD';
+    }
+    if (toolName === 'exec' || toolName === 'exec_wait') {
+        const display = isRecord(data.displayOutput) ? data.displayOutput : undefined;
+        if (display)
+            return Number(display.stdoutDroppedBytes) > 0 || Number(display.stderrDroppedBytes) > 0
+                ? 'HEAD'
+                : undefined;
+        if (data.truncated === true)
+            return 'SOURCE';
+    }
+    return undefined;
+}
+/** Remove the internal display direction from published structured data. */
+export function publicEventOutputData(data) {
+    if (!isRecord(data))
+        return data;
+    const { outputHeadTruncated: _head, outputSourceKnown: _known, outputSourceTruncated: _source, ...rest } = data;
+    return rest;
+}
+export function liveOutputTruncation(output) {
+    if (!output.truncated)
+        return undefined;
+    return output.displayOutput &&
+        (output.displayOutput.stdoutDroppedBytes > 0 || output.displayOutput.stderrDroppedBytes > 0)
+        ? 'HEAD'
+        : 'SOURCE';
+}
 /** Project only known, validated tool result shapes into public structured events. */
 export function structuredToolEventData(toolName, value) {
     if (!isRecord(value))
@@ -199,6 +248,8 @@ export function structuredToolEventData(toolName, value) {
                 : {}),
             status: value.status,
             ...(value.outputHeadTruncated === true ? { outputHeadTruncated: true } : {}),
+            ...(value.outputSourceKnown === true ? { outputSourceKnown: true } : {}),
+            ...(value.outputSourceTruncated === true ? { outputSourceTruncated: true } : {}),
             cached: value.cached === true,
             ...(['snapshot', 'completion', 'timeout', 'yield', 'interrupted'].includes(String(value.waitOutcome))
                 ? { waitOutcome: value.waitOutcome }

package/dist/tools/runtime.js

@@ -2,7 +2,7 @@ import { AgentError } from '../error.js';
 import { randomUUID } from 'node:crypto';
 import { AGENT_TOOL_HANDLERS, BUILTIN_TOOL_DEFINITIONS } from './registry.js';
 import { normalizeToolInput } from './input.js';
-import { validateToolResult } from './output-projection.js';
+import { liveOutputTruncation, validateToolResult } from './output-projection.js';
 import { withToolResultExtensions } from './result-extensions.js';
 import { viewResourceImage } from './local/view-image.js';
 export async function executeRegisteredTool(name, arguments_, callId, context, caller = 'direct') {
@@ -58,6 +58,9 @@ export async function executeCapturedTool(kind, call, context) {
                     toolName: name,
                     callId,
                     ...(context.parentCallId === undefined ? {} : { parentCallId: context.parentCallId }),
+                    ...(liveOutputTruncation(output)
+                        ? { outputTruncation: liveOutputTruncation(output) }
+                        : {}),
                     output
                 })
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/agent",
-  "version": "0.11.44",
+  "version": "0.11.45",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",