@myagentroam/node 0.9.4 → 0.9.6

package/dist/runner/opencode-runner.js

@@ -5,6 +5,7 @@ import { AbstractRunner } from './abstract-runner.js';
 import { isWithinWorkspace } from './codex/conversation-parser.js';
 import { createHash } from 'node:crypto';
 import { openCodeConversationPage } from './opencode/conversation-parser.js';
+import { nodeLog } from '../operational.js';
 const PROFILE_ENTRY_TTL_MS = 30 * 60_000;
 export class OpenCodeRunner extends AbstractRunner {
     client;
@@ -14,6 +15,8 @@ export class OpenCodeRunner extends AbstractRunner {
     modelsByWorkspace = new Map();
     contextLimitsByWorkspace = new Map();
     profileTimersByWorkspace = new Map();
+    profileCache = new Map();
+    profileRefreshes = new Map();
     execution = new Map();
     managedTurns = new Map();
     environmentClients = new Map();
@@ -35,25 +38,79 @@ export class OpenCodeRunner extends AbstractRunner {
         if (capabilities.openCode?.available !== true || workspace === undefined) {
             return this.profile(capabilities);
         }
+        const cacheKey = this.profileCacheKey(workspace.path, environment);
+        const now = Date.now();
+        for (const [key, entry] of this.profileCache)
+            if (entry.expiresAt <= now)
+                this.profileCache.delete(key);
+        const cached = this.profileCache.get(cacheKey);
+        if (cached !== undefined) {
+            nodeLog('runner.opencode.profile.cache-hit', {
+                workspaceId: workspace.id,
+                models: cached.models.length,
+                remainingTtlMs: cached.expiresAt - now
+            });
+            this.modelsByWorkspace.set(workspace.path, cached.models);
+            this.contextLimitsByWorkspace.set(workspace.path, cached.contextLimits);
+            this.scheduleProfileExpiry(workspace.path);
+            return { ...this.profile(capabilities), models: cached.models };
+        }
+        const current = this.profileRefreshes.get(cacheKey);
+        if (current !== undefined) {
+            nodeLog('runner.opencode.profile.single-flight-joined', { workspaceId: workspace.id });
+            return current;
+        }
+        const refresh = this.fetchProfile(capabilities, workspace, environment, cacheKey).finally(() => {
+            if (this.profileRefreshes.get(cacheKey) === refresh)
+                this.profileRefreshes.delete(cacheKey);
+        });
+        this.profileRefreshes.set(cacheKey, refresh);
+        return refresh;
+    }
+    async fetchProfile(capabilities, workspace, environment, cacheKey) {
         const client = this.managedClient(environment);
+        const startedAt = performance.now();
         try {
             const catalog = await client.providers(workspace.path);
             const models = openCodeProfileModels(catalog);
+            const contextLimits = openCodeContextLimits(catalog);
             this.modelsByWorkspace.set(workspace.path, models);
-            this.contextLimitsByWorkspace.set(workspace.path, openCodeContextLimits(catalog));
+            this.contextLimitsByWorkspace.set(workspace.path, contextLimits);
+            this.profileCache.set(cacheKey, {
+                expiresAt: Date.now() + PROFILE_ENTRY_TTL_MS,
+                workspacePath: workspace.path,
+                environmentFingerprint: this.environmentFingerprint(environment),
+                models,
+                contextLimits
+            });
             this.scheduleProfileExpiry(workspace.path);
+            nodeLog('runner.opencode.profile.providers.completed', {
+                workspaceId: workspace.id,
+                models: models.length,
+                durationMs: Math.round(performance.now() - startedAt)
+            });
             return { ...this.profile(capabilities), models };
         }
         catch {
-            this.modelsByWorkspace.delete(workspace.path);
-            this.contextLimitsByWorkspace.delete(workspace.path);
-            this.clearProfileTimer(workspace.path);
+            nodeLog('runner.opencode.profile.providers.failed', {
+                workspaceId: workspace.id,
+                durationMs: Math.round(performance.now() - startedAt)
+            });
         }
         finally {
             this.releaseManagedClient(client);
         }
         return this.profile(capabilities);
     }
+    profileCacheKey(workspacePath, environment) {
+        return createHash('sha256')
+            .update(JSON.stringify({ workspacePath, environment: this.environmentFingerprint(environment) }))
+            .digest('hex');
+    }
+    environmentFingerprint(environment) {
+        const entries = Object.entries(environment).sort(([left], [right]) => left.localeCompare(right));
+        return createHash('sha256').update(JSON.stringify(entries)).digest('hex');
+    }
     available(capabilities) {
         return capabilities.openCode?.available === true;
     }
@@ -68,22 +125,18 @@ export class OpenCodeRunner extends AbstractRunner {
             openCode: { available: true }
         });
     }
-    supportsConfiguration(configuration, workspace) {
+    supportsConfiguration(configuration, workspace, environment = {}) {
         if (configuration.runner !== this.name)
             return false;
-        const models = workspace === undefined
-            ? [...this.modelsByWorkspace.values()].flat()
-            : (this.modelsByWorkspace.get(workspace.path) ?? []);
+        const models = this.cachedModels(workspace, environment);
         const model = models.find((candidate) => candidate.id === configuration.model);
         return (model !== undefined &&
             (model.supportedEfforts.length === 0 ||
                 model.supportedEfforts.includes(configuration.effort)) &&
             this.profileForValidation().accessOptions.some((candidate) => candidate.id === configuration.access));
     }
-    defaultConfiguration(workspace) {
-        const model = workspace === undefined
-            ? this.modelsByWorkspace.values().next().value?.[0]
-            : this.modelsByWorkspace.get(workspace.path)?.[0];
+    defaultConfiguration(workspace, environment = {}) {
+        const model = this.cachedModels(workspace, environment)[0];
         return {
             runner: this.name,
             model: model?.id ?? '',
@@ -91,6 +144,15 @@ export class OpenCodeRunner extends AbstractRunner {
             access: 'default'
         };
     }
+    cachedModels(workspace, environment) {
+        const fingerprint = this.environmentFingerprint(environment);
+        const now = Date.now();
+        return [...this.profileCache.values()]
+            .filter((entry) => entry.expiresAt > now &&
+            entry.environmentFingerprint === fingerprint &&
+            (workspace === undefined || entry.workspacePath === workspace.path))
+            .flatMap((entry) => entry.models);
+    }
     mcpConfiguration(raw, secrets) {
         const servers = super.mcpConfiguration(raw, secrets);
         return Object.fromEntries(servers.map((server) => [
@@ -121,7 +183,9 @@ export class OpenCodeRunner extends AbstractRunner {
             }
             for (const value of sessions) {
                 const session = openCodeSession(value);
-                if (session === undefined || !isWithinWorkspace(session.directory, target.path))
+                if (session === undefined ||
+                    session.parentId !== undefined ||
+                    !isWithinWorkspace(session.directory, target.path))
                     continue;
                 result.push(context.createProjection({
                     workspace: target,
@@ -177,6 +241,10 @@ export class OpenCodeRunner extends AbstractRunner {
             return undefined;
         }
     }
+    async readConversationHistory(readers) {
+        const official = await readers.official();
+        return official === undefined ? undefined : { ...official, source: 'official' };
+    }
     managedRunForNativeTurn(nativeTurnId) {
         return this.managedTurns.get(nativeTurnId);
     }
@@ -286,6 +354,8 @@ export class OpenCodeRunner extends AbstractRunner {
         for (const timer of this.profileTimersByWorkspace.values())
             clearTimeout(timer);
         this.profileTimersByWorkspace.clear();
+        this.profileCache.clear();
+        this.profileRefreshes.clear();
         this.modelsByWorkspace.clear();
         this.contextLimitsByWorkspace.clear();
         const stopping = [
@@ -370,6 +440,9 @@ function openCodeSession(value) {
         id: record.id,
         directory: record.directory,
         title: record.title,
-        updatedAt: typeof time?.updated === 'number' ? time.updated : 0
+        updatedAt: typeof time?.updated === 'number' ? time.updated : 0,
+        ...(typeof record.parentID === 'string' && record.parentID.length > 0
+            ? { parentId: record.parentID }
+            : {})
     };
 }

package/dist/runner/runner-registry.js

@@ -1,3 +1,4 @@
+import { nodeLog } from '../operational.js';
 export class RunnerRegistry {
     runners = new Map();
     constructor(runners = []) {
@@ -35,7 +36,21 @@ export class RunnerRegistry {
         });
     }
     async refreshProfiles(capabilities, workspace, environment = {}) {
-        const profiles = await Promise.all(this.advertised().map((runner) => runner.refreshProfile(capabilities, workspace, environment)));
+        const profiles = await Promise.all(this.advertised().map(async (runner) => {
+            const startedAt = performance.now();
+            try {
+                return await runner.refreshProfile(capabilities, workspace, environment);
+            }
+            finally {
+                const durationMs = Math.round(performance.now() - startedAt);
+                if (durationMs >= 100)
+                    nodeLog('runner.profile.refresh.completed', {
+                        runner: runner.name,
+                        workspaceId: workspace?.id,
+                        durationMs
+                    });
+            }
+        }));
         return profiles.flatMap((profile) => (profile === undefined ? [] : [profile]));
     }
     supportsConfiguration(configuration, workspace, environment) {

package/dist/runtime-command-detector.js

@@ -50,18 +50,13 @@ export function normalizeVersion(id, value) {
 }
 async function executeVersion(command, args) {
     const executable = process.platform === 'win32' ? process.env['ComSpec'] || 'cmd.exe' : command;
-    const commandArgs = process.platform === 'win32'
-        ? ['/d', '/s', '/c', [command, ...args].map(quoteWindowsArgument).join(' ')]
-        : [...args];
+    const commandArgs = process.platform === 'win32' ? ['/d', '/s', '/c', [command, ...args].join(' ')] : [...args];
     return execFileAsync(executable, commandArgs, {
         timeout: 5_000,
         maxBuffer: 64 * 1024,
         windowsHide: true
     });
 }
-function quoteWindowsArgument(value) {
-    return `"${value.replaceAll('"', '""')}"`;
-}
 async function resolveCommandPath(command) {
     try {
         const resolver = process.platform === 'win32' ? 'where.exe' : 'which';

package/dist/runtime-state.js

@@ -391,6 +391,7 @@ export class NodeRuntimeState {
                 ? { ...item, payload: { ...item.payload, text: content } }
                 : item)
         }));
+        this.bumpQueueVersion(run.sessionId);
         return run;
     }
     deleteQueuedRun(runId) {

package/dist/service/conversation-history-service.d.ts

@@ -20,22 +20,23 @@ interface ConversationHistoryServiceOptions {
 }
 export declare class ConversationHistoryService {
     private readonly options;
-    private readonly activeOfficialReads;
+    private readonly activeHistoryReads;
     constructor(options: ConversationHistoryServiceOptions);
     read(session: NodeAgentSession, input: {
         readonly cursor?: string;
         readonly limit?: number;
     }): Promise<ConversationHistoryPage>;
+    private readRunnerHistory;
     private readManagedActive;
-    private prefetchActiveOfficial;
-    private takeActiveOfficialRead;
+    private prefetchActiveHistory;
+    private takeActiveHistoryRead;
     refreshExternalActivity(session: NodeAgentSession): Promise<void>;
-    readNative(session: NodeAgentSession): Promise<import("../native-session-history.js").NativeSessionHistory | undefined>;
+    readNative(session: NodeAgentSession, cursor?: string, limit?: number): Promise<import("../native-session-history.js").NativeSessionHistory | undefined>;
     private attachNativeImages;
     readOfficial(session: NodeAgentSession, input: {
         readonly cursor?: string;
         readonly limit?: number;
-    }): Promise<import("../runner/abstract-runner.js").RunnerOfficialConversationPage | undefined>;
+    }): Promise<import("../runner/abstract-runner.js").RunnerConversationPage | undefined>;
     private managedRunnerTurn;
     private page;
 }

package/dist/service/conversation-history-service.js

@@ -2,6 +2,7 @@ import { discoverNativeSessions, readNativeSession } from '../native-session-his
 import { coalesceImageGenerationItems } from '../runner/codex/conversation-parser.js';
 import { nativeConversationPage } from '../util/runner-native-session-parsers.js';
 import { isPlainRecord } from '../util/node-operation-parsers.js';
+import { nodeLog } from '../operational.js';
 export function hasManagedActiveRun(runtime, session) {
     return (session.nativeControl === 'MAR_MANAGED' &&
         runtime
@@ -47,7 +48,7 @@ function isConversationHistorySource(value) {
 }
 export class ConversationHistoryService {
     options;
-    activeOfficialReads = new Map();
+    activeHistoryReads = new Map();
     constructor(options) {
         this.options = options;
     }
@@ -57,7 +58,14 @@ export class ConversationHistoryService {
         const activeCursor = decodeActiveHistoryCursor(input.cursor, session.id);
         if (activeCursor !== undefined || this.options.hasManagedActiveRun(session))
             return this.readManagedActive(session, input, activeCursor, snapshotSequence, readAt);
-        let official = await this.readOfficial(session, input);
+        const selected = await this.readRunnerHistory(session, input);
+        if (selected.page?.source === 'native')
+            return this.page(selected.page.nextCursor, selected.page.turns, {
+                snapshotSequence,
+                source: 'native',
+                readAt
+            });
+        let official = selected.page?.source === 'official' ? selected.page : undefined;
         if (official !== undefined) {
             const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
             const runtimeTurns = this.options.runtime.getAgentSession(session.id) === undefined
@@ -75,7 +83,7 @@ export class ConversationHistoryService {
                 const reserved = Math.min(missingLocalTurns.length, Math.max(0, limit - 1));
                 const narrowed = await this.readOfficial(session, { ...input, limit: limit - reserved });
                 if (narrowed !== undefined)
-                    official = narrowed;
+                    official = { ...narrowed, source: 'official' };
             }
             const officialTurns = await this.attachNativeImages(session, official.turns);
             const officialRunIds = new Set(officialTurns.flatMap((turn) => (turn.runId === null ? [] : [turn.runId])));
@@ -124,40 +132,68 @@ export class ConversationHistoryService {
                 readAt
             });
         }
-        if (session.externalSessionId !== null && !this.options.hasManagedActiveRun(session)) {
-            const history = await this.readNative(session);
-            if (history !== undefined) {
-                if (history.truncated !== true ||
-                    this.options.runners.require(session.runner).acceptsTruncatedNativeHistory()) {
-                    const runtimeTurns = this.options.runtime.getAgentSession(session.id) === undefined
-                        ? []
-                        : this.options.runtime.listConversationTurns({ sessionId: session.id, limit: 500 })
-                            .turns;
-                    const page = nativeConversationPage(session, history, input, runtimeTurns, (images) => this.options.attachments.registerNative(session, images));
-                    return this.page(page.nextCursor, page.turns, {
-                        snapshotSequence,
-                        source: 'native',
-                        readAt
-                    });
-                }
-                const runtimePage = this.options.runtime.listConversationTurns({
-                    sessionId: session.id,
-                    ...input
-                });
-                if (runtimePage.turns.length === 0)
-                    throw new Error('NATIVE_TRANSCRIPT_INCOMPLETE');
-                return this.page(runtimePage.nextCursor, runtimePage.turns, {
-                    snapshotSequence,
-                    source: 'runtime',
-                    readAt
-                });
-            }
-            if (session.nativeControl === 'EXTERNAL')
-                throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
+        if (session.externalSessionId !== null && selected.incompleteNative) {
+            const runtimePage = this.options.runtime.listConversationTurns({
+                sessionId: session.id,
+                ...input
+            });
+            if (runtimePage.turns.length === 0)
+                throw new Error('NATIVE_TRANSCRIPT_INCOMPLETE');
+            return this.page(runtimePage.nextCursor, runtimePage.turns, {
+                snapshotSequence,
+                source: 'runtime',
+                readAt
+            });
         }
+        if (session.externalSessionId !== null && session.nativeControl === 'EXTERNAL')
+            throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
         const page = this.options.runtime.listConversationTurns({ sessionId: session.id, ...input });
         return this.page(page.nextCursor, page.turns, { snapshotSequence, source: 'runtime', readAt });
     }
+    async readRunnerHistory(session, input) {
+        const runner = this.options.runners.require(session.runner);
+        let incompleteNative = false;
+        const page = await runner.readConversationHistory({
+            native: async () => {
+                const startedAt = performance.now();
+                let history;
+                try {
+                    history = await this.readNative(session, input.cursor, input.limit);
+                }
+                catch {
+                    return undefined;
+                }
+                finally {
+                    const durationMs = Math.round(performance.now() - startedAt);
+                    if (durationMs >= 250)
+                        nodeLog('native.session.history.native-read.completed', {
+                            runner: session.runner,
+                            sessionId: session.id,
+                            durationMs
+                        });
+                }
+                if (history === undefined)
+                    return undefined;
+                if (history.truncated === true &&
+                    (!runner.acceptsTruncatedNativeHistory() || history.items.length === 0)) {
+                    incompleteNative = true;
+                    return undefined;
+                }
+                const runtimeTurns = this.options.runtime.getAgentSession(session.id) === undefined
+                    ? []
+                    : this.options.runtime.listConversationTurns({ sessionId: session.id, limit: 500 })
+                        .turns;
+                const native = nativeConversationPage(session, history, history.cursorReset === true
+                    ? input.limit === undefined
+                        ? {}
+                        : { limit: input.limit }
+                    : input, runtimeTurns, (images) => this.options.attachments.registerNative(session, images));
+                return native;
+            },
+            official: () => this.readOfficial(session, input)
+        });
+        return { page, incompleteNative };
+    }
     async readManagedActive(session, input, cursor, snapshotSequence, readAt) {
         const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
         const runtimeTurns = this.options.runtime.listConversationTurns({
@@ -166,26 +202,30 @@ export class ConversationHistoryService {
         }).turns;
         const beforeAt = cursor?.beforeAt ?? oldestTurnActivityAt(runtimeTurns);
         if (cursor?.stage === 'OFFICIAL') {
-            const prefetched = this.takeActiveOfficialRead(session.id, limit, cursor.cursor);
-            const official = await (prefetched ??
-                this.readOfficial(session, {
+            const prefetched = this.takeActiveHistoryRead(session.id, limit, cursor.cursor);
+            const selected = await (prefetched ??
+                this.readRunnerHistory(session, {
                     ...(cursor.cursor === null ? {} : { cursor: cursor.cursor }),
                     limit
                 }));
-            if (official === undefined)
+            const history = selected.page;
+            if (history === undefined)
                 return this.page(null, [], { snapshotSequence, source: 'runtime', readAt });
-            const turns = (await this.attachNativeImages(session, official.turns)).filter((turn) => latestTurnActivityAt(turn) < beforeAt);
-            return this.page(official.nextCursor === null
+            const hydratedTurns = history.source === 'official'
+                ? await this.attachNativeImages(session, history.turns)
+                : history.turns;
+            const turns = hydratedTurns.filter((turn) => latestTurnActivityAt(turn) < beforeAt);
+            return this.page(history.nextCursor === null
                 ? null
                 : encodeActiveHistoryCursor({
                     sessionId: session.id,
                     stage: 'OFFICIAL',
                     beforeAt,
-                    cursor: official.nextCursor
-                }), turns, { snapshotSequence, source: 'official', readAt });
+                    cursor: history.nextCursor
+                }), turns, { snapshotSequence, source: history.source, readAt });
         }
         if (cursor === undefined && session.externalSessionId !== null)
-            this.prefetchActiveOfficial(session, limit);
+            this.prefetchActiveHistory(session, limit);
         const runtimePage = this.options.runtime.listConversationTurns({
             sessionId: session.id,
             ...(cursor?.cursor === null || cursor === undefined ? {} : { cursor: cursor.cursor }),
@@ -213,29 +253,32 @@ export class ConversationHistoryService {
             deferredOlderHistory: true
         });
     }
-    prefetchActiveOfficial(session, limit) {
+    prefetchActiveHistory(session, limit) {
         const now = Date.now();
-        for (const [sessionId, read] of this.activeOfficialReads)
+        for (const [sessionId, read] of this.activeHistoryReads)
             if (read.createdAt + 60_000 <= now)
-                this.activeOfficialReads.delete(sessionId);
-        const current = this.activeOfficialReads.get(session.id);
+                this.activeHistoryReads.delete(sessionId);
+        const current = this.activeHistoryReads.get(session.id);
         if (current !== undefined && current.limit === limit)
             return;
-        this.activeOfficialReads.set(session.id, {
+        this.activeHistoryReads.set(session.id, {
             createdAt: now,
             limit,
             // The active Run fast path must stay independent from an optional
             // background reader failure until the user explicitly requests older history.
-            page: this.readOfficial(session, { limit }).catch(() => undefined)
+            page: this.readRunnerHistory(session, { limit }).catch(() => ({
+                page: undefined,
+                incompleteNative: false
+            }))
         });
     }
-    takeActiveOfficialRead(sessionId, limit, cursor) {
+    takeActiveHistoryRead(sessionId, limit, cursor) {
         if (cursor !== null)
             return undefined;
-        const read = this.activeOfficialReads.get(sessionId);
+        const read = this.activeHistoryReads.get(sessionId);
         if (read === undefined || read.limit !== limit || read.createdAt + 60_000 <= Date.now())
             return undefined;
-        this.activeOfficialReads.delete(sessionId);
+        this.activeHistoryReads.delete(sessionId);
         return read.page;
     }
     async refreshExternalActivity(session) {
@@ -248,17 +291,26 @@ export class ConversationHistoryService {
         if (activity !== undefined)
             this.options.setExternalActivity(session.id, activity);
     }
-    async readNative(session) {
+    async readNative(session, cursor, limit = 30) {
         if (session.externalSessionId === null)
             return undefined;
-        const current = await readNativeSession(session.runner, session.cwd, session.externalSessionId);
+        const page = nativeHistoryPageCursor(cursor, session.id);
+        const current = await readNativeSession(session.runner, session.cwd, session.externalSessionId, page, limit);
         if (current !== undefined)
             return current;
         await discoverNativeSessions(session.runner, session.cwd);
-        return readNativeSession(session.runner, session.cwd, session.externalSessionId);
+        return readNativeSession(session.runner, session.cwd, session.externalSessionId, page, limit);
     }
     async attachNativeImages(session, turns) {
+        const startedAt = performance.now();
         const history = await this.readNative(session);
+        const readDurationMs = Math.round(performance.now() - startedAt);
+        if (readDurationMs >= 250)
+            nodeLog('native.session.history.attachment-source-read.completed', {
+                runner: session.runner,
+                sessionId: session.id,
+                durationMs: readDurationMs
+            });
         if (history === undefined)
             return turns;
         const attachments = new Map();
@@ -285,7 +337,19 @@ export class ConversationHistoryService {
         const runner = this.options.runners.require(session.runner);
         if (session.externalSessionId === null || !runner.available(this.options.capabilities()))
             return undefined;
-        return runner.readOfficialConversation(session, input, (nativeTurnId) => this.managedRunnerTurn(session, nativeTurnId));
+        const startedAt = performance.now();
+        try {
+            return await runner.readOfficialConversation(session, input, (nativeTurnId) => this.managedRunnerTurn(session, nativeTurnId));
+        }
+        finally {
+            const durationMs = Math.round(performance.now() - startedAt);
+            if (durationMs >= 250)
+                nodeLog('native.session.history.official-read.completed', {
+                    runner: session.runner,
+                    sessionId: session.id,
+                    durationMs
+                });
+        }
     }
     managedRunnerTurn(session, nativeTurnId) {
         const runId = this.options.runners
@@ -306,6 +370,38 @@ export class ConversationHistoryService {
         };
     }
 }
+function nativeHistoryPageCursor(cursor, sessionId) {
+    if (cursor === undefined)
+        return undefined;
+    try {
+        const value = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
+        return value.sessionId === sessionId &&
+            Number.isInteger(value.snapshotEnd) &&
+            Number.isInteger(value.nextEnd) &&
+            Number.isInteger(value.anchorBytes) &&
+            value.snapshotEnd >= 0 &&
+            value.nextEnd >= 0 &&
+            value.nextEnd <= value.snapshotEnd &&
+            value.anchorBytes >= 0 &&
+            value.anchorBytes <= value.snapshotEnd &&
+            (value.readLimit === undefined ||
+                (Number.isInteger(value.readLimit) &&
+                    value.readLimit >= 1 &&
+                    value.readLimit <= 500)) &&
+            typeof value.fileAnchor === 'string'
+            ? {
+                snapshotEnd: value.snapshotEnd,
+                nextEnd: value.nextEnd,
+                fileAnchor: value.fileAnchor,
+                anchorBytes: value.anchorBytes,
+                ...(value.readLimit === undefined ? {} : { readLimit: value.readLimit })
+            }
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 const ACTIVE_HISTORY_CURSOR_PREFIX = 'mar-active-history:1:';
 function encodeActiveHistoryCursor(cursor) {
     return `${ACTIVE_HISTORY_CURSOR_PREFIX}${Buffer.from(JSON.stringify(cursor)).toString('base64url')}`;

package/dist/service/external-session-resume-service.d.ts

@@ -18,7 +18,9 @@ interface ExternalSessionResumeServiceOptions {
 }
 export declare class ExternalSessionResumeService {
     private readonly options;
+    private readonly transitions;
     constructor(options: ExternalSessionResumeServiceOptions);
+    transitioning(sessionId: string): boolean;
     resume(external: NodeAgentSession, force?: boolean): Promise<NodeAgentSession | undefined>;
     failure(sessionId: string): {
         readonly code: string;