@myagentroam/agent 0.11.68 → 0.11.70

package/dist/host/local-tool-registry.js

@@ -6,7 +6,7 @@ import { CodeModeTool, codeModeToolDefinition, codeExecWaitToolDefinition } from
 import { normalizeToolInput } from '../tools/input.js';
 import { execToolInput, execToolDefinition, execWaitToolDefinition, formatExecResult } from '../tools/local/exec.js';
 import { ExecTool } from './local-exec-tool.js';
-import { ReadTool, formatBatchReadOutput, readToolDefinition } from '../tools/local/read.js';
+import { ReadTool, formatBatchReadOutput, formatReadEventOutput, readToolDefinition } from '../tools/local/read.js';
 import { WorkspacePathResolver } from '../tools/shared/path-resolver.js';
 import { ViewImageTool, viewImageToolDefinition } from '../tools/local/view-image.js';
 const definitions = [
@@ -58,9 +58,15 @@ export class LocalToolRegistry {
                 async (arguments_, context) => {
                     const result = await read.execute(arguments_, context.signal);
                     const formatted = formatBatchReadOutput(result.results);
+                    const publicResult = formatReadEventOutput(result.results);
                     return {
                         content: formatted.content,
                         data: result,
+                        eventSummary: publicResult.source,
+                        eventData: {
+                            ...publicResult.data,
+                            truncated: result.truncated || publicResult.truncated
+                        },
                         truncated: result.truncated || formatted.truncated
                     };
                 }

package/dist/runtime/event-projection.d.ts

@@ -4,6 +4,7 @@ import type { EventPayload, AgentEvent } from './events.js';
 export declare function toolEventSummary(text: string): {
     summary: string;
     truncated: boolean;
+    retainedLength: number;
 };
 /** Keep streaming deltas live-only; exec output has one durable copy in model context records. */
 export declare function eventForPersistence(event: AgentEvent): AgentEvent | undefined;

package/dist/runtime/event-projection.js

@@ -4,10 +4,10 @@ import { publicToolMetadata } from './public-tool-metadata.js';
 export function toolEventSummary(text) {
     const limit = AGENT_EXECUTION_POLICY.toolEventSummaryCharacters;
     if (text.length <= limit)
-        return { summary: text, truncated: false };
+        return { summary: text, truncated: false, retainedLength: text.length };
     const marker = '... [tool event summary truncated]';
     const prefix = text.slice(0, limit - marker.length).replace(/[\uD800-\uDBFF]$/u, '');
-    return { summary: prefix + marker, truncated: true };
+    return { summary: prefix + marker, truncated: true, retainedLength: prefix.length };
 }
 /** Keep streaming deltas live-only; exec output has one durable copy in model context records. */
 export function eventForPersistence(event) {

package/dist/runtime/public-tool-metadata.d.ts

@@ -1,5 +1,6 @@
 export type PublicToolMetadata = ({
     query?: string;
+    sourcesOnly?: true;
     sources?: {
         url: string;
         title?: string;
@@ -16,6 +17,10 @@ export type PublicToolMetadata = ({
     name: string;
     description?: string;
     source?: string;
+} | {
+    tools: string[];
+} | {
+    status: 'accepted';
 }) & {
     hostedToolKind?: 'WEB_SEARCH' | 'WEB_FETCH';
 };

package/dist/runtime/public-tool-metadata.js

@@ -1,6 +1,12 @@
 /** Public metadata only; page bodies and skill instructions stay in the bounded output. */
 export function publicToolMetadata(toolName, value) {
     const text = (key, limit) => typeof value[key] === 'string' ? value[key].slice(0, limit) : undefined;
+    if (toolName === 'tool_search' &&
+        Array.isArray(value.tools) &&
+        value.tools.every((name) => typeof name === 'string'))
+        return { tools: value.tools.slice(0, 20).map((name) => name.slice(0, 512)) };
+    if (toolName === 'smart_compact' && value.status === 'accepted')
+        return { status: 'accepted' };
     if (toolName === 'web_search') {
         const entries = Array.isArray(value.results)
             ? value.results
@@ -21,7 +27,21 @@ export function publicToolMetadata(toolName, value) {
                 }
             ];
         });
+        const sourcesComplete = entries !== undefined &&
+            sources !== undefined &&
+            entries.length <= 20 &&
+            entries.length === sources.length &&
+            value.truncated !== true &&
+            value.sourcesTruncated !== true &&
+            entries.every((entry, index) => {
+                const source = entry;
+                const projected = sources[index];
+                return (source.url === projected.url &&
+                    source.title === projected.title &&
+                    source.snippet === projected.snippet);
+            });
         return {
+            ...(value.sourcesOnly === true && sourcesComplete ? { sourcesOnly: true } : {}),
             ...(text('query', 500) === undefined ? {} : { query: text('query', 500) }),
             ...(sources === undefined
                 ? {}

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

@@ -40,7 +40,10 @@ export function createCodeToolDispatch(input) {
                     ...(expected ? { expectedMcpTool: expected } : {})
                 }, 'programmatic');
                 const bounded = boundedModelToolOutput(call.name, result.content, result.data);
-                const data = call.name === 'exec' || call.name === 'exec_wait'
+                const data = call.name === 'read' ||
+                    call.name === 'web_search' ||
+                    call.name === 'exec' ||
+                    call.name === 'exec_wait'
                     ? structuredToolEventData(call.name, result.eventData ?? result.data)
                     : result.eventData === undefined
                         ? structuredToolEventData(call.name, result.data)
@@ -63,7 +66,7 @@ export function createCodeToolDispatch(input) {
                     truncated: result.truncated === true || bounded.truncated || preview.truncated,
                     ...(result.artifacts ? { artifacts: result.artifacts } : {})
                 });
-                const { eventData: _eventData, ...guestResult } = result;
+                const { eventData: _eventData, eventSummary: _eventSummary, ...guestResult } = result;
                 return {
                     ...guestResult,
                     ...((call.name === 'exec' || call.name === 'exec_wait') && data !== undefined

package/dist/tools/contracts.d.ts

@@ -198,6 +198,11 @@ export interface ReadEventData {
         path: string;
         startLine?: number;
         endLine?: number;
+        contentRange?: {
+            start: number;
+            end: number;
+        };
+        empty?: true;
         error?: {
             code: string;
             message: string;

package/dist/tools/execution.js

@@ -128,7 +128,9 @@ export async function executeRoundTools(calls, scope) {
                 : typeof output.eventSummary === 'string'
                     ? output.eventSummary
                     : '');
-            const structuredData = call.name === 'exec' ||
+            const structuredData = call.name === 'read' ||
+                call.name === 'web_search' ||
+                call.name === 'exec' ||
                 call.name === 'exec_wait' ||
                 call.name === 'code_exec' ||
                 call.name === 'code_exec_wait'

package/dist/tools/local/exec.js

@@ -32,6 +32,7 @@ export function formatExecResult(result) {
 export const execToolDefinition = {
     name: 'exec',
     allowedCallers: ['direct', 'programmatic'],
+    codeModeExposure: 'both',
     parallelSafety: 'safe',
     description: 'Start a platform-native command, script, or program in workspace/default cwd. Returns a stable processId (p_ plus 12 lowercase hex characters), status, bounded stdout/stderr, cumulative byte counts, dropped-byte counts, exitCode and truncated. A completed status does not imply exitCode 0; inspect stderr/exitCode. For subsequent waiting, stdin writes or cancellation, call exec_wait directly with processId, not exec. Truncation does not stop the process. Cancelling the initial wait does not terminate the process. waitOutcome distinguishes snapshot, completion, and timeout. A foreground wait may return interrupted with reason=steer; the process keeps running.',
     outputSchema: {

package/dist/tools/local/read.d.ts

@@ -1,4 +1,5 @@
 import type { ClientToolDefinition } from '../contracts.js';
+import type { ReadEventData } from '../contracts.js';
 import { WorkspacePathResolver } from '../shared/path-resolver.js';
 export type { ReadEventData } from '../contracts.js';
 export declare const readToolDefinition: ClientToolDefinition;
@@ -31,6 +32,13 @@ export interface BatchReadResult {
     results: Array<ReadResult | ReadErrorResult>;
     truncated: boolean;
 }
+/** Produce public text and offsets together, independently of model-visible markup. */
+export declare function formatReadEventOutput(results: BatchReadResult['results']): {
+    source: string;
+    summary: string;
+    truncated: boolean;
+    data: ReadEventData;
+};
 export declare class ReadTool {
     #private;
     private readonly paths;

package/dist/tools/local/read.js

@@ -85,6 +85,62 @@ export const readToolDefinition = {
         additionalProperties: false
     }
 };
+/** Produce public text and offsets together, independently of model-visible markup. */
+export function formatReadEventOutput(results) {
+    let source = '';
+    const items = results
+        .slice(0, TOOL_EXECUTION_LIMITS.readMaxBatchItems)
+        .map((item) => {
+        const path = item.path.slice(0, 4096).replace(/[\uD800-\uDBFF]$/u, '');
+        if ('error' in item) {
+            const error = {
+                code: item.error.code.slice(0, 80),
+                message: item.error.message.slice(0, 1000)
+            };
+            return { body: `${error.code}: ${error.message}`, result: { path, error } };
+        }
+        return {
+            body: item.text,
+            result: {
+                path,
+                startLine: item.startLine,
+                ...(item.endLine === undefined ? {} : { endLine: item.endLine }),
+                ...(item.text.length === 0 ? { empty: true } : {})
+            }
+        };
+    });
+    const maximum = AGENT_EXECUTION_POLICY.toolEventSummaryCharacters;
+    const completeLength = items.reduce((length, { body, result }) => length + result.path.length + 1 + body.length, Math.max(0, items.length - 1) * 2);
+    let truncated = items.length < results.length;
+    const projected = [];
+    for (const [index, { body, result }] of items.entries()) {
+        const path = result.path;
+        const separator = index === 0 ? '' : '\n\n';
+        const remaining = items.length - index;
+        const budget = completeLength <= maximum
+            ? maximum - source.length - separator.length
+            : Math.floor((maximum - source.length - separator.length - 2 * (remaining - 1)) / remaining);
+        // Keep full paths in metadata; long display labels must leave room for each body.
+        const pathBudget = Math.max(Math.floor(budget / 2), budget - body.length - 1);
+        const label = path.length <= pathBudget
+            ? path
+            : `${path.slice(0, pathBudget - 3).replace(/[\uD800-\uDBFF]$/u, '')}...`;
+        const preview = body.slice(0, budget - label.length - 1).replace(/[\uD800-\uDBFF]$/u, '');
+        truncated ||= label.length < path.length || preview.length < body.length;
+        source += `${separator}${label}\n`;
+        const start = source.length;
+        source += preview;
+        if (!result.error)
+            result.contentRange = { start, end: source.length };
+        projected.push(result);
+    }
+    return {
+        source,
+        summary: source,
+        truncated,
+        data: { mode: 'batch', results: projected, truncated }
+    };
+}
 export class ReadTool {
     paths;
     constructor(paths) {

package/dist/tools/output-projection.js

@@ -174,6 +174,8 @@ export function publicCodeObservations(values, data) {
 export function publicOutputTruncation(toolName, data) {
     if (!isRecord(data))
         return undefined;
+    if (toolName === 'read' && data.mode === 'batch' && data.truncated === true)
+        return 'SOURCE';
     if (toolName === 'code_exec' || toolName === 'code_exec_wait') {
         if (data.outputSourceTruncated === true)
             return 'SOURCE';
@@ -300,6 +302,12 @@ export function structuredToolEventData(toolName, value) {
             typeof result.path === 'string' &&
             (result.startLine === undefined || isNonnegativeInteger(result.startLine)) &&
             (result.endLine === undefined || isNonnegativeInteger(result.endLine)) &&
+            (result.empty === undefined || result.empty === true) &&
+            (result.contentRange === undefined ||
+                (isRecord(result.contentRange) &&
+                    isNonnegativeInteger(result.contentRange.start) &&
+                    isNonnegativeInteger(result.contentRange.end) &&
+                    result.contentRange.end >= result.contentRange.start)) &&
             (result.error === undefined ||
                 (isRecord(result.error) &&
                     typeof result.error.code === 'string' &&
@@ -314,6 +322,8 @@ export function structuredToolEventData(toolName, value) {
                     ? { startLine: item.startLine }
                     : {}),
                 ...('endLine' in item && item.endLine !== undefined ? { endLine: item.endLine } : {}),
+                ...(item.contentRange === undefined ? {} : { contentRange: { ...item.contentRange } }),
+                ...(item.empty === true ? { empty: true } : {}),
                 ...('error' in item ? { error: { ...item.error } } : {})
             }))
         };

package/package.json

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