@myagentroam/agent 0.10.58 → 0.10.60

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

@@ -0,0 +1,23 @@
+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): Promise<void>;

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

@@ -0,0 +1,249 @@
+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) {
+    const handle = await open(path, 'a', 0o600);
+    try {
+        const bytes = Buffer.from(serialized);
+        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();
+    }
+    finally {
+        await handle.close();
+    }
+}

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

@@ -0,0 +1,83 @@
+import type { ModelInputMetadata } from '../../model/contracts.js';
+import type { TodoSnapshot } from '../../tools/agent/todo.js';
+import type { SessionSource } from '../types.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 {
+    readonly name: string;
+    readonly mimeType: string;
+    readonly dataBase64: string;
+}
+export interface SessionInputImageMetadata {
+    readonly name: string;
+    readonly mimeType: string;
+    readonly byteSize: number;
+    readonly fileName: string;
+    readonly sha256: string;
+}
+export interface RestoredSessionInputImage {
+    readonly mimeType: string;
+    readonly dataBase64: string;
+}
+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;
+        compactSequence?: number;
+        gcSequence?: number;
+        gcGeneration?: number;
+        gcBaseSequence?: 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/store/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,5 +1,5 @@
 import { type AvailableToolResultResource } from '../tools/result-extensions.js';
-import type { SessionRecord } from './jsonl-store.js';
+import type { SessionRecord } from './store/index.js';
 export interface ToolResultResourceInput {
     resourceRef: string;
     cursor?: string;

package/dist/agent-core/subagent/session-controller.d.ts

@@ -3,7 +3,7 @@ import type { CoreOperationContext } from '../extensions/operation.js';
 import type { MarAgentReasoningEffort } from '../model/configuration.js';
 import type { ExecutionResult } from '../runtime/contracts.js';
 import type { MarAgentEvent } from '../runtime/events.js';
-import type { SessionRecord, SessionSource } from '../session/jsonl-store.js';
+import type { SessionRecord, SessionSource } from '../session/store/index.js';
 import type { SubagentManyOutput, SubagentManyOutputOptions } from './contracts.js';
 import type { SubagentController, SubagentMessageOptions, SubagentOutputOptions, SubagentRunOptions, SubagentTaskInput, SubagentTaskSnapshot } from './scheduler.js';
 export interface SubagentModelOption {

package/dist/agent-core/tools/code-mode/state.d.ts

@@ -5,5 +5,5 @@ type StateRecord = {
     readonly payload: unknown;
 };
 export declare function parseCodeModeStateMutations(value: unknown): CodeModeStateMutation[];
-export declare function restoreCodeModeState(records: readonly StateRecord[]): CodeModeStateEntry[];
+export declare function restoreCodeModeState(records: readonly StateRecord[], initialState?: CodeModeStateEntry[]): CodeModeStateEntry[];
 export declare function applyCodeModeStateMutations(entries: readonly CodeModeStateEntry[], mutations: readonly CodeModeStateMutation[]): CodeModeStateEntry[];

package/dist/agent-core/tools/code-mode/state.js

@@ -16,8 +16,8 @@ export function parseCodeModeStateMutations(value) {
         throw invalidState();
     });
 }
-export function restoreCodeModeState(records) {
-    let state = [];
+export function restoreCodeModeState(records, initialState = []) {
+    let state = initialState;
     for (const record of records) {
         if (record.type !== 'code.state.updated')
             continue;

package/package.json

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