@myagentroam/node 0.9.3 → 0.9.4

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

@@ -8,14 +8,55 @@ export function hasManagedActiveRun(runtime, session) {
             .listRunsForSession(session.id)
             .some((run) => run.status === 'STARTING' || run.status === 'RUNNING' || run.status === 'CANCELLING'));
 }
+export function convergeConversationWatchPage(previous, previousObserved, next, previousAuthority) {
+    const authority = isConversationHistorySource(previousAuthority)
+        ? previousAuthority
+        : previous?.source;
+    if (previous === undefined ||
+        authority === undefined ||
+        sourceRank(next.source) >= sourceRank(authority))
+        return { page: next, authority: next.source };
+    if (previous.turns.length === 0)
+        return { page: next, authority };
+    const boundary = next.turns.findLastIndex((turn) => previous.turns.some((candidate) => sameConversationTurn(candidate, turn)));
+    const observedBoundary = boundary >= 0 || previousObserved === undefined
+        ? -1
+        : next.turns.findLastIndex((turn) => previousObserved.turns.some((candidate) => sameConversationTurn(candidate, turn)));
+    const safeBoundary = Math.max(boundary, observedBoundary);
+    if (safeBoundary < 0)
+        return { page: previous, authority };
+    const additions = next.turns
+        .slice(safeBoundary + 1)
+        .filter((turn) => !previous.turns.some((candidate) => sameConversationTurn(candidate, turn)));
+    if (additions.length === 0)
+        return { page: previous, authority };
+    return {
+        page: {
+            ...previous,
+            source: next.source,
+            snapshotSequence: Math.max(previous.snapshotSequence, next.snapshotSequence),
+            readAt: next.readAt,
+            latestVisibleAt: next.latestVisibleAt ?? previous.latestVisibleAt,
+            turns: [...previous.turns, ...additions]
+        },
+        authority
+    };
+}
+function isConversationHistorySource(value) {
+    return value === 'official' || value === 'native' || value === 'runtime';
+}
 export class ConversationHistoryService {
     options;
+    activeOfficialReads = new Map();
     constructor(options) {
         this.options = options;
     }
     async read(session, input) {
         const snapshotSequence = this.options.snapshotSequence();
         const readAt = Date.now();
+        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);
         if (official !== undefined) {
             const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
@@ -23,13 +64,11 @@ export class ConversationHistoryService {
                 ? []
                 : this.options.runtime.listConversationTurns({ sessionId: session.id, limit: 500 }).turns;
             const initialOfficialRunIds = new Set(official.turns.flatMap((turn) => (turn.runId === null ? [] : [turn.runId])));
-            const absentLocalTurns = runtimeTurns.filter((turn) => turn.runId === null || !initialOfficialRunIds.has(turn.runId));
-            const officialFloor = Math.min(...official.turns.map((turn) => Math.max(turn.startedAt ?? 0, turn.completedAt ?? 0)));
-            const missingLocalTurns = official.turns.length === 0
-                ? absentLocalTurns.slice(-limit)
-                : officialFloor > 0
-                    ? absentLocalTurns.filter((turn) => Math.max(turn.startedAt ?? 0, turn.completedAt ?? 0) >= officialFloor)
-                    : absentLocalTurns.slice(-1);
+            const lastRepresentedRuntimeIndex = runtimeTurns.findLastIndex((turn) => turn.runId !== null && initialOfficialRunIds.has(turn.runId));
+            const officialHasTurns = official.turns.length > 0;
+            const absentLocalTurns = runtimeTurns.filter((turn, index) => (turn.runId === null || !initialOfficialRunIds.has(turn.runId)) &&
+                (!officialHasTurns || index > lastRepresentedRuntimeIndex));
+            const missingLocalTurns = absentLocalTurns.slice(-limit);
             if (input.cursor === undefined &&
                 missingLocalTurns.length > 0 &&
                 official.turns.length + missingLocalTurns.length > limit) {
@@ -49,7 +88,7 @@ export class ConversationHistoryService {
                     pendingItemsByRunId.set(turn.runId, pendingItems);
             }
             const availableLocalSlots = Math.max(0, limit - officialTurns.length);
-            const localCandidates = (input.cursor === undefined ? missingLocalTurns : []).sort((left, right) => (left.startedAt ?? 0) - (right.startedAt ?? 0));
+            const localCandidates = input.cursor === undefined ? missingLocalTurns : [];
             const localTurns = availableLocalSlots === 0 ? [] : localCandidates.slice(-availableLocalSlots);
             const localRequestIds = new Set([
                 ...localTurns.flatMap((turn) => turn.items.flatMap((item) => {
@@ -78,7 +117,7 @@ export class ConversationHistoryService {
                 })
                     .filter((turn) => turn.items.length > 0),
                 ...localTurns
-            ].sort((left, right) => (left.startedAt ?? 0) - (right.startedAt ?? 0));
+            ];
             return this.page(official.nextCursor, turns, {
                 snapshotSequence,
                 source: 'official',
@@ -119,6 +158,86 @@ export class ConversationHistoryService {
         const page = this.options.runtime.listConversationTurns({ sessionId: session.id, ...input });
         return this.page(page.nextCursor, page.turns, { snapshotSequence, source: 'runtime', readAt });
     }
+    async readManagedActive(session, input, cursor, snapshotSequence, readAt) {
+        const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
+        const runtimeTurns = this.options.runtime.listConversationTurns({
+            sessionId: session.id,
+            limit: 500
+        }).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, {
+                    ...(cursor.cursor === null ? {} : { cursor: cursor.cursor }),
+                    limit
+                }));
+            if (official === 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
+                ? null
+                : encodeActiveHistoryCursor({
+                    sessionId: session.id,
+                    stage: 'OFFICIAL',
+                    beforeAt,
+                    cursor: official.nextCursor
+                }), turns, { snapshotSequence, source: 'official', readAt });
+        }
+        if (cursor === undefined && session.externalSessionId !== null)
+            this.prefetchActiveOfficial(session, limit);
+        const runtimePage = this.options.runtime.listConversationTurns({
+            sessionId: session.id,
+            ...(cursor?.cursor === null || cursor === undefined ? {} : { cursor: cursor.cursor }),
+            limit
+        });
+        const nextCursor = runtimePage.nextCursor !== null
+            ? encodeActiveHistoryCursor({
+                sessionId: session.id,
+                stage: 'RUNTIME',
+                beforeAt,
+                cursor: runtimePage.nextCursor
+            })
+            : session.externalSessionId === null
+                ? null
+                : encodeActiveHistoryCursor({
+                    sessionId: session.id,
+                    stage: 'OFFICIAL',
+                    beforeAt,
+                    cursor: null
+                });
+        return this.page(nextCursor, runtimePage.turns, {
+            snapshotSequence,
+            source: 'runtime',
+            readAt,
+            deferredOlderHistory: true
+        });
+    }
+    prefetchActiveOfficial(session, limit) {
+        const now = Date.now();
+        for (const [sessionId, read] of this.activeOfficialReads)
+            if (read.createdAt + 60_000 <= now)
+                this.activeOfficialReads.delete(sessionId);
+        const current = this.activeOfficialReads.get(session.id);
+        if (current !== undefined && current.limit === limit)
+            return;
+        this.activeOfficialReads.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)
+        });
+    }
+    takeActiveOfficialRead(sessionId, limit, cursor) {
+        if (cursor !== null)
+            return undefined;
+        const read = this.activeOfficialReads.get(sessionId);
+        if (read === undefined || read.limit !== limit || read.createdAt + 60_000 <= Date.now())
+            return undefined;
+        this.activeOfficialReads.delete(sessionId);
+        return read.page;
+    }
     async refreshExternalActivity(session) {
         const runner = this.options.runners.require(session.runner);
         if (!runner.available(this.options.capabilities())) {
@@ -187,3 +306,56 @@ export class ConversationHistoryService {
         };
     }
 }
+const ACTIVE_HISTORY_CURSOR_PREFIX = 'mar-active-history:1:';
+function encodeActiveHistoryCursor(cursor) {
+    return `${ACTIVE_HISTORY_CURSOR_PREFIX}${Buffer.from(JSON.stringify(cursor)).toString('base64url')}`;
+}
+function decodeActiveHistoryCursor(value, sessionId) {
+    if (value === undefined || !value.startsWith(ACTIVE_HISTORY_CURSOR_PREFIX))
+        return undefined;
+    try {
+        const decoded = JSON.parse(Buffer.from(value.slice(ACTIVE_HISTORY_CURSOR_PREFIX.length), 'base64url').toString('utf8'));
+        if (decoded.sessionId !== sessionId ||
+            (decoded.stage !== 'RUNTIME' && decoded.stage !== 'OFFICIAL') ||
+            typeof decoded.beforeAt !== 'number' ||
+            !Number.isFinite(decoded.beforeAt) ||
+            decoded.beforeAt < 0 ||
+            (decoded.cursor !== null && typeof decoded.cursor !== 'string'))
+            throw new Error('EVENT_CURSOR_INVALID');
+        return decoded;
+    }
+    catch {
+        throw new Error('EVENT_CURSOR_INVALID');
+    }
+}
+function latestTurnActivityAt(turn) {
+    return Math.max(turn.startedAt ?? 0, turn.completedAt ?? 0);
+}
+function oldestTurnActivityAt(turns) {
+    return turns.length === 0 ? 0 : Math.min(...turns.map(latestTurnActivityAt));
+}
+function sameConversationTurn(left, right) {
+    if (left.id === right.id)
+        return true;
+    if (left.runId !== null && left.runId === right.runId)
+        return true;
+    const leftMessageId = conversationClientMessageId(left);
+    return leftMessageId !== null && leftMessageId === conversationClientMessageId(right);
+}
+function conversationClientMessageId(turn) {
+    for (const item of turn.items) {
+        if (item.kind !== 'user_message' || !isPlainRecord(item.payload))
+            continue;
+        const value = item.payload.clientMessageId;
+        if (typeof value === 'string' && value.length > 0)
+            return value;
+    }
+    return null;
+}
+function sourceRank(source) {
+    if (source === 'official')
+        return 3;
+    if (source === 'native')
+        return 2;
+    return 1;
+}

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

@@ -16,6 +16,7 @@ export function conversationSegments(turn) {
         const latest = index === groups.length - 1;
         const projectedItems = items.map((item) => ({
             ...item,
+            runId: turn.runId,
             segmentId: id,
             segmentIndex: index
         }));
@@ -89,7 +90,10 @@ export class ConversationSegmentService {
                 snapshotSequence: page.snapshotSequence,
                 source: page.source,
                 readAt: page.readAt,
-                latestVisibleAt: page.latestVisibleAt
+                latestVisibleAt: page.latestVisibleAt,
+                ...(boundary === undefined && page.deferredOlderHistory === true
+                    ? { deferredOlderHistory: true }
+                    : {})
             };
             const pageSegments = page.turns.flatMap(conversationSegments);
             let eligible = pageSegments;
@@ -108,6 +112,8 @@ export class ConversationSegmentService {
                 hasOlder = eligible.length > take.length || page.nextCursor !== null;
                 collected.unshift(...take);
             }
+            if (boundary === undefined && page.deferredOlderHistory === true)
+                break;
             if (collected.length >= limit || page.nextCursor === null)
                 break;
             if (visited.has(page.nextCursor))

package/dist/service/native-session-watch-service.d.ts

@@ -2,18 +2,24 @@ import type { NodeAgentSession } from '../database.js';
 import type { NodeOperationHandler } from '../connector/node-operation-router.js';
 export interface NativeSessionWatchOptions<TPage extends {
     readonly turns: readonly unknown[];
+    readonly source?: unknown;
 }> {
     readonly resolve: (sessionId: string) => Promise<NodeAgentSession | undefined>;
     readonly managedActive: (session: NodeAgentSession) => boolean;
     readonly refreshActivity: (session: NodeAgentSession) => Promise<void>;
     readonly present: (session: NodeAgentSession) => unknown;
     readonly readPage: (session: NodeAgentSession, limit: number) => Promise<TPage>;
+    readonly convergePage: (previous: TPage | undefined, previousObserved: TPage | undefined, next: TPage, previousAuthority: unknown) => {
+        readonly page: TPage;
+        readonly authority: unknown;
+    };
     readonly projectInitialPage?: (session: NodeAgentSession, page: TPage, unit: 'SEGMENT', limit: number) => unknown;
     readonly emitSession: (session: unknown) => void;
-    readonly emitTurn: (turn: unknown) => void;
+    readonly emitPage: (session: NodeAgentSession, page: TPage) => void;
 }
 export declare class NativeSessionWatchService<TPage extends {
     readonly turns: readonly unknown[];
+    readonly source?: unknown;
 }> {
     private readonly options;
     private readonly watches;
@@ -33,6 +39,6 @@ export declare class NativeSessionWatchService<TPage extends {
         readonly expiresAt: number;
     } | undefined;
     get size(): number;
-    refresh(sessionId: string, limit?: number): Promise<TPage | undefined>;
+    refresh(sessionId: string, limit?: number, emit?: boolean): Promise<TPage | undefined>;
     private performRefresh;
 }

package/dist/service/native-session-watch-service.js

@@ -3,6 +3,7 @@ const INTERVAL_MS = 2_000;
 const TTL_MS = 45_000;
 const MAX_FAILURES = 3;
 const INITIAL_TURN_LIMIT = 30;
+const EMITTED_TURN_LIMIT = 10;
 export class NativeSessionWatchService {
     options;
     watches = new Map();
@@ -32,7 +33,7 @@ export class NativeSessionWatchService {
             return { renewed: true };
         }
         const watch = this.watch(session);
-        const turnSnapshot = watch === undefined ? undefined : await this.refresh(session.id, INITIAL_TURN_LIMIT);
+        const turnSnapshot = watch === undefined ? undefined : await this.refresh(session.id, INITIAL_TURN_LIMIT, false);
         if (watch !== undefined && turnSnapshot === undefined) {
             this.stop(session.id);
             throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
@@ -68,6 +69,9 @@ export class NativeSessionWatchService {
             refresh: undefined,
             sessionSignature: undefined,
             signature: undefined,
+            page: undefined,
+            observedPage: undefined,
+            authority: undefined,
             failures: 0,
             timer: undefined
         };
@@ -110,7 +114,7 @@ export class NativeSessionWatchService {
     get size() {
         return this.watches.size;
     }
-    async refresh(sessionId, limit = 10) {
+    async refresh(sessionId, limit = 10, emit = true) {
         const watch = this.watches.get(sessionId);
         if (watch === undefined)
             return undefined;
@@ -120,7 +124,7 @@ export class NativeSessionWatchService {
             this.stop(sessionId);
             return undefined;
         }
-        const refresh = this.performRefresh(sessionId, watch, limit);
+        const refresh = this.performRefresh(sessionId, watch, limit, emit);
         watch.refresh = refresh;
         try {
             return await refresh;
@@ -130,7 +134,7 @@ export class NativeSessionWatchService {
                 watch.refresh = undefined;
         }
     }
-    async performRefresh(sessionId, watch, limit) {
+    async performRefresh(sessionId, watch, limit, emit) {
         try {
             const session = await this.options.resolve(sessionId);
             if (session === undefined ||
@@ -148,14 +152,28 @@ export class NativeSessionWatchService {
             }
             const page = await this.options.readPage(session, limit);
             watch.failures = 0;
-            const turns = page.turns.length <= 10 ? page.turns : page.turns.slice(-10);
-            const signature = JSON.stringify(turns);
+            const turns = page.turns.length <= EMITTED_TURN_LIMIT
+                ? page.turns
+                : page.turns.slice(-EMITTED_TURN_LIMIT);
+            const observed = { ...page, turns };
+            const convergence = this.options.convergePage(watch.page, watch.observedPage, observed, watch.authority);
+            const converged = convergence.page;
+            const accepted = converged.turns.length <= EMITTED_TURN_LIMIT + 1
+                ? converged
+                : {
+                    ...converged,
+                    turns: converged.turns.slice(-(EMITTED_TURN_LIMIT + 1))
+                };
+            watch.observedPage = observed;
+            watch.authority = convergence.authority;
+            const signature = JSON.stringify({ source: accepted.source, turns: accepted.turns });
             if (signature === watch.signature)
-                return page;
+                return accepted;
             watch.signature = signature;
-            for (const turn of turns)
-                this.options.emitTurn(turn);
-            return page;
+            watch.page = accepted;
+            if (emit)
+                this.options.emitPage(session, accepted);
+            return emit ? accepted : page;
         }
         catch {
             watch.failures += 1;

package/dist/service/node-request-service.js

@@ -23,7 +23,8 @@ export class NodeRequestService {
                 ? {
                     ...payload.data,
                     __workspaceWatchSessionHash: payload.userAuthorization
-                        .sessionHash
+                        .sessionHash,
+                    __requestUserId: payload.userAuthorization.userId
                 }
                 : payload.data;
             const result = await this.options.execute(payload.operation, data);

package/dist/service/run-event-service.js

@@ -95,11 +95,19 @@ export class RunEventService {
         this.options.emitWorkbench('conversation', {
             event: { ...event, createdAt: persisted?.createdAt ?? Date.now() }
         });
-        if (notificationPayload !== undefined)
-            this.emitNow(runId, 'notification', {
-                ...notificationPayload,
-                occurredAt: persisted?.createdAt ?? Date.now()
+        if (notificationPayload !== undefined) {
+            const occurredAt = persisted?.createdAt ?? Date.now();
+            nodeLog('run.event', { runId, eventType: 'notification' });
+            this.options.emitWorkbench('conversation', {
+                event: {
+                    runId,
+                    sequence: event.sequence,
+                    eventType: 'notification',
+                    payload: { ...notificationPayload, occurredAt },
+                    createdAt: occurredAt
+                }
             });
+        }
         if (status === undefined || !isTerminalRunStatus(status))
             return;
         const turn = this.options.runtime.conversationTurnForRun(runId);
@@ -126,11 +134,14 @@ export class RunEventService {
         if (session === undefined)
             return undefined;
         const base = {
+            userId: run.initiatedByUserId,
             workspaceId: run.workspaceId,
             sessionId: run.sessionId,
             sessionTitle: session.customTitle ?? session.runnerTitle ?? session.id,
             runId
         };
+        if (!Number.isSafeInteger(base.userId))
+            return undefined;
         if (status !== undefined && isTerminalRunStatus(status)) {
             if (this.options.state.interruptRequested.has(runId))
                 return undefined;
@@ -159,7 +170,7 @@ export class RunEventService {
         if (payload.kind === 'plan' && typeof payload.itemId === 'string')
             return {
                 ...base,
-                notificationId: `plan:${run.workspaceId}:${run.sessionId}`,
+                notificationId: `plan:${run.workspaceId}:${runId}:${payload.itemId}`,
                 kind: 'PLAN_READY'
             };
         if (payload.kind === 'user_input_request' &&

package/dist/service/session-lifecycle-service.js

@@ -112,25 +112,16 @@ export class SessionLifecycleService {
     async updateConfiguration(input) {
         if (typeof input.sessionId !== 'string' ||
             typeof input.model !== 'string' ||
+            !validSessionOption(input.model) ||
             typeof input.effort !== 'string' ||
             !validSessionEffort(input.effort) ||
-            typeof input.access !== 'string')
+            typeof input.access !== 'string' ||
+            !validSessionOption(input.access))
             throw new Error('SESSION_INVALID');
         const current = this.options.runtime.getAgentSession(input.sessionId) ??
             (await this.options.projection.createMetadataProjection(input.sessionId));
         if (current === undefined)
             throw new Error('SESSION_NOT_FOUND');
-        const configuration = {
-            runner: current.runner,
-            model: input.model,
-            effort: input.effort,
-            access: input.access
-        };
-        const workspace = this.options.database().getWorkspace(current.workspaceId);
-        const environment = parseSecretEnvironment(input.secretEnvironment);
-        if (workspace === undefined ||
-            !this.options.runners.supportsConfiguration(configuration, workspace, environment))
-            throw new Error('RUNNER_CONFIGURATION_UNSUPPORTED');
         const session = this.options.runtime.updateAgentSessionConfiguration({
             sessionId: current.id,
             model: input.model,
@@ -209,6 +200,7 @@ export class SessionLifecycleService {
                 sessionId: messageSessionId,
                 clientMessageId: input.clientMessageId,
                 content: input.content,
+                ...(input.__requestUserId === undefined ? {} : { __requestUserId: input.__requestUserId }),
                 ...(input.secretEnvironment === undefined
                     ? {}
                     : { secretEnvironment: input.secretEnvironment }),

package/dist/service/session-message-service.d.ts

@@ -23,6 +23,7 @@ interface SessionMessageServiceOptions {
 }
 export declare class SessionMessageService {
     private readonly options;
+    private readonly pendingMessages;
     constructor(options: SessionMessageServiceOptions);
     operations(): Readonly<Record<string, NodeOperationHandler>>;
     private message;