@myagentroam/agent 0.11.69 → 0.11.70

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.js

@@ -6,7 +6,6 @@ import { createReadStream } from 'node:fs';
 import { lstat, open } from 'node:fs/promises';
 import { TextDecoder } from 'node:util';
 import { AgentError } from '../../error.js';
-import { toolEventSummary } from '../../runtime/event-projection.js';
 import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
 export const readToolDefinition = {
     name: 'read',
@@ -89,47 +88,57 @@ export const readToolDefinition = {
 /** Produce public text and offsets together, independently of model-visible markup. */
 export function formatReadEventOutput(results) {
     let source = '';
-    const projected = [];
-    for (const item of results.slice(0, TOOL_EXECUTION_LIMITS.readMaxBatchItems)) {
+    const items = results
+        .slice(0, TOOL_EXECUTION_LIMITS.readMaxBatchItems)
+        .map((item) => {
         const path = item.path.slice(0, 4096).replace(/[\uD800-\uDBFF]$/u, '');
-        source += `${source ? '\n\n' : ''}${path}\n`;
         if ('error' in item) {
             const error = {
                 code: item.error.code.slice(0, 80),
                 message: item.error.message.slice(0, 1000)
             };
-            source += `${error.code}: ${error.message}`;
-            projected.push({ path, error });
+            return { body: `${error.code}: ${error.message}`, result: { path, error } };
         }
-        else {
-            const start = source.length;
-            source += item.text;
-            projected.push({
+        return {
+            body: item.text,
+            result: {
                 path,
                 startLine: item.startLine,
                 ...(item.endLine === undefined ? {} : { endLine: item.endLine }),
-                ...(item.text.length === 0 ? { empty: true } : {}),
-                contentRange: { start, end: source.length }
-            });
-        }
-    }
-    const preview = toolEventSummary(source);
-    const retained = preview.retainedLength;
-    for (const item of projected) {
-        const range = item.contentRange;
-        if (!range)
-            continue;
-        if (range.start > retained || (range.start === retained && range.end > range.start)) {
-            delete item.contentRange;
-        }
-        else {
-            range.end = Math.min(range.end, retained);
-        }
+                ...(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,
-        ...preview,
-        data: { mode: 'batch', results: projected, truncated: preview.truncated }
+        summary: source,
+        truncated,
+        data: { mode: 'batch', results: projected, truncated }
     };
 }
 export class ReadTool {

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';

package/package.json

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