@myagentroam/agent 0.11.34 → 0.11.35

package/dist/session/store/jsonl/fork-session.d.ts

@@ -0,0 +1,19 @@
+import type { SessionMeta, SessionRecord } from '../types.js';
+export declare function forkSessionOperation(source: SessionMeta, records: readonly SessionRecord[], input: {
+    readonly boundaryTurnId: string | null;
+    readonly title: string;
+}, sourceRoot: string, sourceDirectory: string, owner: {
+    begin(target: SessionMeta): Promise<{
+        directory: string;
+        release(): Promise<void>;
+    }>;
+    publish(target: SessionMeta, copied: readonly SessionRecord[]): Promise<void>;
+    reject(target: SessionMeta, error: unknown): Promise<boolean>;
+}): Promise<{
+    id: string;
+    title: string;
+    workspace: string;
+    createdAt: string;
+    lastActivityAt: string;
+    source: import("../index.js").SessionSource | undefined;
+}>;

package/dist/session/store/jsonl/fork-session.js

@@ -0,0 +1,142 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, rename, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { AgentError } from '../../../error.js';
+import { inlineMediaHistory } from '../../inline-media.js';
+import { copyToolResultResources } from '../../tool-result-resources.js';
+import { syncJsonlDirectory } from './fs-durability.js';
+import { forkedPayload, stageSessionSegments } from './history.js';
+import { copyGeneratedImages, generatedImageFileNames } from './images.js';
+import { sessionDirectoryExists } from './open-recovery.js';
+import { copyResources } from './resources.js';
+export async function forkSessionOperation(source, records, input, sourceRoot, sourceDirectory, owner) {
+    const sourceSessionId = source.id;
+    const boundaryIndex = input.boundaryTurnId === null
+        ? -1
+        : records.findLastIndex((record) => record.turnId === input.boundaryTurnId);
+    if (input.boundaryTurnId !== null && boundaryIndex < 0)
+        throw new AgentError('MAR_AGENT_REWIND_TARGET_INVALID', 'Session rewind target was not found.');
+    const createdAt = new Date().toISOString();
+    const targetId = randomUUID();
+    const generation = randomUUID();
+    const target = {
+        id: targetId,
+        title: input.title,
+        workspace: source.workspace,
+        createdAt,
+        lastActivityAt: createdAt,
+        source: { type: 'user' },
+        storage: { encoding: 2, generation },
+        nextSequence: 1,
+        automaticTitlePending: false,
+        resume: {
+            version: 1,
+            userTurns: 0,
+            todoRevision: 0,
+            executionModelIndexed: true,
+            firstUserMessageIndexed: true
+        },
+        segments: []
+    };
+    const publication = await owner.begin(target);
+    const targetDirectory = join(publication.directory, 'v2', generation);
+    let discard = false;
+    let failed = false;
+    try {
+        await mkdir(join(publication.directory, 'v2'), { mode: 0o700 });
+        await mkdir(targetDirectory, { mode: 0o700 });
+        await syncJsonlDirectory(join(publication.directory, 'v2'));
+        await syncJsonlDirectory(publication.directory);
+        const copied = [
+            {
+                recordId: randomUUID(),
+                sequence: 1,
+                timestamp: createdAt,
+                sessionId: target.id,
+                type: 'session.created',
+                payload: {
+                    title: target.title,
+                    workspace: target.workspace,
+                    automaticTitle: false,
+                    source: target.source
+                }
+            }
+        ];
+        const retained = input.boundaryTurnId === null ? [] : records.slice(1, boundaryIndex + 1);
+        const inlineState = inlineMediaHistory(retained).state;
+        const stateAnchor = inlineState &&
+            retained.findLast((record) => record.type === 'resource.window' || record.type === 'compact.completed');
+        const forkIdentities = new Map();
+        for (const record of retained) {
+            if (record.type === 'context.gc.completed' || record.type === 'responses.continuation')
+                continue;
+            const identity = { recordId: randomUUID(), sequence: copied.length + 1 };
+            forkIdentities.set(record.recordId, identity);
+            copied.push({
+                ...identity,
+                sessionId: target.id,
+                type: record.type,
+                payload: forkedPayload(record.type, record === stateAnchor
+                    ? record.type === 'resource.window'
+                        ? inlineState
+                        : {
+                            ...record.payload,
+                            inlineMediaState: inlineState
+                        }
+                    : record.payload, sourceSessionId, target.id, input.title, forkIdentities),
+                ...(record.executionId === undefined ? {} : { executionId: record.executionId }),
+                ...(record.turnId === undefined ? {} : { turnId: record.turnId }),
+                timestamp: record.timestamp
+            });
+        }
+        // A fork is unpublished until every segment and referenced image is durable.
+        const staged = await stageSessionSegments(targetDirectory, copied, 'fork');
+        for (const file of staged.files)
+            await rename(file.temporaryPath, file.path);
+        target.segments = staged.segments;
+        target.nextSequence = copied.length + 1;
+        await copyToolResultResources(sourceDirectory, targetDirectory, copied);
+        await copyGeneratedImages(sourceRoot, publication.directory, generatedImageFileNames(retained));
+        await copyResources(sourceDirectory, targetDirectory, retained);
+        for (const path of [
+            join(targetDirectory, 'resources'),
+            join(targetDirectory, 'tool_results'),
+            join(publication.directory, 'generated_images')
+        ])
+            if (await sessionDirectoryExists(path))
+                await syncJsonlDirectory(path);
+        await syncJsonlDirectory(targetDirectory);
+        await syncJsonlDirectory(publication.directory);
+        target.lastActivityAt = target.createdAt;
+        await owner.publish(target, copied);
+        await rm(join(publication.directory, 'publication-pending'), { force: true });
+        return {
+            id: target.id,
+            title: target.title,
+            workspace: target.workspace,
+            createdAt: target.createdAt,
+            lastActivityAt: target.createdAt,
+            source: target.source
+        };
+    }
+    catch (error) {
+        failed = true;
+        discard = await owner.reject(target, error).catch(() => false);
+        throw error;
+    }
+    finally {
+        const cleanup = async () => {
+            try {
+                await publication.release();
+            }
+            finally {
+                if (discard)
+                    await rm(publication.directory, { recursive: true, force: true });
+            }
+        };
+        if (failed)
+            await cleanup().catch(() => undefined);
+        else
+            await cleanup();
+    }
+}

package/dist/session/store/jsonl/jsonl-migration.js

@@ -28,7 +28,7 @@ export async function prepareJsonlV2Generation(input) {
             if (!line)
                 continue;
             const record = decodeJsonlRecord(line, 1);
-            if (record.sessionId !== input.sessionId || record.sequence <= lastSequence)
+            if (record.sessionId !== input.sessionId)
                 throw corruptHistory();
             firstSequence ??= record.sequence;
             lastSequence = record.sequence;

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

@@ -1,6 +1,5 @@
 import { randomUUID } from 'node:crypto';
 import { rollbackBoundaryIndex } from '../../rollback.js';
-import { inlineMediaHistory } from '../../inline-media.js';
 import { lstat, mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
@@ -11,7 +10,7 @@ import { acquireFileLock } from '../../../storage/file-lock.js';
 import { todoItemsFromSnapshot } from '../../todo.js';
 import { applyCodeModeStateMutations, parseCodeModeStateMutations, restoreCodeModeState } from '../../code-state.js';
 import { contextGcBaseFromRecords, contextGcCheckpointIntervalEligible, latestValidContextGcCheckpoint, normalizeContextGcReplacements, sameContextGcBase, validateContextGcCheckpoint } from '../../context-gc-checkpoint.js';
-import { copyToolResultResources, recordToolResources, readToolResultResource, writeToolResultResource } from '../../tool-result-resources.js';
+import { recordToolResources, readToolResultResource, writeToolResultResource } from '../../tool-result-resources.js';
 import { beginTreeDeleteTransaction, finishTreeDelete, finishTreeDeletePreparation, readTreeDeleteTransaction, recoverSessionStorageTransaction, stageTreeDelete } from './transaction-recovery.js';
 import { extensionCheckpointFromPayload, indexExtensionCheckpoint, restoreExtensionCheckpoint, updateSessionCurrentState } from '../current-state.js';
 import { decodeSessionListCursor, encodeSessionListCursor, mergeSessionDerivedCache, normalizeSessionSource, persistFormatSelection, readSessionIndex, restoreSessionIndexMeta, sessionListFilter, sessionMatchesFilter, sessionTreeIds, upgradeSessionIndex } from './directory-index.js';
@@ -20,9 +19,9 @@ import { prepareJsonlV2Generation } from './jsonl-migration.js';
 import { syncJsonlDirectory } from './fs-durability.js';
 import { withSessionReadDrain, withSessionReadPin } from './read-pins.js';
 import { deriveExecutionState, executionModelFromRecord, isCompactCheckpoint, isNativeUserTurn, sameResumeIndex, userMessagePreviewFromRecord } from '../execution-state.js';
-import { forkedPayload, stageSessionSegments } from './history.js';
-import { MAX_INPUT_IMAGES, copyGeneratedImages, generatedImageFileNames, inputImageReference, inputImageReferences, readInputImageBytes } from './images.js';
-import { persistResource, setResourceUrl, readResource, copyResources, resourceFiles } from './resources.js';
+import { forkSessionOperation } from './fork-session.js';
+import { MAX_INPUT_IMAGES, inputImageReference, inputImageReferences, readInputImageBytes } from './images.js';
+import { persistResource, setResourceUrl, readResource, resourceFiles } from './resources.js';
 import { CONTEXTUAL_WORLD_STATE_FILE, openJsonlIndex, reclaimUnpublishedSessions, recoverContextualWorldStateTransactions, recoverJsonlTail, sessionDirectoryExists } from './open-recovery.js';
 import { JsonlStorePool } from './store-pool.js';
 import { acquireTreeMaintenance } from './tree-maintenance.js';
@@ -606,6 +605,7 @@ export class JsonlSessionStore {
                 throw new AgentError('MAR_AGENT_SESSION_LOCKED', 'Session already has a writer.');
             const sourceRoot = join(this.#shared.root, 'sessions', sourceSessionId);
             const release = await acquireFileLock(join(sourceRoot, 'lock'));
+            let sourceFailed = false;
             try {
                 await this.#refreshIndex();
                 const source = this.#shared.index.sessions.find((item) => item.id === sourceSessionId);
@@ -615,163 +615,76 @@ export class JsonlSessionStore {
                     await preflightV1Session(sourceRoot);
                 await this.#ensureRootV2();
                 const records = await this.#readRecords(sourceSessionId);
-                const boundaryIndex = input.boundaryTurnId === null
-                    ? -1
-                    : records.findLastIndex((record) => record.turnId === input.boundaryTurnId);
-                if (input.boundaryTurnId !== null && boundaryIndex < 0)
-                    throw new AgentError('MAR_AGENT_REWIND_TARGET_INVALID', 'Session rewind target was not found.');
-                const createdAt = new Date().toISOString();
-                const target = {
-                    id: randomUUID(),
-                    title: input.title,
-                    workspace: source.workspace,
-                    createdAt,
-                    lastActivityAt: createdAt,
-                    source: { type: 'user' },
-                    storage: { encoding: 2, generation: randomUUID() },
-                    nextSequence: 1,
-                    automaticTitlePending: false,
-                    resume: {
-                        version: 1,
-                        userTurns: 0,
-                        todoRevision: 0,
-                        executionModelIndexed: true,
-                        firstUserMessageIndexed: true
+                let publicationConfirmed = false;
+                return await forkSessionOperation(source, records, input, sourceRoot, this.#sessionDirectory(sourceSessionId), {
+                    begin: async (target) => {
+                        const publication = await this.#beginUnpublishedSession(target.id);
+                        this.#shared.segments.set(target.id, 1);
+                        this.#shared.pendingSessions.set(target.id, target);
+                        return publication;
                     },
-                    segments: []
-                };
-                const publication = await this.#beginUnpublishedSession(target.id);
-                this.#shared.segments.set(target.id, 1);
-                this.#shared.pendingSessions.set(target.id, target);
-                let discard = false;
-                try {
-                    await mkdir(join(publication.directory, 'v2'), { mode: 0o700 });
-                    await mkdir(this.#sessionDirectory(target.id), { mode: 0o700 });
-                    await syncJsonlDirectory(join(publication.directory, 'v2'));
-                    await syncJsonlDirectory(publication.directory);
-                    const copied = [
-                        {
-                            recordId: randomUUID(),
-                            sequence: 1,
-                            timestamp: createdAt,
-                            sessionId: target.id,
-                            type: 'session.created',
-                            payload: {
-                                title: target.title,
-                                workspace: target.workspace,
-                                automaticTitle: false,
-                                source: target.source
-                            }
+                    publish: async (target, copied) => {
+                        this.#shared.segments.set(target.id, target.segments.length);
+                        for (const record of copied)
+                            this.#applyRecordToResumeIndex(target, record);
+                        this.#shared.pendingSessions.delete(target.id);
+                        this.#shared.index = {
+                            version: 2,
+                            revision: this.#shared.index.revision + 1,
+                            sessions: [target, ...this.#shared.index.sessions]
+                        };
+                        this.#shared.pendingPublishIds.add(target.id);
+                        this.#markIndexDirty(target.id);
+                        try {
+                            await this.#saveIndex(undefined, [target.id], () => {
+                                publicationConfirmed = true;
+                            });
                         }
-                    ];
-                    const retained = input.boundaryTurnId === null ? [] : records.slice(1, boundaryIndex + 1);
-                    const inlineState = inlineMediaHistory(retained).state;
-                    const stateAnchor = inlineState &&
-                        retained.findLast((record) => record.type === 'resource.window' || record.type === 'compact.completed');
-                    const forkIdentities = new Map();
-                    for (const record of retained) {
-                        if (record.type === 'context.gc.completed' || record.type === 'responses.continuation')
-                            continue;
-                        const identity = { recordId: randomUUID(), sequence: copied.length + 1 };
-                        forkIdentities.set(record.recordId, identity);
-                        copied.push({
-                            ...identity,
-                            sessionId: target.id,
-                            type: record.type,
-                            payload: forkedPayload(record.type, record === stateAnchor
-                                ? record.type === 'resource.window'
-                                    ? inlineState
-                                    : {
-                                        ...record.payload,
-                                        inlineMediaState: inlineState
-                                    }
-                                : record.payload, sourceSessionId, target.id, input.title, forkIdentities),
-                            ...(record.executionId === undefined ? {} : { executionId: record.executionId }),
-                            ...(record.turnId === undefined ? {} : { turnId: record.turnId }),
-                            timestamp: record.timestamp
-                        });
-                    }
-                    // A fork is unpublished until every segment and referenced image is durable.
-                    const staged = await stageSessionSegments(this.#sessionDirectory(target.id), copied, 'fork');
-                    for (const file of staged.files)
-                        await rename(file.temporaryPath, file.path);
-                    target.segments = staged.segments;
-                    target.nextSequence = copied.length + 1;
-                    this.#shared.segments.set(target.id, staged.segments.length);
-                    for (const record of copied)
-                        this.#applyRecordToResumeIndex(target, record);
-                    await copyToolResultResources(this.#sessionDirectory(sourceSessionId), this.#sessionDirectory(target.id), copied);
-                    await copyGeneratedImages(sourceRoot, publication.directory, generatedImageFileNames(retained));
-                    await copyResources(this.#sessionDirectory(sourceSessionId), this.#sessionDirectory(target.id), retained);
-                    for (const path of [
-                        join(this.#sessionDirectory(target.id), 'resources'),
-                        join(this.#sessionDirectory(target.id), 'tool_results'),
-                        join(this.#sessionRoot(target.id), 'generated_images')
-                    ])
-                        if (await sessionDirectoryExists(path))
-                            await syncJsonlDirectory(path);
-                    await syncJsonlDirectory(this.#sessionDirectory(target.id));
-                    await syncJsonlDirectory(this.#sessionRoot(target.id));
-                    target.lastActivityAt = target.createdAt;
-                    this.#shared.pendingSessions.delete(target.id);
-                    this.#shared.index = {
-                        version: 2,
-                        revision: this.#shared.index.revision + 1,
-                        sessions: [target, ...this.#shared.index.sessions]
-                    };
-                    this.#shared.pendingPublishIds.add(target.id);
-                    this.#markIndexDirty(target.id);
-                    let persisted = false;
-                    try {
-                        await this.#saveIndex(undefined, [target.id], () => {
-                            persisted = true;
-                        });
-                    }
-                    catch (error) {
-                        if (!persisted)
-                            throw error;
-                    }
-                    await rm(join(publication.directory, 'publication-pending'), { force: true });
-                    return {
-                        id: target.id,
-                        title: target.title,
-                        workspace: target.workspace,
-                        createdAt: target.createdAt,
-                        lastActivityAt: target.createdAt,
-                        source: target.source
-                    };
-                }
-                catch (error) {
-                    this.#shared.pendingSessions.delete(target.id);
-                    const disk = await readSessionIndex(join(this.#shared.root, 'sessions', 'index.json'));
-                    if (disk?.sessions.some((session) => session.id === target.id)) {
-                        this.#shared.migrationFailures.set(target.id, { error, unreadable: true });
-                        throw error;
-                    }
-                    const publishedIndex = this.#shared.index.sessions.findIndex((item) => item.id === target.id);
-                    if (publishedIndex >= 0) {
-                        this.#shared.index.sessions.splice(publishedIndex, 1);
-                        this.#shared.index.revision++;
-                        this.#shared.pendingPublishIds.delete(target.id);
-                        this.#shared.dirtySessionVersions.delete(target.id);
-                        this.#shared.indexDirty = this.#shared.dirtySessionVersions.size > 0;
-                    }
-                    this.#shared.segments.delete(target.id);
-                    discard = true;
-                    throw error;
-                }
-                finally {
-                    try {
-                        await publication.release();
-                    }
-                    finally {
-                        if (discard)
-                            await rm(publication.directory, { recursive: true, force: true });
+                        catch (error) {
+                            if (!publicationConfirmed)
+                                throw error;
+                        }
+                    },
+                    reject: async (target, error) => {
+                        this.#shared.pendingSessions.delete(target.id);
+                        if (publicationConfirmed) {
+                            this.#shared.migrationFailures.set(target.id, { error, unreadable: true });
+                            return false;
+                        }
+                        let disk;
+                        try {
+                            disk = await readSessionIndex(join(this.#shared.root, 'sessions', 'index.json'));
+                        }
+                        catch {
+                            this.#shared.migrationFailures.set(target.id, { error, unreadable: true });
+                            return false;
+                        }
+                        if (!disk || disk.sessions.some((session) => session.id === target.id)) {
+                            this.#shared.migrationFailures.set(target.id, { error, unreadable: true });
+                            return false;
+                        }
+                        const publishedIndex = this.#shared.index.sessions.findIndex((item) => item.id === target.id);
+                        if (publishedIndex >= 0) {
+                            this.#shared.index.sessions.splice(publishedIndex, 1);
+                            this.#shared.index.revision++;
+                            this.#shared.pendingPublishIds.delete(target.id);
+                            this.#shared.dirtySessionVersions.delete(target.id);
+                            this.#shared.indexDirty = this.#shared.dirtySessionVersions.size > 0;
+                        }
+                        this.#shared.segments.delete(target.id);
+                        return true;
                     }
-                }
+                });
+            }
+            catch (error) {
+                sourceFailed = true;
+                throw error;
             }
             finally {
-                await release();
+                if (sourceFailed)
+                    await release().catch(() => undefined);
+                else
+                    await release();
             }
         });
     }

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

@@ -1,69 +1,9 @@
 import { type ToolWaitInterrupt } from '../runtime/wait.js';
-import type { AgentReasoningEffort } from '../model/configuration.js';
-import type { ExecutionResult } from '../runtime/contracts.js';
-import type { AgentEvent } from '../runtime/events.js';
 import type { SessionSource } from '../session/types.js';
 import type { SubagentManyOutput, SubagentManyOutputOptions } from './contracts.js';
 import type { SubagentController, SubagentMessageOptions, SubagentOutputOptions, SubagentRunOptions, SubagentTaskInput, SubagentTaskSnapshot } from './contracts.js';
-export interface SubagentModelOption {
-    readonly id: string;
-    readonly name: string;
-    readonly conversationModel?: boolean;
-    readonly reasoningEfforts: readonly AgentReasoningEffort[];
-    readonly defaultReasoningEffort: AgentReasoningEffort;
-}
-export interface SubagentTurnHandle extends AsyncIterable<AgentEvent> {
-    readonly executionId: string;
-    readonly turnId: string;
-    /** True only after the child terminal event was durably appended. */
-    readonly persistedEvents?: boolean;
-    result(): Promise<ExecutionResult>;
-    cancel(): void;
-    enqueueMessage(message: string, delivery?: SubagentMessageDelivery): boolean;
-}
-/** Caller-owned correlation is opaque to Subagent; the adapter restores it at delivery. */
-export interface SubagentOrigin {
-    readonly signal: AbortSignal;
-    readonly correlation: unknown;
-}
-export interface SubagentMessageDelivery {
-    readonly messageId: string;
-    readonly origin?: SubagentOrigin;
-    readonly signal?: AbortSignal;
-    applied(): void;
-    settled?(status: 'cancelled' | 'failed'): void;
-}
-export interface SubagentMailboxMessage {
-    readonly text: string;
-    readonly delivery?: SubagentMessageDelivery;
-}
-export interface SubagentParentExecution {
-    readonly executionId: string;
-    readonly modelId: string;
-    readonly reasoningEffort: AgentReasoningEffort;
-    readonly models: ReadonlyMap<string, SubagentModelOption>;
-    emitTerminal(snapshot: SubagentTaskSnapshot): Promise<void>;
-    startTurn(input: {
-        readonly sessionId: string;
-        readonly prompt: string;
-        readonly modelId: string;
-        readonly reasoningEffort: AgentReasoningEffort;
-        readonly role: SubagentTaskInput['role'];
-        readonly initialMailbox: readonly SubagentMailboxMessage[];
-        readonly turnId: string;
-        readonly delivery?: SubagentMessageDelivery;
-        readonly origin?: SubagentOrigin;
-    }): Promise<SubagentTurnHandle>;
-}
-/** A native operation has its own provenance even when no parent Execution is active. */
-export interface SubagentParentOperation extends Omit<SubagentParentExecution, 'executionId'> {
-    readonly operationId: string;
-    readonly executionId?: string;
-    readonly ownerInstanceId?: string;
-    readonly extensionId?: string;
-    readonly signal: AbortSignal;
-    readonly origin?: SubagentOrigin;
-}
+import type { SubagentParentExecution, SubagentParentOperation } from './turn-contracts.js';
+export type { SubagentModelOption, SubagentTurnHandle, SubagentOrigin, SubagentMessageDelivery, SubagentMailboxMessage, SubagentParentExecution, SubagentParentOperation } from './turn-contracts.js';
 interface SubagentHistoryRecord {
     readonly type: string;
     readonly payload: unknown;
@@ -145,4 +85,3 @@ export declare class SubagentSessionController implements SubagentController {
     }[];
     dispose(): Promise<void>;
 }
-export {};