@myagentroam/agent 0.9.74 → 0.9.75

package/dist/prompts/index.d.ts

@@ -2,7 +2,7 @@ import type { ExecutionMode } from '../sdk/types.js';
 import { type ExecutionBudgetPromptState } from './execution-budget.js';
 import { type RetainedSessionResources } from './resources.js';
 import { type CurrentAgentModel, type SubagentModelOption } from './subagent.js';
-export declare const MAR_AGENT_PROMPT_VERSION = "1.42";
+export declare const MAR_AGENT_PROMPT_VERSION = "1.43";
 export declare function buildSystemPrompt(input: {
     mode: ExecutionMode;
     platform: string;

package/dist/prompts/index.js

@@ -6,7 +6,7 @@ import { outputStylePrompt } from './output.js';
 import { retainedSessionResourcesPrompt } from './resources.js';
 import { subagentModelOptionsPrompt, subagentPrompt, currentAgentModelPrompt } from './subagent.js';
 import { interactionPrompt, longRunningPrompt, safetyPrompt, toolUsagePrompt, workflowPrompt } from './workflow.js';
-export const MAR_AGENT_PROMPT_VERSION = '1.42';
+export const MAR_AGENT_PROMPT_VERSION = '1.43';
 export function buildSystemPrompt(input) {
     const toolNames = new Set(input.tools);
     const hasLongRunningCapability = [

package/dist/prompts/workflow.js

@@ -10,7 +10,7 @@ export function toolUsagePrompt(tools) {
     if (names.has('exec'))
         clauses.push('Use exec for platform-native commands, scripts, verification, and mechanical edits. Prefer rg or rg --files for search. Batch independent lookups and already-decided commands, preserving failure ordering. Use scripts for mechanical substitutions instead of reproducing long unchanged text in a patch; inspect actual effects afterward.');
     if (names.has('read'))
-        clauses.push('Use read to batch known files and ranges. Batch only already-located, bounded ranges that are likely to fit together; for large files or documents, locate relevant sections before reading them. Read only what can affect the next decision, continue only relevant incomplete results using returned metadata, and avoid rereading unchanged content.');
+        clauses.push('Use read to batch known files and ranges. Batch only already-located, bounded ranges that are likely to fit together; for large files or documents, locate relevant sections before reading them. Read only what can affect the next decision, continue only relevant incomplete results using returned metadata, and avoid rereading unchanged content. Do not edit from an incomplete oversized-line preview. Obtain exact source with exec; if it still cannot fit, use a preconditioned deterministic replacement and verify the result.');
     if (names.has('apply_patch'))
         clauses.push('Prefer apply_patch for precise local edits. After a conflict, use the reported evidence to refresh only the affected context before retrying.');
     if (names.has('apply_patch') || names.has('exec'))

package/dist/runtime/token-budget.d.ts

@@ -2,8 +2,12 @@ export declare const MODEL_TOKEN_ESTIMATOR: "UTF8_BYTES_V1";
 /** Local budget estimate only; provider usage remains authoritative. */
 export declare function countModelTokens(value: string): number;
 export declare function modelTokenBudgetBytes(maximumTokens: number): number;
-export declare function truncateModelText(value: string, maximumTokens: number, omittedLabel?: string): {
+export declare function truncateModelText(value: string, maximumTokens: number, omittedLabel?: string, reported?: {
+    readonly originalTokenCount?: number;
+    readonly totalLines?: number;
+}): {
     content: string;
     truncated: boolean;
     omittedTokens: number;
 };
+export declare function countTextLines(value: string): number;

package/dist/runtime/token-budget.js

@@ -7,13 +7,13 @@ export function countModelTokens(value) {
 export function modelTokenBudgetBytes(maximumTokens) {
     return Math.max(0, Math.floor(maximumTokens)) * BYTES_PER_TOKEN;
 }
-export function truncateModelText(value, maximumTokens, omittedLabel = 'tool output') {
+export function truncateModelText(value, maximumTokens, omittedLabel = 'tool output', reported) {
     const tokens = countModelTokens(value);
     if (tokens <= maximumTokens)
         return { content: value, truncated: false, omittedTokens: 0 };
     const maximumBytes = modelTokenBudgetBytes(maximumTokens);
     const bytes = Buffer.from(value, 'utf8');
-    const warning = `Warning: truncated output (original token count: ${tokens})\nTotal output lines: ${lineCount(value)}\n\n`;
+    const warning = `Warning: truncated output (original token count: ${reported?.originalTokenCount ?? tokens})\nTotal output lines: ${reported?.totalLines ?? countTextLines(value)}\n\n`;
     let retainedBytes = Math.max(0, maximumBytes - 16 * BYTES_PER_TOKEN);
     for (let attempt = 0; attempt < 8; attempt++) {
         let head = Math.ceil(retainedBytes / 2);
@@ -48,7 +48,7 @@ export function truncateModelText(value, maximumTokens, omittedLabel = 'tool out
         omittedTokens: tokens
     };
 }
-function lineCount(value) {
+export function countTextLines(value) {
     let lines = value.length === 0 ? 0 : 1;
     for (let index = 0; index < value.length; index++)
         if (value.charCodeAt(index) === 10)

package/dist/sdk/agent.js

@@ -12,7 +12,7 @@ import { AGENT_EXECUTION_POLICY } from '../runtime/execution-policy.js';
 import { RolloutBudget, resolveRolloutBudgetOptions } from '../runtime/rollout-budget.js';
 import { ContextGcRuntime } from '../runtime/context-gc-runtime.js';
 import { buildContextProjection } from '../runtime/context-projection.js';
-import { countModelTokens, truncateModelText } from '../runtime/token-budget.js';
+import { countModelTokens, countTextLines, truncateModelText } from '../runtime/token-budget.js';
 import { TOOL_EXECUTION_LIMITS } from '../tools/execution-limits.js';
 import { DEFAULT_COMPACTION_FOCUS, CompactionOperation, buildCompactionInput, buildCompactionMessages, buildCompactedHistory, compactedHistoryMessages, continuationMessage } from '../runtime/compact.js';
 import { buildSystemPrompt, MAR_AGENT_PROMPT_VERSION } from '../prompts/index.js';
@@ -930,7 +930,7 @@ export async function createMarAgent(options) {
                                             }
                                         })
                                 });
-                                const modelOutput = boundedModelToolOutput(output.content);
+                                const modelOutput = boundedModelToolOutput(call.name, output.content, output.data);
                                 const eventSummary = output.content.slice(0, AGENT_EXECUTION_POLICY.toolEventSummaryCharacters);
                                 const structuredData = structuredToolEventData(call.name, output.data);
                                 const artifacts = structuredToolArtifacts(call.name, output.artifacts);
@@ -1660,8 +1660,17 @@ function estimatedRequestTokens(system, messages, tools, images) {
     return (countModelTokens(`${system}${stableJson(textMessages)}${stableJson(tools)}`) +
         transientImageCount * AGENT_EXECUTION_POLICY.estimatedTokensPerImage);
 }
-function boundedModelToolOutput(value) {
-    const result = truncateModelText(value, AGENT_EXECUTION_POLICY.modelToolOutputTokens);
+function boundedModelToolOutput(toolName, value, data) {
+    const execDiagnostics = toolName === 'exec' &&
+        isRecord(data) &&
+        typeof data.stdout === 'string' &&
+        typeof data.stderr === 'string'
+        ? {
+            originalTokenCount: countModelTokens(data.stdout) + countModelTokens(data.stderr),
+            totalLines: countTextLines(data.stdout) + countTextLines(data.stderr)
+        }
+        : undefined;
+    const result = truncateModelText(value, AGENT_EXECUTION_POLICY.modelToolOutputTokens, 'tool output', execDiagnostics);
     return { content: result.content, truncated: result.truncated };
 }
 function stableJson(value) {

package/dist/tools/local-registry.js

@@ -208,6 +208,30 @@ function boundedUtf8Prefix(value, maximumBytes) {
     }
     return { value: `${result}${marker}`, truncated: true };
 }
+function oversizedLinePreview(value, retainedBytes, lineNumber) {
+    const bytes = Buffer.from(value, 'utf8');
+    if (retainedBytes >= bytes.length)
+        return { value, shownBytes: bytes.length, omittedBytes: 0 };
+    const headTarget = Math.floor(retainedBytes / 2);
+    const tailTarget = retainedBytes - headTarget;
+    let head = Math.min(headTarget, bytes.length);
+    while (head > 0 && isUtf8ContinuationByte(bytes[head]))
+        head--;
+    let tail = Math.max(head, bytes.length - tailTarget);
+    while (tail < bytes.length && isUtf8ContinuationByte(bytes[tail]))
+        tail++;
+    const shownBytes = head + bytes.length - tail;
+    const omittedBytes = bytes.length - shownBytes;
+    const marker = `...[${omittedBytes} bytes omitted from line ${lineNumber}]...`;
+    return {
+        value: `${bytes.toString('utf8', 0, head)}${marker}${bytes.toString('utf8', tail)}`,
+        shownBytes,
+        omittedBytes
+    };
+}
+function isUtf8ContinuationByte(value) {
+    return value !== undefined && (value & 0xc0) === 0x80;
+}
 function formatBatchReadResult(result, index, maximumBytes) {
     const visiblePath = boundedUtf8Prefix(result.path, 128);
     const path = escapeAttribute(visiblePath.value);
@@ -265,8 +289,59 @@ function formatBatchReadResult(result, index, maximumBytes) {
             high = middle - 1;
     }
     const content = render(low);
-    if (Buffer.byteLength(content) <= maximumBytes)
+    if (low > 0 && Buffer.byteLength(content) <= maximumBytes)
         return { content, previewComplete: low === lines.length };
+    if (lines.length > 0) {
+        const lineNumber = result.startLine;
+        const prefix = `${lineNumber}\t`;
+        const formattedLine = lines[0];
+        const sourceLine = formattedLine.startsWith(prefix)
+            ? formattedLine.slice(prefix.length)
+            : formattedLine;
+        const sourceLineBytes = Buffer.byteLength(sourceLine);
+        const renderOversizedLine = (retainedBytes) => {
+            const preview = oversizedLinePreview(sourceLine, retainedBytes, lineNumber);
+            const metadata = {
+                path: visiblePath.value,
+                ...(visiblePath.truncated ? { pathTruncated: true } : {}),
+                encoding: result.encoding,
+                newline: result.newline,
+                startLine: lineNumber,
+                endLine: lineNumber,
+                eof: false,
+                truncated: true,
+                previewComplete: false,
+                oversizedLine: {
+                    line: lineNumber,
+                    bytes: sourceLineBytes,
+                    shownBytes: preview.shownBytes,
+                    omittedBytes: preview.omittedBytes
+                }
+            };
+            return [
+                `<read_result index="${index}" path="${path}"${pathTruncatedAttribute}>`,
+                `${prefix}${preview.value}`,
+                `<read_metadata>${JSON.stringify(metadata)}</read_metadata>`,
+                '</read_result>'
+            ].join('\n');
+        };
+        let minimum = renderOversizedLine(0);
+        if (Buffer.byteLength(minimum) <= maximumBytes) {
+            let retainedLow = 0;
+            let retainedHigh = sourceLineBytes;
+            while (retainedLow < retainedHigh) {
+                const middle = Math.ceil((retainedLow + retainedHigh) / 2);
+                const candidate = renderOversizedLine(middle);
+                if (Buffer.byteLength(candidate) <= maximumBytes) {
+                    retainedLow = middle;
+                    minimum = candidate;
+                }
+                else
+                    retainedHigh = middle - 1;
+            }
+            return { content: minimum, previewComplete: false };
+        }
+    }
     return {
         content: `<read_error index="${index}" code="MAR_AGENT_TOOL_OUTPUT_LIMIT">Model-visible read metadata exceeds this item's output share.</read_error>`,
         previewComplete: false

package/dist/tools/read.js

@@ -46,7 +46,7 @@ export const readToolDefinition = {
             }
         }
     },
-    description: `Read one or more known text files/ranges. Strict UTF-8 with optional BOM is the default; BOM-declared UTF-16LE/UTF-16BE is supported. Invalid text returns an item error instead of replacement characters. Always pass reads; use one item for a single file and up to ${TOOL_EXECUTION_LIMITS.readMaxBatchItems} items for a batch. Batch only already-located, bounded ranges whose combined content is likely to fit the model-visible output budget; for exploration, locate relevant files, symbols, or headings first, then read the smallest useful ranges. Results retain input order, use 1-based line numbers, and include <read_metadata> with path, encoding, newline, exact visible range, eof, truncation, nextOffset, and whether previewComplete. Items fail independently and run with bounded concurrency. Each item returns at most ${TOOL_EXECUTION_LIMITS.readMaxLines} lines/${TOOL_EXECUTION_LIMITS.readMaxBytes} bytes; the structured call shares a ${TOOL_EXECUTION_LIMITS.readMaxBatchBytes}-byte budget, while ordinary model-visible content fairly shares the common tool-output budget across all items. Structured data.results items provide text as decoded source for the returned range, preserving line endings and excluding BOM; content is numbered display text. Large files support bounded range reads. If previewComplete is false, continue only the still-relevant item from nextOffset. Relative paths use the workspace; absolute paths are allowed. Prefer exec with rg for search and read for known files.`,
+    description: `Read one or more known text files/ranges. Strict UTF-8 with optional BOM is the default; BOM-declared UTF-16LE/UTF-16BE is supported. Invalid text returns an item error instead of replacement characters. Always pass reads; use one item for a single file and up to ${TOOL_EXECUTION_LIMITS.readMaxBatchItems} items for a batch. Batch only already-located, bounded ranges whose combined content is likely to fit the model-visible output budget; for exploration, locate relevant files, symbols, or headings first, then read the smallest useful ranges. Results retain input order, use 1-based line numbers, and include <read_metadata> with path, encoding, newline, exact visible range, eof, truncation, nextOffset, and whether previewComplete. Items fail independently and run with bounded concurrency. Each item returns at most ${TOOL_EXECUTION_LIMITS.readMaxLines} lines/${TOOL_EXECUTION_LIMITS.readMaxBytes} bytes; the structured call shares a ${TOOL_EXECUTION_LIMITS.readMaxBatchBytes}-byte budget, while ordinary model-visible content fairly shares the common tool-output budget across all items. Structured data.results items provide text as decoded source for the returned range, preserving line endings and excluding BOM; content is numbered display text. Large files support bounded range reads. If previewComplete is false and nextOffset is present, continue only the still-relevant item from nextOffset. An oversized single line instead returns a head/tail preview with no line continuation cursor; use exec to obtain exact source before editing omitted content. Relative paths use the workspace; absolute paths are allowed. Prefer exec with rg for search and read for known files.`,
     inputSchema: {
         type: 'object',
         properties: {

package/package.json

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