@myagentroam/node 0.9.3 → 0.9.5

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

@@ -3,15 +3,19 @@ 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();
+    leases = new Map();
+    snapshotSequence = 0;
     constructor(options) {
         this.options = options;
     }
     operations() {
         return {
-            'session.watch': (data) => this.executeWatch(isPlainRecord(data) ? data : {})
+            'session.watch': (data) => this.executeWatch(isPlainRecord(data) ? data : {}),
+            'session.unwatch': (data) => this.executeUnwatch(isPlainRecord(data) ? data : {})
         };
     }
     async executeWatch(input) {
@@ -19,39 +23,75 @@ export class NativeSessionWatchService {
         if (input.unit === 'SEGMENT' && projectInitialPage === undefined)
             throw new Error('SESSION_INVALID');
         if (typeof input.sessionId !== 'string' ||
+            (input.workspaceId !== undefined && typeof input.workspaceId !== 'string') ||
+            typeof input.watchId !== 'string' ||
+            typeof input.workbenchConnectionId !== 'string' ||
             (input.mode !== 'initial' && input.mode !== 'renew') ||
             (input.unit !== undefined && input.unit !== 'SEGMENT'))
             throw new Error('SESSION_INVALID');
-        const session = await this.options.resolve(input.sessionId);
-        if (session === undefined || session.externalSessionId === null)
-            throw new Error('SESSION_NOT_FOUND');
+        const ownerKey = this.ownerKey(input);
         if (input.mode === 'renew') {
-            const watch = this.renew(session);
-            if (watch === undefined)
+            const lease = this.leases.get(ownerKey);
+            if (lease === undefined ||
+                lease.watchId !== input.watchId ||
+                lease.sessionId !== input.sessionId ||
+                (input.workspaceId !== undefined && lease.workspaceId !== input.workspaceId))
+                throw new Error('SESSION_WATCH_NOT_FOUND');
+            if (lease.expiresAt <= Date.now()) {
+                this.removeLease(ownerKey);
                 throw new Error('SESSION_WATCH_NOT_FOUND');
-            return { renewed: true };
-        }
-        const watch = this.watch(session);
-        const turnSnapshot = watch === undefined ? undefined : await this.refresh(session.id, INITIAL_TURN_LIMIT);
-        if (watch !== undefined && turnSnapshot === undefined) {
-            this.stop(session.id);
-            throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
-        }
-        let snapshot = turnSnapshot;
-        if (turnSnapshot !== undefined && input.unit === 'SEGMENT') {
-            try {
-                snapshot = projectInitialPage(session, turnSnapshot, 'SEGMENT', 10);
-            }
-            catch (error) {
-                this.stop(session.id);
-                throw error;
             }
+            lease.expiresAt = Date.now() + TTL_MS;
+            const observer = this.watches.get(lease.sessionId);
+            if (observer !== undefined)
+                observer.expiresAt = this.latestLeaseExpiry(lease.sessionId);
+            clearTimeout(lease.timer);
+            lease.timer = this.leaseTimer(ownerKey);
+            return this.accepted(lease);
         }
-        return {
-            session: this.options.present(session),
-            watch: watch === undefined ? null : { expiresAt: watch.expiresAt },
-            ...(snapshot === undefined ? {} : { snapshot })
+        const existing = this.leases.get(ownerKey);
+        const unit = input.unit === 'SEGMENT' ? 'SEGMENT' : 'TURN';
+        if (existing?.watchId === input.watchId &&
+            existing.sessionId === input.sessionId &&
+            (input.workspaceId === undefined || existing.workspaceId === input.workspaceId) &&
+            existing.unit === unit &&
+            existing.expiresAt > Date.now()) {
+            existing.expiresAt = Date.now() + TTL_MS;
+            clearTimeout(existing.timer);
+            existing.timer = this.leaseTimer(ownerKey);
+            return this.accepted(existing);
+        }
+        this.removeLease(ownerKey);
+        const lease = {
+            ownerKey,
+            sessionHash: this.sessionHash(input),
+            workbenchConnectionId: input.workbenchConnectionId,
+            watchId: input.watchId,
+            sessionId: input.sessionId,
+            unit,
+            nodeGeneration: this.options.nodeGeneration?.() ?? 'local-test-generation',
+            ...(typeof input.workspaceId === 'string' ? { workspaceId: input.workspaceId } : {}),
+            expiresAt: Date.now() + TTL_MS,
+            timer: undefined
         };
+        lease.timer = this.leaseTimer(ownerKey);
+        this.leases.set(ownerKey, lease);
+        const observer = this.watches.get(lease.sessionId);
+        if (observer !== undefined)
+            observer.expiresAt = this.latestLeaseExpiry(lease.sessionId);
+        void this.initializeLease(lease, projectInitialPage);
+        return this.accepted(lease);
+    }
+    executeUnwatch(input) {
+        if (typeof input.sessionId !== 'string' ||
+            typeof input.watchId !== 'string' ||
+            typeof input.workbenchConnectionId !== 'string')
+            throw new Error('SESSION_INVALID');
+        const ownerKey = this.ownerKey(input);
+        const lease = this.leases.get(ownerKey);
+        if (lease?.watchId === input.watchId && lease.sessionId === input.sessionId)
+            this.removeLease(ownerKey);
+        return { stopped: true };
     }
     watch(session) {
         if (this.options.managedActive(session)) {
@@ -68,11 +108,13 @@ export class NativeSessionWatchService {
             refresh: undefined,
             sessionSignature: undefined,
             signature: undefined,
+            page: undefined,
+            observedPage: undefined,
+            authority: undefined,
             failures: 0,
             timer: undefined
         };
-        watch.timer = setInterval(() => void this.refresh(session.id), INTERVAL_MS);
-        watch.timer.unref();
+        watch.timer = this.refreshTimer(session.id);
         this.watches.set(session.id, watch);
         return { expiresAt: watch.expiresAt };
     }
@@ -93,13 +135,16 @@ export class NativeSessionWatchService {
         const watch = this.watches.get(sessionId);
         if (watch === undefined)
             return;
-        clearInterval(watch.timer);
+        clearTimeout(watch.timer);
         this.watches.delete(sessionId);
     }
     clear() {
         for (const watch of this.watches.values())
-            clearInterval(watch.timer);
+            clearTimeout(watch.timer);
         this.watches.clear();
+        for (const lease of this.leases.values())
+            clearTimeout(lease.timer);
+        this.leases.clear();
     }
     has(sessionId) {
         return this.watches.has(sessionId);
@@ -110,7 +155,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,26 +165,33 @@ 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;
         }
         finally {
-            if (this.watches.get(sessionId) === watch)
+            if (this.watches.get(sessionId) === watch) {
                 watch.refresh = undefined;
+                clearTimeout(watch.timer);
+                watch.timer = this.refreshTimer(sessionId);
+            }
         }
     }
-    async performRefresh(sessionId, watch, limit) {
+    async performRefresh(sessionId, watch, limit, emit) {
         try {
+            if (this.options.suspended?.(sessionId) === true)
+                return watch.page;
             const session = await this.options.resolve(sessionId);
             if (session === undefined ||
                 session.externalSessionId === null ||
                 this.options.managedActive(session)) {
-                this.stop(sessionId);
+                this.releaseSessionLeases(sessionId);
                 return undefined;
             }
             await this.options.refreshActivity(session);
+            if (this.options.suspended?.(sessionId) === true)
+                return watch.page;
             const presented = this.options.present(session);
             const sessionSignature = JSON.stringify(presented);
             if (sessionSignature !== watch.sessionSignature) {
@@ -148,20 +200,184 @@ 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.emitObservedPage(session, accepted);
+            return emit ? accepted : page;
         }
         catch {
             watch.failures += 1;
             if (watch.failures >= MAX_FAILURES)
-                this.stop(sessionId);
+                this.failSession(sessionId);
             return undefined;
         }
     }
+    sessionHash(input) {
+        return typeof input.__workspaceWatchSessionHash === 'string'
+            ? input.__workspaceWatchSessionHash
+            : 'local-test';
+    }
+    ownerKey(input) {
+        return `${this.sessionHash(input)}:${input.workbenchConnectionId}`;
+    }
+    accepted(lease) {
+        return {
+            accepted: true,
+            watchId: lease.watchId,
+            nodeGeneration: lease.nodeGeneration,
+            expiresAt: lease.expiresAt
+        };
+    }
+    async initializeLease(lease, projectInitialPage) {
+        try {
+            const session = await this.options.resolve(lease.sessionId);
+            if (session === undefined || session.externalSessionId === null)
+                throw new Error('SESSION_NOT_FOUND');
+            if (lease.workspaceId !== undefined && session.workspaceId !== lease.workspaceId)
+                throw new Error('SESSION_WORKSPACE_MISMATCH');
+            if (this.leases.get(lease.ownerKey) !== lease)
+                return;
+            lease.workspaceId = session.workspaceId;
+            const watch = this.watch(session);
+            const page = watch === undefined ? undefined : await this.refresh(session.id, INITIAL_TURN_LIMIT, false);
+            if (page === undefined)
+                throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
+            const payload = lease.unit === 'SEGMENT' ? projectInitialPage(session, page, 'SEGMENT', 10) : page;
+            if (this.leases.get(lease.ownerKey) !== lease)
+                return;
+            this.options.emitWatchEvent?.({
+                type: 'watch.session.snapshot',
+                workbenchConnectionId: lease.workbenchConnectionId,
+                watchId: lease.watchId,
+                nodeGeneration: lease.nodeGeneration,
+                nodeId: this.options.nodeId?.() ?? 'local-test-node',
+                workspaceId: session.workspaceId,
+                sessionId: session.id,
+                revision: 1,
+                snapshotSequence: ++this.snapshotSequence,
+                expiresAt: lease.expiresAt,
+                payload
+            });
+        }
+        catch (error) {
+            if (this.leases.get(lease.ownerKey) !== lease)
+                return;
+            this.options.emitWatchEvent?.({
+                type: 'watch.failed',
+                workbenchConnectionId: lease.workbenchConnectionId,
+                watchType: 'session',
+                watchId: lease.watchId,
+                nodeGeneration: lease.nodeGeneration,
+                nodeId: this.options.nodeId?.() ?? 'local-test-node',
+                workspaceId: lease.workspaceId ?? 'unknown',
+                sessionId: lease.sessionId,
+                code: error instanceof Error && /^[A-Z][A-Z0-9_]+$/.test(error.message)
+                    ? error.message
+                    : 'SESSION_WATCH_SNAPSHOT_FAILED',
+                message: 'Session watch snapshot failed.'
+            });
+            this.removeLease(lease.ownerKey);
+        }
+    }
+    removeLease(ownerKey) {
+        const lease = this.leases.get(ownerKey);
+        if (lease === undefined)
+            return;
+        clearTimeout(lease.timer);
+        this.leases.delete(ownerKey);
+        const observer = this.watches.get(lease.sessionId);
+        const nextExpiry = this.latestLeaseExpiry(lease.sessionId);
+        if (nextExpiry === 0)
+            this.stop(lease.sessionId);
+        else if (observer !== undefined)
+            observer.expiresAt = nextExpiry;
+    }
+    emitObservedPage(session, page) {
+        const leases = [...this.leases.values()].filter((lease) => lease.sessionId === session.id);
+        if (leases.length === 0) {
+            this.options.emitPage(session, page);
+            return;
+        }
+        for (const lease of leases) {
+            const payload = lease.unit === 'SEGMENT'
+                ? this.options.projectInitialPage?.(session, page, 'SEGMENT', 10)
+                : page;
+            if (payload === undefined)
+                continue;
+            this.options.emitWatchEvent?.({
+                type: 'watch.session.snapshot',
+                workbenchConnectionId: lease.workbenchConnectionId,
+                watchId: lease.watchId,
+                nodeGeneration: lease.nodeGeneration,
+                nodeId: this.options.nodeId?.() ?? 'local-test-node',
+                workspaceId: session.workspaceId,
+                sessionId: session.id,
+                revision: 1,
+                snapshotSequence: ++this.snapshotSequence,
+                expiresAt: lease.expiresAt,
+                payload
+            });
+        }
+    }
+    failSession(sessionId) {
+        for (const lease of [...this.leases.values()]) {
+            if (lease.sessionId !== sessionId)
+                continue;
+            this.options.emitWatchEvent?.({
+                type: 'watch.failed',
+                workbenchConnectionId: lease.workbenchConnectionId,
+                watchType: 'session',
+                watchId: lease.watchId,
+                nodeGeneration: lease.nodeGeneration,
+                nodeId: this.options.nodeId?.() ?? 'local-test-node',
+                workspaceId: lease.workspaceId ?? 'unknown',
+                sessionId,
+                code: 'NATIVE_TRANSCRIPT_UNAVAILABLE',
+                message: 'Session watch snapshot failed.'
+            });
+            this.removeLease(lease.ownerKey);
+        }
+        this.stop(sessionId);
+    }
+    releaseSessionLeases(sessionId) {
+        for (const lease of [...this.leases.values()])
+            if (lease.sessionId === sessionId)
+                this.removeLease(lease.ownerKey);
+        this.stop(sessionId);
+    }
+    leaseTimer(ownerKey) {
+        const timer = setTimeout(() => this.removeLease(ownerKey), TTL_MS);
+        timer.unref();
+        return timer;
+    }
+    latestLeaseExpiry(sessionId) {
+        let latest = 0;
+        for (const lease of this.leases.values())
+            if (lease.sessionId === sessionId)
+                latest = Math.max(latest, lease.expiresAt);
+        return latest;
+    }
+    refreshTimer(sessionId) {
+        const timer = setTimeout(() => void this.refresh(sessionId), INTERVAL_MS);
+        timer.unref();
+        return timer;
+    }
 }

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/run-workbench-service.d.ts

@@ -4,10 +4,8 @@ export interface RunWorkbenchServiceOptions {
     readonly runtime: NodeRuntimeState;
     readonly readImage: (runId: string, imageIndex: number) => Promise<unknown | undefined>;
     readonly respondUserInput: (runId: string, requestId: string, answers: Record<string, unknown>) => void;
-    readonly deleteQueuedStart: (runId: string) => void;
-    readonly clearImages: (runId: string) => void;
-    readonly cleanupAttachments: (runId: string) => void;
-    readonly emitQueue: (workspaceId: string, sessionId: string) => void;
+    readonly cancelQueued: (runId: string) => void;
+    readonly pauseQueue: (sessionId: string) => void;
     readonly emitRun: (runId: string, eventType: string, payload: unknown, status?: 'CANCELLED') => void;
     readonly control: (operation: string, payload: Record<string, unknown>) => void;
     readonly markInterrupted: (runId: string) => void;

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

@@ -55,11 +55,7 @@ export class RunWorkbenchService {
         if (operation === 'run.cancel' &&
             run.status === 'QUEUED' &&
             this.options.runtime.isQueuedRun(run.id)) {
-            this.options.runtime.deleteQueuedRun(run.id);
-            this.options.deleteQueuedStart(run.id);
-            this.options.clearImages(run.id);
-            this.options.cleanupAttachments(run.id);
-            this.options.emitQueue(run.workspaceId, run.sessionId);
+            this.options.cancelQueued(run.id);
             return { cancelled: true };
         }
         const next = this.options.runtime.transitionRun(run.id, operation === 'run.cancel' && run.status === 'QUEUED' ? 'CANCELLED' : 'CANCELLING');
@@ -68,8 +64,7 @@ export class RunWorkbenchService {
             return { run: next };
         }
         if (operation === 'run.interrupt') {
-            this.options.runtime.pauseSessionQueue(run.sessionId);
-            this.options.emitQueue(run.workspaceId, run.sessionId);
+            this.options.pauseQueue(run.sessionId);
             this.options.markInterrupted(run.id);
         }
         this.options.control(operation, { runId: run.id });

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

@@ -36,7 +36,7 @@ export class SessionCommandService {
             input.input.length > 20_000)
             throw new Error('RUNNER_COMMAND_INVALID');
         const resolved = this.options.runtime.getAgentSession(input.sessionId) ??
-            (await this.options.projection.resolve(input.sessionId));
+            (await this.options.projection.resolveCurrent(input.sessionId));
         if (resolved === undefined)
             throw new Error('SESSION_NOT_FOUND');
         const session = resolved.nativeControl === 'EXTERNAL' ? await this.options.resume.resume(resolved) : resolved;

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

@@ -8,7 +8,7 @@ export interface SessionIdentityServiceOptions {
     readonly migrateRunnerState: (previousId: string, nextId: string) => void;
     readonly emitSession: (session: NodeAgentSession) => void;
     readonly emitRun: (run: unknown) => void;
-    readonly emitQueue: (workspaceId: string, sessionId: string) => void;
+    readonly emitQueue: (sessionId: string) => void;
     readonly emitTurn: (turn: unknown) => void;
 }
 export declare class SessionIdentityService {

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

@@ -29,7 +29,7 @@ export class SessionIdentityService {
         this.options.emitSession(session);
         for (const run of this.options.runtime.listRunsForSession(nativeSessionId))
             this.options.emitRun(run);
-        this.options.emitQueue(session.workspaceId, nativeSessionId);
+        this.options.emitQueue(nativeSessionId);
         for (const turn of this.options.runtime.listConversationTurns({ sessionId: nativeSessionId })
             .turns)
             if (turn.status !== 'QUEUED')

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,9 +200,13 @@ export class SessionLifecycleService {
                 sessionId: messageSessionId,
                 clientMessageId: input.clientMessageId,
                 content: input.content,
+                ...(input.__requestUserId === undefined ? {} : { __requestUserId: input.__requestUserId }),
                 ...(input.secretEnvironment === undefined
                     ? {}
                     : { secretEnvironment: input.secretEnvironment }),
+                ...(input.personalInstructions === undefined
+                    ? {}
+                    : { personalInstructions: input.personalInstructions }),
                 ...(input.attachmentIds === undefined ? {} : { attachmentIds: input.attachmentIds })
             }));
             const nativeSessionId = await identity;

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

@@ -18,11 +18,11 @@ interface SessionMessageServiceOptions {
     readonly resolve: (sessionId: string) => Promise<NodeAgentSession>;
     readonly present: (session: NodeAgentSession) => unknown;
     readonly emitSession: (session: NodeAgentSession) => void;
-    readonly emitQueue: (workspaceId: string, sessionId: string) => void;
     readonly channelToken: (sessionId: string) => string | undefined;
 }
 export declare class SessionMessageService {
     private readonly options;
+    private readonly pendingMessages;
     constructor(options: SessionMessageServiceOptions);
     operations(): Readonly<Record<string, NodeOperationHandler>>;
     private message;