@myagentroam/agent 0.9.150 → 0.9.152

package/dist/agent-core/prompts/execution-budget.d.ts

@@ -1,3 +1,3 @@
 import type { RolloutBudgetStage } from '../runtime/rollout-budget.js';
-export type ExecutionBudgetEnvironmentStage = Exclude<RolloutBudgetStage, 'normal'> | 'inactive';
+export type ExecutionBudgetEnvironmentStage = Exclude<RolloutBudgetStage, 'normal' | 'exhausted'> | 'inactive';
 export declare function executionBudgetEnvironmentEntry(stage: ExecutionBudgetEnvironmentStage): string;

package/dist/agent-core/prompts/execution-budget.js

@@ -2,10 +2,8 @@ export function executionBudgetEnvironmentEntry(stage) {
     if (stage === 'inactive')
         return '<execution_guidance status="inactive" />';
     const privateInstruction = 'This is internal runtime guidance. Never mention the budget, thresholds, remaining amount, or budget stage in user-visible progress or the final answer.';
-    const guidance = stage === 'exhausted'
-        ? 'The shared rollout budget is exhausted. Do not start or continue investigation, optional work, new tool exploration, or new subagents. Return a concise final answer now using the current verified staged result. Clearly distinguish completed work from anything still incomplete, without mentioning this budget.'
-        : stage === 'finalize'
-            ? 'Enter finalization now. Do not start new investigation or new subagents. Complete only the current atomic change, the minimum necessary verification, and the final answer as soon as possible.'
-            : 'Stop expanding scope and stop optional work. Prefer completing the current objective with the evidence already gathered, and avoid new investigation unless it is strictly required for correctness.';
+    const guidance = stage === 'finalize'
+        ? 'Enter finalization now. Do not start new investigation or new subagents. Complete only the current atomic change, the minimum necessary verification, and the final answer as soon as possible.'
+        : 'Stop expanding scope and stop optional work. Prefer completing the current objective with the evidence already gathered, and avoid new investigation unless it is strictly required for correctness.';
     return `<execution_guidance stage="${stage}">\n${privateInstruction}\n\n${guidance}\n</execution_guidance>`;
 }

package/dist/agent-core/runtime/execution.js

@@ -34,6 +34,7 @@ export class ExecutionLoop {
             const pendingTools = [];
             let incompleteToolCall = false;
             const round = await input.prepareRound(pendingOutputContinuation);
+            input.rolloutBudget?.assertAvailable();
             let sawModelSemanticEvent = false;
             let requestStartedAt;
             let firstModelResponseAt;
@@ -293,11 +294,6 @@ export class ExecutionLoop {
             }
             recoveringFromContextOverflow = false;
             input.observeUsage(roundServerUsage);
-            if (pendingTools.length === 0 && input.mailbox.hasPending()) {
-                await input.mailbox.append();
-                this.finalAnswer = '';
-                continue;
-            }
             const toolResults = await executeRoundTools(pendingTools, round.toolScope);
             for (const result of toolResults) {
                 if ('images' in result && result.images?.length)
@@ -335,11 +331,12 @@ export class ExecutionLoop {
                     this.finalAnswer = '';
             }
             input.rolloutBudget?.recordUsage(latestUsage);
+            if (!input.signal.aborted)
+                input.rolloutBudget?.assertAvailable();
             if (mode !== 'compact' && stop === 'max_output') {
                 const needsContinuation = !sawTool || incompleteToolCall;
                 if (needsContinuation) {
-                    if (maxOutputContinuationUsed ||
-                        (input.rolloutBudget?.active && input.rolloutBudget.stage === 'exhausted'))
+                    if (maxOutputContinuationUsed)
                         throw new MarAgentError('MAR_AGENT_MODEL_OUTPUT_INCOMPLETE', 'Model output reached its limit before completing.');
                     maxOutputContinuationUsed = true;
                     pendingOutputContinuation = {
@@ -358,6 +355,7 @@ export class ExecutionLoop {
                 const aborted = toolResults.find((result) => result.failed)?.error;
                 throw aborted ?? new MarAgentError('MAR_AGENT_EXECUTION_CANCELLED', 'Execution cancelled.');
             }
+            input.rolloutBudget?.assertAvailable();
             if (input.mailbox.hasPending()) {
                 await input.mailbox.append();
                 this.finalAnswer = '';

package/dist/agent-core/runtime/rollout-budget.d.ts

@@ -19,6 +19,7 @@ export declare class RolloutBudget {
     get stage(): RolloutBudgetStage;
     recordUsage(usage: ModelUsage | undefined): number;
     discard(): void;
+    assertAvailable(): void;
 }
 export declare function resolveRolloutBudgetOptions(options: false | RolloutBudgetOptions | undefined): ResolvedRolloutBudgetOptions | undefined;
 export declare function createRolloutBudget(options: false | RolloutBudgetOptions | undefined): RolloutBudget | undefined;

package/dist/agent-core/runtime/rollout-budget.js

@@ -48,6 +48,10 @@ export class RolloutBudget {
     discard() {
         this.#active = false;
     }
+    assertAvailable() {
+        if (this.stage === 'exhausted')
+            throw new MarAgentError('MAR_AGENT_ROLLOUT_BUDGET_EXCEEDED', 'The shared execution token budget has been exhausted.');
+    }
 }
 export function resolveRolloutBudgetOptions(options) {
     if (options === false)

package/dist/agent-core/sdk/session.js

@@ -234,7 +234,10 @@ export function createSessionOpener(services) {
                     let recordedEnvironment = restored.environmentState;
                     let projectedExecutionBudgetStage;
                     const appendExecutionBudgetEnvironment = () => {
+                        rolloutBudget?.assertAvailable();
                         const currentStage = rolloutBudget?.active ? rolloutBudget.stage : 'inactive';
+                        if (currentStage === 'exhausted')
+                            return;
                         if (currentStage === projectedExecutionBudgetStage)
                             return;
                         const previousStage = projectedExecutionBudgetStage;
@@ -806,9 +809,7 @@ export function createSessionOpener(services) {
                                 executionEnvironment = { ...currentEnvironment, ...currentLocalTimeContext() };
                                 await recordEnvironment();
                             }
-                            const toolsAllowed = mode !== 'compact' &&
-                                (!rolloutBudget?.active || rolloutBudget.stage !== 'exhausted');
-                            const roundTools = mode === 'compact' ? executionTools : toolsAllowed ? executionTools : [];
+                            const roundTools = executionTools;
                             const codeModeEnabled = roundTools.some((tool) => tool.name === 'code_exec');
                             const residentTools = mcpRegistry.projectDirect(baseTools());
                             const requestTools = (() => {
@@ -891,11 +892,7 @@ export function createSessionOpener(services) {
                                     system: systemPrompt,
                                     messages: modelMessages.map((message) => projectCodeModeSearchResult(message, codeModeEnabled)),
                                     tools: requestTools,
-                                    ...(mode === 'compact'
-                                        ? { toolChoice: 'none' }
-                                        : toolsAllowed
-                                            ? {}
-                                            : { allowTools: false }),
+                                    ...(mode === 'compact' ? { toolChoice: 'none' } : {}),
                                     promptCacheKey: sessionId,
                                     reasoningEffort,
                                     ...(requestReasoningEffort === undefined ? {} : { requestReasoningEffort }),

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

@@ -11,6 +11,8 @@ import { contextGcBaseFromRecords, contextGcBaseSequence, contextGcMinimumUsageG
 import { beginSessionStorageTransaction, isUnjournaledTransactionFile, recoverSessionStorageTransaction } from './transaction-recovery.js';
 const MAX_SEGMENT_BYTES = 16 * 1024 * 1024;
 const REVERSE_READ_CHUNK_BYTES = 64 * 1024;
+const MAX_HISTORY_PAGE_FILES = 32;
+const MAX_HISTORY_PAGE_OFFSETS = 128;
 const MAX_INPUT_IMAGES = 5;
 const MAX_INPUT_IMAGE_BYTES = 5 * 1024 * 1024;
 const MAX_INPUT_IMAGES_BYTES = 10 * 1024 * 1024;
@@ -161,7 +163,8 @@ export class JsonlSessionStore {
             recordWrites: new Map(),
             writerLeases: new Map(),
             segments: new Map(),
-            executionModelReads: new Map()
+            executionModelReads: new Map(),
+            historyPagePositions: new Map()
         };
     }
     /** Merge dirty metadata with disk membership; only createdIds publish locally new entries. */
@@ -1171,7 +1174,7 @@ export class JsonlSessionStore {
             if (segment !== undefined && segment.firstSequence >= before)
                 continue;
             const needed = limit - page.length;
-            const window = await readRecordPageFromTail(path, before, needed);
+            const window = await readRecordPageFromTail(path, before, needed, this.#shared.historyPagePositions);
             page.unshift(...window.records);
             if (window.hasEarlier) {
                 hasEarlier = true;
@@ -2338,9 +2341,9 @@ async function repairSegmentTail(path) {
         await handle.close();
     }
 }
-async function readRecordPageFromTail(path, beforeSequence, limit) {
+async function readRecordPageFromTail(path, beforeSequence, limit, positions) {
     const newestFirst = [];
-    for await (const record of readRecordsFromTail(path)) {
+    for await (const record of readRecordsFromTail(path, { beforeSequence, limit, positions })) {
         if (!(record.sequence < beforeSequence))
             continue;
         newestFirst.push(record);
@@ -2353,14 +2356,42 @@ async function readRecordPageFromTail(path, beforeSequence, limit) {
     };
 }
 /** Decode complete records newest-first, releasing the file as soon as a reader stops. */
-async function* readRecordsFromTail(path) {
+async function* readRecordsFromTail(path, page) {
     const handle = await open(path, 'r');
     try {
-        const size = (await handle.stat()).size;
+        const metadata = await handle.stat({ bigint: true });
+        const size = Number(metadata.size);
         let position = size;
+        let cached;
+        if (page !== undefined) {
+            const signature = `${metadata.dev}:${metadata.ino}:${metadata.size}:${metadata.mtimeNs}:${metadata.ctimeNs}`;
+            const previous = page.positions.get(path);
+            cached = previous?.signature === signature ? previous : { signature, offsets: new Map() };
+            page.positions.delete(path);
+            page.positions.set(path, cached);
+            if (page.positions.size > MAX_HISTORY_PAGE_FILES)
+                page.positions.delete(page.positions.keys().next().value);
+            let nearestSequence = Number.POSITIVE_INFINITY;
+            for (const [sequence, offset] of cached.offsets) {
+                if (sequence >= page.beforeSequence && sequence < nearestSequence) {
+                    nearestSequence = sequence;
+                    position = offset;
+                }
+            }
+        }
+        let accepted = 0;
+        const remember = (record, offset) => {
+            if (page === undefined || cached === undefined || record.sequence >= page.beforeSequence)
+                return;
+            if (++accepted !== page.limit)
+                return;
+            cached.offsets.set(record.sequence, offset);
+            if (cached.offsets.size > MAX_HISTORY_PAGE_OFFSETS)
+                cached.offsets.delete(cached.offsets.keys().next().value);
+        };
         let pendingLineParts = [];
         let invalidFinalLineMayBeIgnored = false;
-        let inspectedFileEnd = false;
+        let inspectedFileEnd = position !== size;
         const decode = (line, allowInvalidFinalLine) => {
             if (line.length === 0)
                 return undefined;
@@ -2402,8 +2433,10 @@ async function* readRecordsFromTail(path) {
                 invalidFinalLineMayBeIgnored = false;
                 pendingLineParts = [];
                 lineEnd = index;
-                if (record !== undefined)
+                if (record !== undefined) {
+                    remember(record, start + index + 1);
                     yield record;
+                }
             }
             if (lineEnd > 0)
                 pendingLineParts.unshift(Buffer.from(value.subarray(0, lineEnd)));
@@ -2411,8 +2444,10 @@ async function* readRecordsFromTail(path) {
         }
         if (pendingLineParts.length > 0) {
             const record = decode(Buffer.concat(pendingLineParts), invalidFinalLineMayBeIgnored);
-            if (record !== undefined)
+            if (record !== undefined) {
+                remember(record, 0);
                 yield record;
+            }
         }
     }
     finally {

package/dist/agent-core/tools/local/exec.js

@@ -50,7 +50,7 @@ export const execToolDefinition = {
             },
             cwd: {
                 type: 'string',
-                description: 'Optional relative/absolute start directory; defaults to workspace.'
+                description: 'Optional relative/absolute start directory; defaults to workspace. Command-internal relative paths resolve from this directory.'
             },
             timeoutMs: { type: 'integer', minimum: 1, maximum: TOOL_EXECUTION_LIMITS.execMaxTimeoutMs },
             yieldMs: {

package/package.json

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