@myagentroam/node 0.9.161 → 0.9.163

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

@@ -118,27 +118,31 @@ export class ConversationHistoryService {
     async read(session, input) {
         const snapshotSequence = this.options.snapshotSequence();
         const readAt = Date.now();
+        const idleCursor = decodeIdleMarHistoryCursor(input.cursor, session.id);
+        if (idleCursor !== undefined) {
+            if (session.runner !== 'mar-agent')
+                throw new Error('EVENT_CURSOR_INVALID');
+            return this.readIdleMarAgentHistory(session, input, snapshotSequence, readAt);
+        }
         const activeCursor = decodeActiveHistoryCursor(input.cursor, session.id);
-        if (activeCursor !== undefined ||
-            this.options.hasManagedActiveRun(session) ||
-            this.hasManagedRuntimeHistory(session))
+        if (activeCursor !== undefined || this.options.hasManagedActiveRun(session))
             return this.readManagedRuntime(session, input, activeCursor, snapshotSequence, readAt);
         return this.readHistory(session, input, snapshotSequence, readAt);
     }
     async readHistoryPage(session, input) {
-        if (this.hasManagedRuntimeHistory(session)) {
+        if (input.cursor !== undefined)
+            return this.read(session, input);
+        if (this.options.hasManagedActiveRun(session) && this.hasManagedRuntimeHistory(session)) {
             const runtimeTurns = this.options.runtime.listConversationTurns({
                 sessionId: session.id,
                 limit: 500
             }).turns;
-            const olderCursor = this.options.hasManagedActiveRun(session)
-                ? {
-                    sessionId: session.id,
-                    stage: 'OFFICIAL',
-                    beforeAt: oldestTurnActivityAt(runtimeTurns),
-                    cursor: null
-                }
-                : undefined;
+            const olderCursor = {
+                sessionId: session.id,
+                stage: 'OFFICIAL',
+                beforeAt: oldestTurnActivityAt(runtimeTurns),
+                cursor: null
+            };
             return this.readManagedRuntime(session, input, olderCursor, this.options.snapshotSequence(), Date.now());
         }
         return this.readHistory(session, input, this.options.snapshotSequence(), Date.now());
@@ -151,6 +155,8 @@ export class ConversationHistoryService {
                 0);
     }
     async readHistory(session, input, snapshotSequence, readAt) {
+        if (session.runner === 'mar-agent' && session.nativeControl === 'MAR_MANAGED')
+            return this.readIdleMarAgentHistory(session, input, snapshotSequence, readAt);
         let selected;
         try {
             selected = await this.readRunnerHistory(session, input);
@@ -290,6 +296,84 @@ export class ConversationHistoryService {
             throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
         return this.page(page.nextCursor, page.turns, { snapshotSequence, source: 'runtime', readAt });
     }
+    async readIdleMarAgentHistory(session, input, snapshotSequence, readAt) {
+        const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
+        const cursor = decodeIdleMarHistoryCursor(input.cursor, session.id);
+        const runtime = this.options.runtime.getAgentSession(session.id) === undefined
+            ? []
+            : this.options.runtime.listConversationTurns({ sessionId: session.id, limit: 500 }).turns;
+        const before = (turn) => {
+            const at = earliestTurnActivityAt(turn);
+            return cursor === undefined || at <= cursor.beforeAt;
+        };
+        let nativeCursor = cursor === undefined ? input.cursor : (cursor.nativeCursor ?? undefined);
+        let exhausted = false;
+        let locatingBoundary = cursor !== undefined;
+        const native = [];
+        let merged = [];
+        let lastInputCursor = nativeCursor;
+        const visited = new Set();
+        if (nativeCursor !== undefined)
+            visited.add(nativeCursor);
+        try {
+            for (;;) {
+                // Keep the containing SDK page as the anchor: a local-only failure has no
+                // native cursor, and equal timestamps require a stable Turn boundary.
+                lastInputCursor = nativeCursor;
+                const page = await this.readOfficial(session, {
+                    limit,
+                    ...(nativeCursor === undefined ? {} : { cursor: nativeCursor })
+                });
+                if (page === undefined)
+                    throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
+                native.unshift(...page.turns);
+                exhausted = page.nextCursor === null;
+                const projected = native.map((turn) => {
+                    const local = runtime.find((candidate) => sameConversationTurn(turn, candidate));
+                    return local === undefined ? turn : mergeMarAgentRuntimeTurn(turn, local);
+                });
+                merged = projected.filter(before);
+                const oldestNative = oldestTurnActivityAt(native);
+                for (const turn of runtime) {
+                    if (before(turn) &&
+                        (exhausted || earliestTurnActivityAt(turn) >= oldestNative) &&
+                        !native.some((candidate) => sameConversationTurn(candidate, turn)))
+                        insertConversationTurnChronologically(merged, turn);
+                }
+                if (cursor !== undefined) {
+                    const boundary = merged.findIndex((turn) => conversationTurnKey(turn) === cursor.beforeTurnKey);
+                    if (boundary >= 0) {
+                        merged = merged.slice(0, boundary);
+                        locatingBoundary = false;
+                    }
+                }
+                if ((!locatingBoundary && merged.length >= limit) || exhausted)
+                    break;
+                if (visited.has(page.nextCursor))
+                    throw new Error('EVENT_CURSOR_INVALID');
+                visited.add(page.nextCursor);
+                nativeCursor = page.nextCursor;
+            }
+        }
+        catch (error) {
+            // Never replace a visible local failure with an empty SDK snapshot.
+            if (input.cursor !== undefined || runtime.length === 0)
+                throw error;
+            return this.readManagedActive(session, input, undefined, snapshotSequence, readAt);
+        }
+        if (locatingBoundary)
+            throw new Error('EVENT_CURSOR_INVALID');
+        const turns = merged.slice(-limit);
+        const nextCursor = turns.length > 0 && (merged.length > turns.length || !exhausted)
+            ? encodeIdleMarHistoryCursor({
+                sessionId: session.id,
+                beforeAt: earliestTurnActivityAt(turns[0]),
+                beforeTurnKey: conversationTurnKey(turns[0]),
+                nativeCursor: lastInputCursor ?? null
+            })
+            : null;
+        return this.page(nextCursor, turns, { snapshotSequence, source: 'official', readAt });
+    }
     async readRunnerHistory(session, input) {
         const runner = this.options.runners.require(session.runner);
         let incompleteNative = false;
@@ -393,8 +477,7 @@ export class ConversationHistoryService {
         const codexActive = session.runner === 'codex' && this.options.hasManagedActiveRun(session);
         if (input.cursor !== undefined ||
             session.externalSessionId === null ||
-            (!codexActive &&
-                (this.options.hasManagedActiveRun(session) || !this.hasManagedRuntimeHistory(session))) ||
+            !codexActive ||
             !page.turns.some((turn) => turn.rewind === undefined &&
                 terminalConversationTurn(turn.status) &&
                 conversationClientMessageId(turn) !== null))
@@ -402,9 +485,7 @@ export class ConversationHistoryService {
         // A completed managed Turn keeps its live items and Run identity until Runtime cleanup.
         // Only its matched native Turn may supply a Rewind boundary.
         const historyInput = { limit: Math.min(500, Math.max(30, page.turns.length + 1)) };
-        const authoritative = codexActive
-            ? (await this.readRunnerHistory(session, historyInput).catch(() => undefined))?.page
-            : await this.readOfficial(session, historyInput).catch(() => undefined);
+        const authoritative = (await this.readRunnerHistory(session, historyInput).catch(() => undefined))?.page;
         if (authoritative === undefined)
             return page;
         return {
@@ -509,6 +590,50 @@ function nativeHistoryPageCursor(cursor, sessionId) {
         return undefined;
     }
 }
+const IDLE_MAR_HISTORY_CURSOR_PREFIX = 'mar-idle-history:1:';
+function encodeIdleMarHistoryCursor(cursor) {
+    return `${IDLE_MAR_HISTORY_CURSOR_PREFIX}${Buffer.from(JSON.stringify(cursor)).toString('base64url')}`;
+}
+function decodeIdleMarHistoryCursor(value, sessionId) {
+    if (value === undefined || !value.startsWith(IDLE_MAR_HISTORY_CURSOR_PREFIX))
+        return undefined;
+    try {
+        if (value.length > 1024)
+            throw new Error('EVENT_CURSOR_INVALID');
+        const decoded = JSON.parse(Buffer.from(value.slice(IDLE_MAR_HISTORY_CURSOR_PREFIX.length), 'base64url').toString('utf8'));
+        if (decoded.sessionId !== sessionId ||
+            typeof decoded.beforeAt !== 'number' ||
+            !Number.isFinite(decoded.beforeAt) ||
+            decoded.beforeAt < 0 ||
+            typeof decoded.beforeTurnKey !== 'string' ||
+            decoded.beforeTurnKey.length === 0 ||
+            decoded.beforeTurnKey.length > 256 ||
+            (decoded.nativeCursor !== null &&
+                (typeof decoded.nativeCursor !== 'string' || decoded.nativeCursor.length > 256)))
+            throw new Error('EVENT_CURSOR_INVALID');
+        return decoded;
+    }
+    catch {
+        throw new Error('EVENT_CURSOR_INVALID');
+    }
+}
+/** Retained MAR output owns its matched Turn, never the entire shared Session. */
+function mergeMarAgentRuntimeTurn(native, local) {
+    const nativeErrors = local.items.some((item) => item.kind === 'error')
+        ? []
+        : native.items.filter((item) => item.kind === 'error');
+    const matchedInput = conversationClientMessageId(local) !== null &&
+        conversationClientMessageId(local) === conversationClientMessageId(native);
+    return {
+        ...local,
+        ...(matchedInput && native.rewind !== undefined ? { rewind: native.rewind } : {}),
+        status: nativeErrors.length > 0 ? 'FAILED' : local.status,
+        items: [
+            ...local.items,
+            ...nativeErrors.map((item) => ({ ...item, turnId: local.id, runId: local.runId }))
+        ]
+    };
+}
 const ACTIVE_HISTORY_CURSOR_PREFIX = 'mar-active-history:1:';
 function encodeActiveHistoryCursor(cursor) {
     return `${ACTIVE_HISTORY_CURSOR_PREFIX}${Buffer.from(JSON.stringify(cursor)).toString('base64url')}`;
@@ -606,6 +731,10 @@ function mergeRuntimeUserMetadata(officialTurn, runtimeTurn, attachments) {
             : item)
     };
 }
+function conversationTurnKey(turn) {
+    const messageId = conversationClientMessageId(turn);
+    return messageId === null ? `turn:${turn.id}` : `message:${messageId}`;
+}
 function sameConversationTurn(left, right) {
     if (left.id === right.id)
         return true;

package/dist/util/node-operation-parsers.js

@@ -1,7 +1,7 @@
 import { nodeCapabilitiesSchema } from '@myagentroam/protocol';
 const MAX_COMPOSER_ATTACHMENT_BYTES = 5 * 1024 * 1024;
 const MAX_COMPOSER_ATTACHMENTS_BYTES = 10 * 1024 * 1024;
-const USER_AUTHORIZATION_CLOCK_SKEW_MS = 5_000;
+const USER_AUTHORIZATION_CLOCK_SKEW_MS = 60 * 60 * 1_000;
 const NON_IMAGE_ATTACHMENT_PROMPT_PREFIX = '\n\nAttachments available in the Workspace:\n';
 const COMPOSER_IMAGE_MIME_TYPES = new Set([
     'image/png',
@@ -220,6 +220,7 @@ export function validUserAuthorization(value, envelope, operation, nodeId, now =
         typeof authorization.expiresAt === 'number' &&
         Number.isSafeInteger(authorization.issuedAt) &&
         Number.isSafeInteger(authorization.expiresAt) &&
+        authorization.expiresAt >= authorization.issuedAt &&
         authorization.issuedAt <= now + USER_AUTHORIZATION_CLOCK_SKEW_MS &&
         authorization.expiresAt >= now - USER_AUTHORIZATION_CLOCK_SKEW_MS &&
         authorization.expiresAt - authorization.issuedAt <= 15_000);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.161",
+  "version": "0.9.163",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -36,10 +36,10 @@
     "playwright": "1.62.1",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.9.161",
+    "@myagentroam/agent": "0.9.163",
     "@myagentroam/code-navigation": "0.9.129",
     "@myagentroam/marctl": "0.9.120",
-    "@myagentroam/protocol": "0.9.161"
+    "@myagentroam/protocol": "0.9.163"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"