@myagentroam/agent 0.11.55 → 0.11.57

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

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { lstat, mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { AgentError } from '../error.js';
 import { parseToolResultExtensions } from '../tools/result-extensions.js';
 const REF = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/u;
@@ -73,13 +73,8 @@ export async function bindToolResultResources(directory, record, readRecord, deg
 async function bindToolResultResource(directory, record, resource, readRecord) {
     const path = join(directory, 'tool_results', `${resource.resourceRef}.json`);
     try {
-        await writeFile(path, JSON.stringify({ sequence: record.sequence, recordId: record.recordId }), { flag: 'wx', mode: 0o600, flush: true });
-    }
-    catch (error) {
-        if (error.code !== 'EEXIST')
-            throw error;
-        try {
-            const locator = JSON.parse(await readFile(path, 'utf8'));
+        const locator = await readToolResourceLocator(path, resource.resourceRef);
+        if (locator !== undefined) {
             const existing = locator.sequence === record.sequence && locator.recordId === record.recordId
                 ? record
                 : Number.isSafeInteger(locator.sequence)
@@ -89,46 +84,103 @@ async function bindToolResultResource(directory, record, resource, readRecord) {
                 existing.recordId !== locator.recordId ||
                 !recordToolResources(existing).some((entry) => entry.resourceRef === resource.resourceRef && entry.sha256 === resource.sha256))
                 throw resourceError('CORRUPT', 'Tool resource locator conflicts with committed history.');
+            return;
         }
-        catch (cause) {
+    }
+    catch (cause) {
+        if (cause.code !== 'ENOENT')
             throw normalizedResourceError(cause);
-        }
     }
+    await writeFile(path, JSON.stringify({ sequence: record.sequence, recordId: record.recordId }), {
+        flag: 'wx',
+        mode: 0o600,
+        flush: true
+    });
 }
 export function toolResultResourceFiles(records) {
-    return new Set(records.flatMap((record) => recordToolResources(record).flatMap((resource) => [
+    const files = new Set(records.flatMap((record) => recordToolResources(record).flatMap((resource) => [
         `${resource.resourceRef}.diff`,
         `${resource.resourceRef}.json`
     ])));
+    if (files.size > 0)
+        files.add('index.json');
+    return files;
 }
-export async function copyToolResultResources(source, target, records) {
-    const copied = new Set();
+export async function prepareToolResultResources(source, records) {
+    const resources = new Map();
     for (const record of records) {
         for (const resource of recordToolResources(record)) {
-            if (copied.has(resource.resourceRef))
-                continue;
-            copied.add(resource.resourceRef);
+            const previous = resources.get(resource.resourceRef);
+            if (previous && previous.resource.sha256 !== resource.sha256)
+                throw resourceError('CORRUPT', 'Tool resource locator conflicts with committed history.');
+            if (!previous)
+                resources.set(resource.resourceRef, { record, resource });
+        }
+    }
+    const bodies = new Map();
+    if (resources.size === 0)
+        return bodies;
+    const bySequence = new Map(records.map((record) => [record.sequence, record]));
+    const pending = resources.values();
+    let failure;
+    const read = async () => {
+        while (!failure) {
+            const next = pending.next();
+            if (next.done)
+                return;
+            const { record, resource } = next.value;
             try {
-                const bytes = await readResourceBytes(source, resource);
-                const directory = join(target, 'tool_results');
-                await mkdir(directory, { recursive: true, mode: 0o700 });
-                await writeFile(join(directory, `${resource.resourceRef}.diff`), bytes, {
-                    flag: 'wx',
-                    mode: 0o600,
-                    flush: true
-                });
+                const bytes = await readResourceBytes(source, resource, async (sequence) => bySequence.get(sequence));
+                bodies.set(resource.resourceRef, { owner: record.recordId, bytes });
             }
             catch (error) {
-                if (error instanceof AgentError && error.code === 'MAR_AGENT_TOOL_RESOURCE_NOT_FOUND')
-                    continue;
-                throw error;
+                if (!(error instanceof AgentError && error.code === 'MAR_AGENT_TOOL_RESOURCE_NOT_FOUND'))
+                    failure ??= { error };
             }
         }
-        if (recordToolResources(record).length) {
-            await mkdir(join(target, 'tool_results'), { recursive: true, mode: 0o700 });
-            await bindToolResultResources(target, record, async (sequence) => records.find((item) => item.sequence === sequence));
-        }
+    };
+    await Promise.all(Array.from({ length: Math.min(8, resources.size) }, read));
+    if (failure)
+        throw failure.error;
+    return bodies;
+}
+export async function writeToolResultResourceIndex(target, locators) {
+    if (locators.size === 0)
+        return;
+    const directory = join(target, 'tool_results');
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    await writeFile(join(directory, 'index.json'), JSON.stringify({ version: 1, locators: Object.fromEntries(locators) }), {
+        flag: 'wx',
+        mode: 0o600,
+        flush: true
+    });
+}
+async function readToolResourceLocator(path, resourceRef) {
+    let text;
+    try {
+        text = await readFile(path, 'utf8');
     }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        text = await readFile(join(dirname(path), 'index.json'), 'utf8');
+    }
+    const value = JSON.parse(text);
+    const locator = value?.version === 1 ? value.locators?.[resourceRef] : value;
+    if (value?.version === 1 && locator === undefined)
+        return undefined;
+    if (!Number.isSafeInteger(locator?.sequence) ||
+        locator.sequence < 1 ||
+        typeof locator.recordId !== 'string')
+        throw resourceError('CORRUPT', 'Invalid tool resource locator.');
+    if (locator.bodySequences !== undefined &&
+        (!Array.isArray(locator.bodySequences) ||
+            locator.bodySequences.length === 0 ||
+            !locator.bodySequences.every((sequence) => Number.isSafeInteger(sequence) &&
+                sequence > 0 &&
+                sequence < locator.sequence)))
+        throw resourceError('CORRUPT', 'Invalid tool resource body locator.');
+    return locator;
 }
 export async function completeToolResultResources(directory, record) {
     await Promise.all(recordToolResources(record).map((resource) => rm(join(directory, 'tool_results', `.${resource.resourceRef}.pending`), {
@@ -177,22 +229,20 @@ export async function readToolResultResource(directory, sessionId, input, readRe
     let locator;
     try {
         const file = join(directory, 'tool_results', `${input.resourceRef}.json`);
-        locator = JSON.parse(await readFile(file, 'utf8'));
+        locator = await readToolResourceLocator(file, input.resourceRef);
     }
     catch (error) {
         throw normalizedResourceError(error);
     }
-    if (!Number.isSafeInteger(locator.sequence) ||
-        locator.sequence < 1 ||
-        typeof locator.recordId !== 'string')
-        throw resourceError('CORRUPT', 'Invalid tool resource locator.');
+    if (locator === undefined)
+        throw resourceError('NOT_FOUND', 'Tool resource is unavailable.');
     const record = await readRecord(locator.sequence);
     const resource = record?.recordId === locator.recordId
         ? recordToolResources(record).find((entry) => entry.resourceRef === input.resourceRef)
         : undefined;
     if (!resource)
         throw resourceError('NOT_FOUND', 'Tool resource is not part of this session history.');
-    const bytes = await readResourceBytes(directory, resource);
+    const bytes = await readResourceBytes(directory, resource, readRecord, locator);
     let offset = 0;
     if (input.cursor !== undefined) {
         try {
@@ -237,10 +287,31 @@ export async function readToolResultResource(directory, sessionId, input, readRe
             : {})
     };
 }
-async function readResourceBytes(directory, resource) {
+async function readResourceBytes(directory, resource, readRecord, knownLocator) {
     try {
         return await readFile(join(directory, 'tool_results', `${resource.resourceRef}.diff`));
     }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw normalizedResourceError(error);
+    }
+    try {
+        const locator = knownLocator ??
+            (await readToolResourceLocator(join(directory, 'tool_results', `${resource.resourceRef}.json`), resource.resourceRef));
+        if (!locator?.bodySequences || !readRecord)
+            throw resourceError('NOT_FOUND', 'Tool resource is unavailable.');
+        const chunks = [];
+        for (const sequence of locator.bodySequences) {
+            const record = await readRecord(sequence);
+            const payload = record?.payload;
+            if (record?.type !== 'tool.resource' ||
+                payload?.resourceRef !== resource.resourceRef ||
+                typeof payload.dataBase64 !== 'string')
+                throw resourceError('CORRUPT', 'Invalid tool resource body.');
+            chunks.push(Buffer.from(payload.dataBase64, 'base64'));
+        }
+        return Buffer.concat(chunks);
+    }
     catch (error) {
         throw normalizedResourceError(error);
     }

package/package.json

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