@myagentroam/agent 0.11.24 → 0.11.25

package/dist/agent-core/sdk/resource-input.d.ts

@@ -27,5 +27,6 @@ export declare class ResourceInputProjection {
     /** Propose a cursor; only the unified GC checkpoint may adopt it. */
     gcCandidate(request?: ModelRequest, mirroredImages?: readonly ModelImage[]): Promise<InlineMediaGcCandidate | undefined>;
     adoptGc(state: InlineMediaState | undefined): void;
+    releaseBytes(): void;
 }
 export {};

package/dist/agent-core/sdk/resource-input.js

@@ -3,9 +3,11 @@ import { MarAgentError } from '../error.js';
 import { isModelImageUrl } from '../model/image.js';
 import { observationImages, renderObservationResult, selectObservationImages } from '../tools/code-mode/observations.js';
 import { INLINE_MEDIA_POLICY as policy, assertInlineMediaBudget, inlineMediaBytes, inlineMediaHistory, inlineMediaLimit, inlineMediaSource } from '../session/inline-media.js';
-function releasedImageNotice(message, indices) {
+function releasedImageNotice(message, indices, unavailable) {
     return indices
         .map((index) => {
+        if (unavailable?.has(index))
+            return 'Image unavailable; omitted from context.';
         const resourceId = message.images?.[index]?.resourceId;
         const hint = resourceId
             ? ` Reopen with view_image(${JSON.stringify({ resourceId })}) if needed.`
@@ -14,7 +16,7 @@ function releasedImageNotice(message, indices) {
     })
         .join('\n');
 }
-function projectRetainedImages(message, images, removed) {
+function projectRetainedImages(message, images, removed, unavailable) {
     if (!removed.size)
         return { ...message, images };
     if (message.observations) {
@@ -22,7 +24,7 @@ function projectRetainedImages(message, images, removed) {
             const removedIndices = observationImages(observation).filter((index) => removed.has(index));
             if (!removedIndices.length)
                 return observation;
-            const notice = releasedImageNotice(message, removedIndices);
+            const notice = releasedImageNotice(message, removedIndices, unavailable);
             return observation.type === 'tool_result'
                 ? {
                     ...observation,
@@ -37,7 +39,7 @@ function projectRetainedImages(message, images, removed) {
             content: renderObservationResult(selected.observations, message.content)
         };
     }
-    const notice = releasedImageNotice(message, [...removed]);
+    const notice = releasedImageNotice(message, [...removed], unavailable);
     return {
         ...message,
         images: images.filter(Boolean),
@@ -54,6 +56,8 @@ export class ResourceInputProjection {
     #entries = [];
     #sources = new Map();
     #candidates = new WeakMap();
+    #resourceReads = new Map();
+    #cachedBytes = 0;
     #considered = -1;
     #rollout = 0;
     #evicted = -1;
@@ -98,12 +102,15 @@ export class ResourceInputProjection {
         for (const message of messages)
             for (const [index, image] of (message.images ?? []).entries()) {
                 const entry = this.#entries[this.#entry(inlineMediaSource(message), index)];
+                if (entry.image && !isDeepStrictEqual(entry.image, image))
+                    delete entry.unavailable;
                 entry.image = image;
                 entry.active = true;
             }
     }
     /** Called only at an explicit context replacement, never as a history diff detector. */
     replace(messages) {
+        this.releaseBytes();
         for (const entry of this.#entries) {
             entry.active = false;
             delete entry.image;
@@ -133,16 +140,23 @@ export class ResourceInputProjection {
             if (!images?.length)
                 return message;
             const removed = new Set();
+            const unavailable = new Set();
             const retained = [];
             images.forEach((image, index) => {
-                if (!this.useResourceUrl &&
+                const position = positions?.[index];
+                const entry = position === undefined ? undefined : this.#entries[position];
+                if (entry?.unavailable && isDeepStrictEqual(entry.image, image)) {
+                    removed.add(index);
+                    unavailable.add(index);
+                }
+                else if (!this.useResourceUrl &&
                     positions?.[index] !== undefined &&
                     positions[index] <= evicted)
                     removed.add(index);
                 else
                     retained[index] = image;
             });
-            return projectRetainedImages({ ...message, images }, retained, removed);
+            return projectRetainedImages({ ...message, images }, retained, removed, unavailable);
         });
     }
     checkpoint(messages) {
@@ -167,50 +181,44 @@ export class ResourceInputProjection {
         this.observe(canonicalMessages);
         const through = this.#entries.length - 1;
         const cached = new Map();
-        const project = (image) => {
-            let value = cached.get(image);
+        const project = (image, entry) => {
+            const key = entry && isDeepStrictEqual(entry.image, image) ? entry : image;
+            let value = cached.get(key);
             if (!value)
-                cached.set(image, (value = this.#project(image)));
+                cached.set(key, (value = this.#project(image, entry)));
             return value;
         };
-        const sized = async (image) => image.dataBase64 !== undefined || image.byteSize !== undefined ? image : project(image);
         const top = (request.images ?? []).filter((image) => !mirroredImages.some((mirror) => isDeepStrictEqual(image, mirror)));
         const evicted = this.#evicted;
-        if (!this.useResourceUrl) {
-            let total = 0;
-            for (const message of request.messages)
-                for (const [index, image] of (message.images ?? []).entries()) {
-                    const position = this.#sources.get(inlineMediaSource(message))?.[index];
-                    const original = position === undefined ? undefined : this.#entries[position]?.image;
-                    if (position !== undefined && position <= evicted && isDeepStrictEqual(original, image))
-                        continue;
-                    total += inlineMediaBytes(await sized(image));
-                }
-            for (const image of top)
-                total += inlineMediaBytes(await sized(image));
-            if (total > policy.requestInlineMediaHardLimit)
-                inlineMediaLimit();
-        }
         const messages = await Promise.all(request.messages.map(async (message) => {
             if (!message.images?.length)
                 return message;
             const removed = new Set();
+            const unavailable = new Set();
             const images = [];
             await Promise.all(message.images.map(async (image, index) => {
                 const position = this.#sources.get(inlineMediaSource(message))?.[index];
-                const original = position === undefined ? undefined : this.#entries[position]?.image;
+                const entry = position === undefined ? undefined : this.#entries[position];
+                const original = entry?.image;
                 if (!this.useResourceUrl &&
                     position !== undefined &&
                     position <= evicted &&
                     isDeepStrictEqual(original, image))
                     removed.add(index);
-                else
-                    images[index] = await project(image);
+                else {
+                    const projected = await project(image, entry);
+                    if (projected)
+                        images[index] = projected;
+                    else {
+                        removed.add(index);
+                        unavailable.add(index);
+                    }
+                }
             }));
-            return projectRetainedImages(message, images, removed);
+            return projectRetainedImages(message, images, removed, unavailable);
         }));
         const { images: _topImages, ...retained } = request;
-        const images = await Promise.all(top.map(project));
+        const images = (await Promise.all(top.map((image) => project(image)))).filter((image) => image !== undefined);
         const result = { ...retained, messages, ...(images.length ? { images } : {}) };
         if (!this.useResourceUrl)
             assertInlineMediaBudget(result);
@@ -241,16 +249,25 @@ export class ResourceInputProjection {
     async gcCandidate(request, mirroredImages = []) {
         if (this.useResourceUrl)
             return undefined;
-        const size = async (image) => inlineMediaBytes(image.byteSize !== undefined || image.dataBase64 !== undefined
-            ? image
-            : await this.#project(image));
+        const size = async (image, entry) => {
+            if (entry?.unavailable && isDeepStrictEqual(entry.image, image))
+                return 0;
+            const sized = image.byteSize !== undefined || image.dataBase64 !== undefined
+                ? image
+                : await this.#project(image, entry);
+            return sized ? inlineMediaBytes(sized) : 0;
+        };
+        const actualSize = async (image, entry) => {
+            const projected = await this.#project(image, entry);
+            return projected ? inlineMediaBytes(projected) : 0;
+        };
         const history = await Promise.all(this.#entries.map(async (entry, index) => ({
             index,
             bytes: entry.active && entry.image && index > this.#evicted && index <= this.#considered
-                ? await size(entry.image)
+                ? await size(entry.image, entry)
                 : 0
         })));
-        const beforeBytes = history.reduce((sum, entry) => sum + entry.bytes, 0);
+        let beforeBytes = history.reduce((sum, entry) => sum + entry.bytes, 0);
         let freshBytes = 0;
         let requestBytes = 0;
         const requestHistory = new Map();
@@ -262,20 +279,23 @@ export class ResourceInputProjection {
                     const original = entry && isDeepStrictEqual(entry.image, image);
                     if (original && position <= this.#evicted)
                         continue;
-                    const bytes = await size(image);
+                    const bytes = await actualSize(image, entry);
                     requestBytes += bytes;
-                    if (original && position <= this.#considered)
+                    if (original && position <= this.#considered) {
                         requestHistory.set(position, (requestHistory.get(position) ?? 0) + bytes);
+                        history[position].bytes = bytes;
+                    }
                     else
                         freshBytes += bytes;
                 }
             for (const image of request.images ?? []) {
                 if (mirroredImages.some((mirror) => isDeepStrictEqual(image, mirror)))
                     continue;
-                const bytes = await size(image);
+                const bytes = await actualSize(image);
                 freshBytes += bytes;
                 requestBytes += bytes;
             }
+            beforeBytes = history.reduce((sum, item) => sum + item.bytes, 0);
             if (freshBytes > policy.requestInlineMediaHardLimit)
                 inlineMediaLimit();
         }
@@ -319,23 +339,64 @@ export class ResourceInputProjection {
         };
     }
     adoptGc(state) {
-        if (state)
+        if (state) {
             this.#evicted = this.#position(state.evictedThrough);
+            this.releaseBytes();
+        }
+    }
+    releaseBytes() {
+        this.#resourceReads.clear();
+        this.#cachedBytes = 0;
+    }
+    #readBytes(resourceId) {
+        const cached = this.#resourceReads.get(resourceId);
+        if (cached)
+            return cached;
+        const pending = this.store.readResource(this.sessionId, resourceId).then((resource) => {
+            if (this.#resourceReads.get(resourceId) === pending) {
+                const bytes = resource?.dataBase64 ? inlineMediaBytes(resource) : 0;
+                if (!bytes || this.#cachedBytes + bytes > policy.requestInlineMediaHardLimit)
+                    this.#resourceReads.delete(resourceId);
+                else
+                    this.#cachedBytes += bytes;
+            }
+            return resource;
+        }, (error) => {
+            if (this.#resourceReads.get(resourceId) === pending)
+                this.#resourceReads.delete(resourceId);
+            throw error;
+        });
+        this.#resourceReads.set(resourceId, pending);
+        return pending;
     }
-    async #project(image) {
+    async #project(image, entry) {
+        const original = entry && isDeepStrictEqual(entry.image, image);
+        if (original && entry.unavailable)
+            return undefined;
         if (this.useResourceUrl) {
             if (!isModelImageUrl(image.url))
                 throw new MarAgentError('MAR_AGENT_RESOURCE_URL_UNAVAILABLE', 'Resource URL is unavailable.');
             const { dataBase64: _bytes, ...reference } = image;
             return reference;
         }
-        const bytes = image.dataBase64 !== undefined
-            ? image
-            : image.resourceId === undefined
-                ? undefined
-                : await this.store.readResource(this.sessionId, image.resourceId);
-        if (!bytes?.dataBase64)
-            throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Resource bytes are unavailable.');
+        let bytes;
+        try {
+            bytes =
+                image.dataBase64 !== undefined
+                    ? image
+                    : image.resourceId === undefined
+                        ? undefined
+                        : await this.#readBytes(image.resourceId);
+        }
+        catch (error) {
+            if (!(error instanceof MarAgentError) || error.code !== 'MAR_AGENT_IMAGE_UNAVAILABLE')
+                throw error;
+        }
+        if (!bytes?.dataBase64) {
+            if (original)
+                entry.unavailable = true;
+            return undefined;
+        }
         const { url: _url, urlExpiresAt: _expires, ...reference } = image;
         return { ...reference, dataBase64: bytes.dataBase64 };
     }

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

@@ -389,6 +389,7 @@ export function createSessionOpener(services) {
                 let finalAnswer = '';
                 let executionLoop;
                 let executionToolSources;
+                let releaseImageBytes;
                 const contextGc = new ContextGcRuntime();
                 let selectedAdapter;
                 const modelResources = createExecutionModelResources(activeExecutionAdapters);
@@ -816,6 +817,7 @@ export function createSessionOpener(services) {
                             }));
                         }
                     });
+                    releaseImageBytes = () => resourceInput.releaseBytes();
                     const selected = modelResources.openTurn(selectedAdapter, services.hasCustomAdapters && selectedAdapter.createTurnSession === undefined);
                     let lastServerUsage = latestModelUsage(contextRecords, selectedModel.id);
                     let smartContextTokens = latestSmartContextTokens(contextRecords, selectedModel.id, selectedModel.contextWindowTokens);
@@ -1981,6 +1983,7 @@ export function createSessionOpener(services) {
                     };
                 }
                 finally {
+                    releaseImageBytes?.();
                     // Revoke this Execution's request and input bindings, not Session warm resources.
                     delete executionContext.requestMessages;
                     compactRequests.close(new MarAgentError('MAR_AGENT_CANCELLED', 'Execution ended.'));

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

@@ -1,6 +1,4 @@
-import { createHash } from 'node:crypto';
-import { constants } from 'node:fs';
-import { copyFile, lstat, mkdir, open } from 'node:fs/promises';
+import { copyFile, mkdir, readFile } from 'node:fs/promises';
 import { basename, join } from 'node:path';
 import { MarAgentError } from '../../error.js';
 import { isModelImageUrl } from '../../model/image.js';
@@ -93,57 +91,14 @@ export function validInputImageFileName(fileName) {
     return (basename(fileName) === fileName && /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}\.bin$/u.test(fileName));
 }
 export async function readInputImageBytes(directory, reference) {
-    const path = join(directory, reference.fileName);
-    for (let attempt = 0; attempt < 2; attempt++) {
-        let handle;
-        try {
-            const before = await lstat(path);
-            if (!before.isFile() || before.size !== reference.byteSize)
-                throw corruptInputImageReference();
-            const flags = process.platform === 'win32'
-                ? constants.O_RDONLY
-                : constants.O_RDONLY | constants.O_NOFOLLOW;
-            handle = await open(path, flags);
-            const opened = await handle.stat();
-            if (!opened.isFile() ||
-                opened.size !== reference.byteSize ||
-                opened.dev !== before.dev ||
-                opened.ino !== before.ino)
-                continue;
-            const data = await readExactBytes(handle, reference.byteSize);
-            const after = await handle.stat();
-            if (after.size !== opened.size ||
-                after.mtimeMs !== opened.mtimeMs ||
-                after.ctimeMs !== opened.ctimeMs)
-                continue;
-            if (createHash('sha256').update(data).digest('hex') !== reference.sha256)
-                throw corruptInputImageReference();
-            return data;
-        }
-        catch (cause) {
-            if (cause instanceof MarAgentError)
-                throw cause;
-            throw corruptInputImageReference(cause);
-        }
-        finally {
-            await handle?.close();
-        }
+    try {
+        return await readFile(join(directory, reference.fileName));
     }
-    throw corruptInputImageReference();
-}
-async function readExactBytes(handle, byteSize) {
-    const data = Buffer.alloc(byteSize);
-    let offset = 0;
-    while (offset < byteSize) {
-        const { bytesRead } = await handle.read(data, offset, byteSize - offset, offset);
-        if (bytesRead === 0)
-            throw corruptInputImageReference();
-        offset += bytesRead;
+    catch (cause) {
+        throw new MarAgentError('MAR_AGENT_IMAGE_UNAVAILABLE', 'Session input image is unavailable.', {
+            cause
+        });
     }
-    const extra = Buffer.allocUnsafe(1);
-    if ((await handle.read(extra, 0, 1, byteSize)).bytesRead !== 0)
-        throw corruptInputImageReference();
-    return data;
 }
 function corruptInputImageReference(cause) {
     return new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Session input image is corrupt.', {

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

@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { inlineMediaHistory } from '../inline-media.js';
-import { lstat, mkdir, open, readdir, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { lstat, mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { basename, join } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import { MarAgentError } from '../../error.js';
@@ -394,27 +394,15 @@ export class JsonlSessionStore {
     async readContextualWorldState(sessionId) {
         const path = join(this.#sessionDirectory(sessionId), CONTEXTUAL_WORLD_STATE_FILE);
         try {
-            const pathInfo = await lstat(path);
-            if (!pathInfo.isFile())
+            const envelope = JSON.parse(await readFile(path, 'utf8'));
+            const meta = this.#shared.index.sessions.find((item) => item.id === sessionId);
+            if (envelope.version !== 1 ||
+                !Number.isSafeInteger(envelope.historySequence) ||
+                envelope.historySequence < 1 ||
+                meta === undefined ||
+                envelope.historySequence >= meta.nextSequence)
                 return undefined;
-            const file = await open(path, 'r');
-            try {
-                const info = await file.stat();
-                if (!info.isFile() || info.size > MAX_CONTEXTUAL_WORLD_STATE_BYTES)
-                    return undefined;
-                const envelope = JSON.parse(await file.readFile('utf8'));
-                const meta = this.#shared.index.sessions.find((item) => item.id === sessionId);
-                if (envelope.version !== 1 ||
-                    !Number.isSafeInteger(envelope.historySequence) ||
-                    envelope.historySequence < 1 ||
-                    meta === undefined ||
-                    envelope.historySequence >= meta.nextSequence)
-                    return undefined;
-                return envelope.state;
-            }
-            finally {
-                await file.close();
-            }
+            return envelope.state;
         }
         catch {
             return undefined;
@@ -490,16 +478,21 @@ export class JsonlSessionStore {
         if (!/^[a-f0-9]{64}$/u.test(resourceId))
             return undefined;
         return this.#serializeRecordOperation(sessionId, async () => {
+            let pending = false;
             try {
                 await lstat(join(directory, `.${resourceId}.pending`));
-                if (this.#shared.writerLeases.get(sessionId)?.appendFailure !== undefined ||
-                    !resourceFiles(await this.#readRecords(sessionId)).has(`${resourceId}.bin`))
-                    return undefined;
+                pending = true;
             }
-            catch (error) {
-                if (error.code !== 'ENOENT')
-                    throw error;
+            catch (cause) {
+                if (cause.code !== 'ENOENT')
+                    throw new MarAgentError('MAR_AGENT_IMAGE_UNAVAILABLE', 'Session image resource is unavailable.', {
+                        cause
+                    });
             }
+            if (pending &&
+                (this.#shared.writerLeases.get(sessionId)?.appendFailure !== undefined ||
+                    !resourceFiles(await this.#readRecords(sessionId)).has(`${resourceId}.bin`)))
+                return undefined;
             return readResource(directory, resourceId);
         });
     }

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

@@ -12,44 +12,39 @@ function resourceIdentity(mimeType, sha256) {
 export async function resourceMetadata(directory, resourceId) {
     if (!idPattern.test(resourceId))
         return undefined;
-    let text;
     try {
-        text = await readFile(join(directory, `${resourceId}.json`), 'utf8');
+        const value = JSON.parse(await readFile(join(directory, `${resourceId}.json`), 'utf8'));
+        const resource = value;
+        if (!value ||
+            typeof value !== 'object' ||
+            Array.isArray(value) ||
+            typeof resource.resourceId !== 'string' ||
+            typeof resource.mimeType !== 'string' ||
+            typeof resource.byteSize !== 'number' ||
+            typeof resource.sha256 !== 'string' ||
+            (resource.url !== undefined &&
+                (typeof resource.url !== 'string' ||
+                    !isModelImageUrl(resource.url) ||
+                    !Number.isSafeInteger(resource.urlExpiresAt) ||
+                    resource.urlExpiresAt <= 0)) ||
+            (resource.url === undefined && resource.urlExpiresAt !== undefined))
+            throw new Error('Invalid Session image resource metadata.');
+        return value;
     }
-    catch (error) {
-        if (error.code === 'ENOENT')
+    catch (cause) {
+        if (cause.code === 'ENOENT')
             return undefined;
-        throw error;
-    }
-    let value;
-    try {
-        value = JSON.parse(text);
-    }
-    catch {
-        // Invalid JSON is reported below without exposing metadata contents.
+        throw new MarAgentError('MAR_AGENT_IMAGE_UNAVAILABLE', 'Session image resource is unavailable.', {
+            cause
+        });
     }
-    if (!value ||
-        value.resourceId !== resourceId ||
-        !mimeTypes.has(value.mimeType) ||
-        !Number.isSafeInteger(value.byteSize) ||
-        value.byteSize <= 0 ||
-        value.byteSize > 20 * 1024 * 1024 ||
-        !idPattern.test(value.sha256) ||
-        resourceIdentity(value.mimeType, value.sha256) !== resourceId ||
-        (value.url !== undefined &&
-            (!isModelImageUrl(value.url) ||
-                !Number.isSafeInteger(value.urlExpiresAt) ||
-                value.urlExpiresAt <= 0)) ||
-        (value.url === undefined && value.urlExpiresAt !== undefined))
-        throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Session image resource is corrupt.');
-    return value;
 }
 export async function persistResource(directory, image) {
     if (image.resourceId !== undefined && image.dataBase64 === undefined) {
         const existing = await resourceMetadata(directory, image.resourceId);
         if (existing !== undefined && existing.mimeType === image.mimeType)
             return existing;
-        throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Session image resource is missing.');
+        throw new MarAgentError('MAR_AGENT_IMAGE_UNAVAILABLE', 'Session image resource is missing.');
     }
     const data = Buffer.from(image.dataBase64 ?? '', 'base64');
     if (data.toString('base64') !== image.dataBase64)
@@ -60,10 +55,16 @@ export async function persistResource(directory, image) {
     const resourceId = resourceIdentity(image.mimeType, sha256);
     if (image.resourceId !== undefined && image.resourceId !== resourceId)
         throw new MarAgentError('MAR_AGENT_SESSION_INPUT_INVALID', 'Image resource identity does not match its bytes.');
-    const existing = await resourceMetadata(directory, resourceId);
-    if (existing !== undefined)
-        return existing;
+    let existing;
+    try {
+        existing = await resourceMetadata(directory, resourceId);
+    }
+    catch (error) {
+        if (!(error instanceof MarAgentError) || error.code !== 'MAR_AGENT_IMAGE_UNAVAILABLE')
+            throw error;
+    }
     const resource = {
+        ...existing,
         resourceInputVersion: 1,
         resourceId,
         mimeType: image.mimeType,
@@ -79,7 +80,7 @@ export async function persistResource(directory, image) {
 export async function setResourceUrl(directory, resourceId, published) {
     const resource = await resourceMetadata(directory, resourceId);
     if (!resource)
-        throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Session image resource is missing.');
+        throw new MarAgentError('MAR_AGENT_IMAGE_UNAVAILABLE', 'Session image resource is missing.');
     if (resource.url !== undefined)
         return resource;
     if (!isModelImageUrl(published.url) ||
@@ -136,7 +137,7 @@ export async function copyResources(source, target, records) {
         const resourceId = file.slice(0, -4);
         const resource = await resourceMetadata(join(source, 'resources'), resourceId);
         if (resource === undefined)
-            throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Session image resource is missing.');
+            throw new MarAgentError('MAR_AGENT_IMAGE_UNAVAILABLE', 'Session image resource is missing.');
         const bytes = await readInputImageBytes(join(source, 'resources'), {
             ...resource,
             name: 'image',

package/dist/agent-core/session/tool-result-resources.js

@@ -1,6 +1,5 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { constants } from 'node:fs';
-import { lstat, mkdir, open, readdir, rename, rm, writeFile } from 'node:fs/promises';
+import { lstat, mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { MarAgentError } from '../error.js';
 import { parseToolResultExtensions } from '../tools/result-extensions.js';
@@ -79,12 +78,8 @@ async function bindToolResultResource(directory, record, resource, readRecord) {
     catch (error) {
         if (error.code !== 'EEXIST')
             throw error;
-        const handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
         try {
-            const info = await handle.stat();
-            if (!info.isFile() || info.size > 1024)
-                throw resourceError('CORRUPT', 'Invalid tool resource locator.');
-            const locator = JSON.parse(await handle.readFile('utf8'));
+            const locator = JSON.parse(await readFile(path, 'utf8'));
             const existing = locator.sequence === record.sequence && locator.recordId === record.recordId
                 ? record
                 : Number.isSafeInteger(locator.sequence)
@@ -98,9 +93,6 @@ async function bindToolResultResource(directory, record, resource, readRecord) {
         catch (cause) {
             throw normalizedResourceError(cause);
         }
-        finally {
-            await handle.close();
-        }
     }
 }
 export function toolResultResourceFiles(records) {
@@ -184,16 +176,7 @@ export async function readToolResultResource(directory, sessionId, input, readRe
     let locator;
     try {
         const file = join(directory, 'tool_results', `${input.resourceRef}.json`);
-        const handle = await open(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
-        try {
-            const info = await handle.stat();
-            if (!info.isFile() || info.size > 1024)
-                throw resourceError('CORRUPT', 'Invalid tool resource locator.');
-            locator = JSON.parse(await handle.readFile('utf8'));
-        }
-        finally {
-            await handle.close();
-        }
+        locator = JSON.parse(await readFile(file, 'utf8'));
     }
     catch (error) {
         throw normalizedResourceError(error);
@@ -208,6 +191,7 @@ export async function readToolResultResource(directory, sessionId, input, readRe
         : undefined;
     if (!resource)
         throw resourceError('NOT_FOUND', 'Tool resource is not part of this session history.');
+    const bytes = await readResourceBytes(directory, resource);
     let offset = 0;
     if (input.cursor !== undefined) {
         try {
@@ -219,7 +203,7 @@ export async function readToolResultResource(directory, sessionId, input, readRe
                 cursor.sha256 !== resource.sha256 ||
                 !Number.isSafeInteger(cursor.offset) ||
                 cursor.offset < 0 ||
-                cursor.offset >= resource.byteSize)
+                cursor.offset >= bytes.length)
                 throw new Error('cursor');
             offset = cursor.offset;
         }
@@ -227,7 +211,6 @@ export async function readToolResultResource(directory, sessionId, input, readRe
             throw resourceError('INPUT_INVALID', 'Invalid tool resource cursor.');
         }
     }
-    const bytes = await readResourceBytes(directory, resource);
     if (offset > 0 && (bytes[offset] & 0xc0) === 0x80)
         throw resourceError('INPUT_INVALID', 'Invalid tool resource cursor boundary.');
     let end = Math.min(bytes.length, offset + (input.maxBytes ?? 256 * 1024));
@@ -257,19 +240,7 @@ export async function readToolResultResource(directory, sessionId, input, readRe
 }
 async function readResourceBytes(directory, resource) {
     try {
-        const handle = await open(join(directory, 'tool_results', `${resource.resourceRef}.diff`), constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
-        try {
-            const stat = await handle.stat();
-            if (!stat.isFile() || stat.size !== resource.byteSize || stat.size > MAX_BYTES)
-                throw resourceError('CORRUPT', 'Tool resource size does not match its history.');
-            const bytes = await handle.readFile();
-            if (createHash('sha256').update(bytes).digest('hex') !== resource.sha256)
-                throw resourceError('CORRUPT', 'Tool resource checksum does not match its history.');
-            return bytes;
-        }
-        finally {
-            await handle.close();
-        }
+        return await readFile(join(directory, 'tool_results', `${resource.resourceRef}.diff`));
     }
     catch (error) {
         throw normalizedResourceError(error);

package/package.json

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