@myagentroam/agent 0.11.32 → 0.11.34

package/dist/agent-core/session/store/records.d.ts

@@ -1,23 +0,0 @@
-import type { SessionRecord } from './types.js';
-export interface HistoryPagePositions {
-    readonly signature: string;
-    readonly offsets: Map<number, number>;
-}
-export declare const MAX_SEGMENT_BYTES: number;
-/** Read only the prefix needed by discovery; never load the entire transcript. */
-export declare function readRecordsFromHead(path: string): AsyncGenerator<SessionRecord>;
-export declare function readRecords(path: string): Promise<SessionRecord[]>;
-/** Repair only the final record under the Session writer lock; never skip middle damage. */
-export declare function repairSegmentTail(path: string): Promise<void>;
-export declare function readRecordPageFromTail(path: string, beforeSequence: number, limit: number, positions: Map<string, HistoryPagePositions>): Promise<{
-    records: SessionRecord[];
-    hasEarlier: boolean;
-}>;
-/** Decode complete records newest-first, releasing the file as soon as a reader stops. */
-export declare function readRecordsFromTail(path: string, page?: {
-    readonly beforeSequence: number;
-    readonly limit: number;
-    readonly positions: Map<string, HistoryPagePositions>;
-}): AsyncGenerator<SessionRecord>;
-export declare function segmentNumberFromPath(path: string): number | undefined;
-export declare function appendRecordBytes(path: string, serialized: string, onWriteFailure: (error: unknown) => void): Promise<void>;

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

@@ -1,261 +0,0 @@
-import { open, readFile } from 'node:fs/promises';
-import { MarAgentError } from '../../error.js';
-export 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;
-/** Read only the prefix needed by discovery; never load the entire transcript. */
-export async function* readRecordsFromHead(path) {
-    const handle = await open(path, 'r');
-    try {
-        const { size } = await handle.stat();
-        let position = 0;
-        let pending = [];
-        while (position < size) {
-            const chunk = Buffer.allocUnsafe(Math.min(REVERSE_READ_CHUNK_BYTES, size - position));
-            const { bytesRead } = await handle.read(chunk, 0, Math.min(chunk.length, size - position), position);
-            if (bytesRead === 0)
-                break;
-            position += bytesRead;
-            const data = chunk.subarray(0, bytesRead);
-            let start = 0;
-            for (;;) {
-                const end = data.indexOf(0x0a, start);
-                if (end < 0)
-                    break;
-                const part = data.subarray(start, end);
-                const line = (pending.length === 0 ? part : Buffer.concat([...pending, part])).toString('utf8');
-                pending = [];
-                start = end + 1;
-                if (!line)
-                    continue;
-                let record;
-                try {
-                    record = JSON.parse(line);
-                }
-                catch (cause) {
-                    throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Session history is corrupt.', {
-                        cause
-                    });
-                }
-                yield record;
-            }
-            if (start < data.length)
-                pending.push(data.subarray(start));
-        }
-        if (pending.length > 0) {
-            let record;
-            try {
-                record = JSON.parse(Buffer.concat(pending).toString('utf8'));
-            }
-            catch {
-                return; // Readers ignore only an interrupted final line.
-            }
-            yield record;
-        }
-    }
-    finally {
-        await handle.close();
-    }
-}
-export async function readRecords(path) {
-    const value = await readFile(path, 'utf8');
-    const lines = value.split('\n');
-    if (lines.at(-1) === '')
-        lines.pop();
-    const records = [];
-    for (const [index, line] of lines.entries()) {
-        if (!line)
-            continue;
-        try {
-            records.push(JSON.parse(line));
-        }
-        catch (cause) {
-            if (index === lines.length - 1 && !value.endsWith('\n'))
-                break;
-            throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Session history is corrupt.', {
-                cause
-            });
-        }
-    }
-    return records;
-}
-/** Repair only the final record under the Session writer lock; never skip middle damage. */
-export async function repairSegmentTail(path) {
-    const data = await readFile(path);
-    if (data.length === 0 || data.at(-1) === 10)
-        return;
-    const boundary = data.lastIndexOf(10);
-    let complete = false;
-    try {
-        const record = JSON.parse(data.subarray(boundary + 1).toString('utf8'));
-        complete =
-            record?.schemaVersion === 1 &&
-                Number.isSafeInteger(record.sequence) &&
-                typeof record.sessionId === 'string' &&
-                typeof record.type === 'string';
-    }
-    catch {
-        // An interrupted final line is discarded before another record can be appended.
-    }
-    const handle = await open(path, 'r+');
-    try {
-        if (complete) {
-            const { bytesWritten } = await handle.write(Buffer.from('\n'), 0, 1, data.length);
-            if (bytesWritten !== 1)
-                throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Session tail repair is incomplete.');
-        }
-        else
-            await handle.truncate(boundary + 1);
-        await handle.sync();
-    }
-    finally {
-        await handle.close();
-    }
-}
-export async function readRecordPageFromTail(path, beforeSequence, limit, positions) {
-    const newestFirst = [];
-    for await (const record of readRecordsFromTail(path, { beforeSequence, limit, positions })) {
-        if (!(record.sequence < beforeSequence))
-            continue;
-        newestFirst.push(record);
-        if (newestFirst.length > limit)
-            break;
-    }
-    return {
-        records: newestFirst.slice(0, limit).reverse(),
-        hasEarlier: newestFirst.length > limit
-    };
-}
-/** Decode complete records newest-first, releasing the file as soon as a reader stops. */
-export async function* readRecordsFromTail(path, page) {
-    const handle = await open(path, 'r');
-    try {
-        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 = position !== size;
-        const decode = (line, allowInvalidFinalLine) => {
-            if (line.length === 0)
-                return undefined;
-            try {
-                return JSON.parse(line.toString('utf8'));
-            }
-            catch (cause) {
-                if (allowInvalidFinalLine)
-                    return undefined;
-                throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Session history is corrupt.', {
-                    cause
-                });
-            }
-        };
-        while (position > 0) {
-            const start = Math.max(0, position - REVERSE_READ_CHUNK_BYTES);
-            const chunk = Buffer.allocUnsafe(position - start);
-            let bytesRead = 0;
-            while (bytesRead < chunk.length) {
-                const result = await handle.read(chunk, bytesRead, chunk.length - bytesRead, start + bytesRead);
-                if (result.bytesRead === 0)
-                    break;
-                bytesRead += result.bytesRead;
-            }
-            const value = chunk.subarray(0, bytesRead);
-            if (!inspectedFileEnd) {
-                inspectedFileEnd = true;
-                invalidFinalLineMayBeIgnored = value.at(-1) !== 0x0a;
-            }
-            let lineEnd = value.length;
-            for (let index = value.length - 1; index >= 0; index--) {
-                if (value[index] !== 0x0a)
-                    continue;
-                const currentPart = value.subarray(index + 1, lineEnd);
-                const line = pendingLineParts.length === 0
-                    ? currentPart
-                    : Buffer.concat([currentPart, ...pendingLineParts.reverse()]);
-                const record = decode(line, invalidFinalLineMayBeIgnored);
-                invalidFinalLineMayBeIgnored = false;
-                pendingLineParts = [];
-                lineEnd = index;
-                if (record !== undefined) {
-                    remember(record, start + index + 1);
-                    yield record;
-                }
-            }
-            if (lineEnd > 0)
-                pendingLineParts.push(value.subarray(0, lineEnd));
-            position = start;
-        }
-        if (pendingLineParts.length > 0) {
-            const record = decode(Buffer.concat(pendingLineParts.reverse()), invalidFinalLineMayBeIgnored);
-            if (record !== undefined) {
-                remember(record, 0);
-                yield record;
-            }
-        }
-    }
-    finally {
-        await handle.close();
-    }
-}
-export function segmentNumberFromPath(path) {
-    const match = /events-(\d{6})\.jsonl$/.exec(path);
-    return match === null ? undefined : Number(match[1]);
-}
-export async function appendRecordBytes(path, serialized, onWriteFailure) {
-    const bytes = Buffer.from(serialized);
-    const handle = await open(path, 'a', 0o600);
-    let failure;
-    try {
-        let offset = 0;
-        while (offset < bytes.length) {
-            const { bytesWritten } = await handle.write(bytes, offset, bytes.length - offset);
-            if (bytesWritten === 0)
-                throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Session append is incomplete.');
-            offset += bytesWritten;
-        }
-        await handle.sync();
-    }
-    catch (error) {
-        failure = { error };
-    }
-    try {
-        await handle.close();
-    }
-    catch (error) {
-        failure ??= { error };
-    }
-    if (failure) {
-        // Opening/encoding failures cannot have appended bytes; write/sync/close failures can.
-        onWriteFailure(failure.error);
-        throw failure.error;
-    }
-}

package/dist/agent-core/session/store/resources.d.ts

@@ -1,26 +0,0 @@
-import { type ModelImage } from '../../model/image.js';
-import type { SessionRecord } from './types.js';
-export interface SessionResource {
-    readonly resourceInputVersion?: 1;
-    readonly resourceId: string;
-    readonly mimeType: string;
-    readonly byteSize: number;
-    readonly sha256: string;
-    readonly url?: string;
-    readonly urlExpiresAt?: number;
-}
-export declare function resourceMetadata(directory: string, resourceId: string): Promise<SessionResource | undefined>;
-export declare function persistResource(directory: string, image: ModelImage): Promise<SessionResource>;
-export declare function setResourceUrl(directory: string, resourceId: string, published: {
-    url: string;
-    urlExpiresAt: number;
-}): Promise<SessionResource>;
-export declare function readResource(directory: string, resourceId: string): Promise<{
-    mimeType: string;
-    dataBase64: string;
-} | undefined>;
-/** Resource identities are SDK-owned metadata, never interpreted as file paths. */
-export declare function resourceFiles(records: readonly SessionRecord[]): Set<string>;
-export declare function copyResources(source: string, target: string, records: readonly SessionRecord[]): Promise<void>;
-export declare function completeResources(directory: string, record: SessionRecord): Promise<void>;
-export declare function recoverResources(directory: string, readHistory: () => Promise<SessionRecord[]>): Promise<void>;

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

@@ -1,197 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
-import { basename, dirname, join } from 'node:path';
-import { MarAgentError } from '../../error.js';
-import { isModelImageUrl } from '../../model/image.js';
-import { readInputImageBytes } from './images.js';
-const idPattern = /^[a-f0-9]{64}$/u;
-const mimeTypes = new Set(['image/png', 'image/jpeg', 'image/gif', 'image/webp']);
-function resourceIdentity(mimeType, sha256) {
-    return createHash('sha256').update(mimeType).update('\0').update(sha256).digest('hex');
-}
-export async function resourceMetadata(directory, resourceId) {
-    if (!idPattern.test(resourceId))
-        return undefined;
-    try {
-        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 (cause) {
-        if (cause.code === 'ENOENT')
-            return undefined;
-        throw new MarAgentError('MAR_AGENT_IMAGE_UNAVAILABLE', 'Session image resource is unavailable.', {
-            cause
-        });
-    }
-}
-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_IMAGE_UNAVAILABLE', 'Session image resource is missing.');
-    }
-    const data = Buffer.from(image.dataBase64 ?? '', 'base64');
-    if (data.toString('base64') !== image.dataBase64)
-        throw new MarAgentError('MAR_AGENT_SESSION_INPUT_INVALID', 'Image resource data is not canonical base64.');
-    if (!mimeTypes.has(image.mimeType) || data.length === 0 || data.length > 20 * 1024 * 1024)
-        throw new MarAgentError('MAR_AGENT_HOST_LIMIT_EXCEEDED', 'Image resource exceeds supported limits.');
-    const sha256 = createHash('sha256').update(data).digest('hex');
-    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.');
-    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,
-        byteSize: data.length,
-        sha256
-    };
-    await mkdir(directory, { recursive: true, mode: 0o700 });
-    await writeFile(join(directory, `.${resourceId}.pending`), '', { mode: 0o600, flush: true });
-    await atomicWrite(join(directory, `${resourceId}.bin`), data);
-    await atomicWrite(join(directory, `${resourceId}.json`), JSON.stringify(resource));
-    return resource;
-}
-export async function setResourceUrl(directory, resourceId, published) {
-    const resource = await resourceMetadata(directory, resourceId);
-    if (!resource)
-        throw new MarAgentError('MAR_AGENT_IMAGE_UNAVAILABLE', 'Session image resource is missing.');
-    if (resource.url !== undefined)
-        return resource;
-    if (!isModelImageUrl(published.url) ||
-        !Number.isSafeInteger(published.urlExpiresAt) ||
-        published.urlExpiresAt <= 0)
-        throw new MarAgentError('MAR_AGENT_IMAGE_PUBLICATION_FAILED', 'Image URL publication failed.');
-    const result = { ...resource, url: published.url, urlExpiresAt: published.urlExpiresAt };
-    await atomicWrite(join(directory, `${resourceId}.json`), JSON.stringify(result));
-    return result;
-}
-export async function readResource(directory, resourceId) {
-    const resource = await resourceMetadata(directory, resourceId);
-    if (!resource)
-        return undefined;
-    const bytes = await readInputImageBytes(directory, {
-        ...resource,
-        name: 'image',
-        fileName: `${resourceId}.bin`
-    });
-    return { mimeType: resource.mimeType, dataBase64: bytes.toString('base64') };
-}
-/** Resource identities are SDK-owned metadata, never interpreted as file paths. */
-export function resourceFiles(records) {
-    const ids = new Set();
-    const visit = (value) => {
-        if (Array.isArray(value)) {
-            for (const item of value)
-                visit(item);
-            return;
-        }
-        if (!value || typeof value !== 'object')
-            return;
-        const item = value;
-        if (item.resourceInputVersion === 1 &&
-            typeof item.resourceId === 'string' &&
-            idPattern.test(item.resourceId))
-            ids.add(item.resourceId);
-        for (const key of ['images', 'input', 'pendingInputs', 'payload', 'retainedModelContext'])
-            if (item[key] !== undefined)
-                visit(item[key]);
-    };
-    for (const record of records)
-        visit(record.payload);
-    return new Set([...ids].flatMap((id) => [`${id}.bin`, `${id}.json`]));
-}
-export async function copyResources(source, target, records) {
-    const files = resourceFiles(records);
-    if (!files.size)
-        return;
-    await mkdir(join(target, 'resources'), { recursive: true, mode: 0o700 });
-    for (const file of files) {
-        if (!file.endsWith('.bin'))
-            continue;
-        const resourceId = file.slice(0, -4);
-        const resource = await resourceMetadata(join(source, 'resources'), resourceId);
-        if (resource === undefined)
-            throw new MarAgentError('MAR_AGENT_IMAGE_UNAVAILABLE', 'Session image resource is missing.');
-        const bytes = await readInputImageBytes(join(source, 'resources'), {
-            ...resource,
-            name: 'image',
-            fileName: file
-        });
-        await writeFile(join(target, 'resources', file), bytes, {
-            mode: 0o600,
-            flag: 'wx',
-            flush: true
-        });
-        await writeFile(join(target, 'resources', `${resourceId}.json`), JSON.stringify(resource), {
-            mode: 0o600,
-            flag: 'wx',
-            flush: true
-        });
-    }
-}
-export async function completeResources(directory, record) {
-    for (const file of resourceFiles([record]))
-        if (file.endsWith('.bin'))
-            await rm(join(directory, `.${file.slice(0, -4)}.pending`), { force: true });
-}
-export async function recoverResources(directory, readHistory) {
-    let names;
-    try {
-        names = await readdir(directory);
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return;
-        throw error;
-    }
-    const pending = names.filter((name) => /^\.[a-f0-9]{64}\.pending$/u.test(name));
-    if (pending.length) {
-        const retained = resourceFiles(await readHistory());
-        for (const name of pending) {
-            const id = name.slice(1, -8);
-            if (!retained.has(`${id}.bin`))
-                for (const suffix of ['bin', 'json'])
-                    await rm(join(directory, `${id}.${suffix}`), { force: true });
-            await rm(join(directory, name), { force: true });
-        }
-    }
-    for (const name of names)
-        if (/^\.[a-f0-9]{64}\.(?:bin|json)\.[a-f0-9-]{36}\.tmp$/u.test(name))
-            await rm(join(directory, name), { force: true });
-}
-async function atomicWrite(path, data) {
-    const temporary = join(dirname(path), `.${basename(path)}.${randomUUID()}.tmp`);
-    try {
-        await writeFile(temporary, data, { mode: 0o600, flag: 'wx', flush: true });
-        await rename(temporary, path);
-    }
-    finally {
-        await rm(temporary, { force: true });
-    }
-}

package/dist/agent-core/session/store/types.d.ts

@@ -1,82 +0,0 @@
-import type { ModelInputMetadata } from '../../model/contracts.js';
-import type { TodoSnapshot } from '../../tools/agent/todo.js';
-import type { SessionSource } from '../types.js';
-import type { ModelImage } from '../../model/image.js';
-export interface SessionRecord {
-    schemaVersion: 1;
-    recordId: string;
-    sequence: number;
-    timestamp: string;
-    sessionId: string;
-    executionId?: string;
-    turnId?: string;
-    type: string;
-    payload: unknown;
-}
-export interface SessionExecutionState {
-    automaticTitlePending: boolean;
-    todo: TodoSnapshot;
-    contextRecords: SessionRecord[];
-}
-export interface CompactUserInput {
-    content: string;
-    metadata?: ModelInputMetadata;
-}
-export interface CompactHistoryMessage extends CompactUserInput {
-    role: 'user';
-    kind: 'user_input' | 'extension_input' | 'summary';
-}
-export interface SessionInputImage extends ModelImage {
-    readonly name: string;
-}
-export interface SessionInputImageMetadata {
-    readonly resourceInputVersion?: 1;
-    readonly name: string;
-    readonly mimeType: string;
-    readonly byteSize: number;
-    readonly fileName: string;
-    readonly sha256: string;
-    readonly resourceId?: string;
-    readonly url?: string;
-    readonly urlExpiresAt?: number;
-}
-export interface RestoredSessionInputImage extends ModelImage {
-}
-export interface SessionInputImageData extends SessionInputImageMetadata {
-    readonly dataBase64: string;
-}
-export interface SessionMeta {
-    id: string;
-    title: string;
-    workspace: string;
-    createdAt: string;
-    lastActivityAt: string;
-    source?: SessionSource;
-    nextSequence: number;
-    automaticTitlePending?: boolean;
-    storageTransactionId?: string;
-    resume?: {
-        version: 1;
-        userTurns?: number;
-        compactSequence?: number;
-        todoSequence?: number;
-        todoRevision: number;
-        executionModelIndexed?: true;
-        firstUserMessageIndexed?: true;
-        firstUserMessagePreview?: string;
-        modelId?: string;
-        modelName?: string;
-        reasoningEffort?: string;
-    };
-    segments?: Array<{
-        number: number;
-        firstSequence: number;
-        lastSequence: number;
-        bytes: number;
-    }>;
-}
-export interface SessionIndex {
-    version: 1;
-    revision: number;
-    sessions: SessionMeta[];
-}

package/dist/agent-core/session/tool-result-resources.d.ts

@@ -1,26 +0,0 @@
-import { type AvailableToolResultResource } from '../tools/result-extensions.js';
-import type { SessionRecord } from './store/index.js';
-export interface ToolResultResourceInput {
-    resourceRef: string;
-    cursor?: string;
-    maxBytes?: number;
-}
-export interface ToolResultResourcePage {
-    type: 'file_changes';
-    version: 1;
-    format: 'unified-diff';
-    resourceRef: string;
-    byteSize: number;
-    sha256: string;
-    content: string;
-    nextCursor?: string;
-}
-export declare function writeToolResultResource(directory: string, text: string): Promise<AvailableToolResultResource>;
-export declare function recordToolResources(record: Pick<SessionRecord, 'type' | 'payload'>): AvailableToolResultResource[];
-/** A locator is only a hint: reads must verify its exact committed record identity. */
-export declare function bindToolResultResources(directory: string, record: SessionRecord, readRecord?: (sequence: number) => Promise<SessionRecord | undefined>, degrade?: boolean): Promise<void>;
-export declare function toolResultResourceFiles(records: readonly SessionRecord[]): Set<string>;
-export declare function copyToolResultResources(source: string, target: string, records: readonly SessionRecord[]): Promise<void>;
-export declare function completeToolResultResources(directory: string, record: SessionRecord): Promise<void>;
-export declare function cleanupUnreferencedToolResources(directory: string, readRecords: () => Promise<readonly SessionRecord[]>): Promise<void>;
-export declare function readToolResultResource(directory: string, sessionId: string, input: ToolResultResourceInput, readRecord: (sequence: number) => Promise<SessionRecord | undefined>): Promise<ToolResultResourcePage>;