@myagentroam/node 0.9.4 → 0.9.5

package/dist/service/external-session-resume-service.js

@@ -1,9 +1,13 @@
 const RESUME_FAILURE_TTL_MS = 30 * 60_000;
 export class ExternalSessionResumeService {
     options;
+    transitions = new Set();
     constructor(options) {
         this.options = options;
     }
+    transitioning(sessionId) {
+        return this.transitions.has(sessionId);
+    }
     async resume(external, force = false) {
         this.clearFailure(external.id);
         const priorId = this.options.state.resumedByDirectId.get(external.id);
@@ -15,40 +19,47 @@ export class ExternalSessionResumeService {
             this.setFailure(external.id, 'RUNNER_UNAVAILABLE');
             return undefined;
         }
-        const result = await runner.resumeExternal(external, {
-            available: this.options.available(external.runner),
-            projectionFor: this.options.projectionFor,
-            managedAliasFor: this.options.managedAliasFor,
-            currentResumed: (sessionId) => {
-                const resumedId = this.options.state.resumedByDirectId.get(sessionId);
-                return resumedId === undefined
-                    ? undefined
-                    : this.options.runtime.getAgentSession(resumedId);
-            },
-            promote: (sessionId) => {
-                this.options.runtime.setNativeControl(sessionId, 'MAR_MANAGED');
-                return this.options.runtime.getAgentSession(sessionId);
-            },
-            ensureConfiguration: this.options.ensureConfiguration,
-            create: (session) => {
-                const configuration = this.options.configuration(session);
-                return this.options.runtime.createAgentSession({
-                    workspaceId: session.workspaceId,
-                    runner: session.runner,
-                    ...(session.externalSessionId === null
-                        ? {}
-                        : { externalSessionId: session.externalSessionId }),
-                    nativeControl: 'MAR_MANAGED',
-                    cwd: session.cwd,
-                    model: configuration.model,
-                    effort: configuration.effort,
-                    access: configuration.access,
-                    ...(session.runnerTitle === null ? {} : { title: session.runnerTitle })
-                });
-            },
-            workspacePath: this.options.workspacePath,
-            rememberManagedNative: this.options.rememberNative
-        }, force);
+        this.transitions.add(external.id);
+        let result;
+        try {
+            result = await runner.resumeExternal(external, {
+                available: this.options.available(external.runner),
+                projectionFor: this.options.projectionFor,
+                managedAliasFor: this.options.managedAliasFor,
+                currentResumed: (sessionId) => {
+                    const resumedId = this.options.state.resumedByDirectId.get(sessionId);
+                    return resumedId === undefined
+                        ? undefined
+                        : this.options.runtime.getAgentSession(resumedId);
+                },
+                promote: (sessionId) => {
+                    this.options.runtime.setNativeControl(sessionId, 'MAR_MANAGED');
+                    return this.options.runtime.getAgentSession(sessionId);
+                },
+                ensureConfiguration: this.options.ensureConfiguration,
+                create: (session) => {
+                    const configuration = this.options.configuration(session);
+                    return this.options.runtime.createAgentSession({
+                        workspaceId: session.workspaceId,
+                        runner: session.runner,
+                        ...(session.externalSessionId === null
+                            ? {}
+                            : { externalSessionId: session.externalSessionId }),
+                        nativeControl: 'MAR_MANAGED',
+                        cwd: session.cwd,
+                        model: configuration.model,
+                        effort: configuration.effort,
+                        access: configuration.access,
+                        ...(session.runnerTitle === null ? {} : { title: session.runnerTitle })
+                    });
+                },
+                workspacePath: this.options.workspacePath,
+                rememberManagedNative: this.options.rememberNative
+            }, force);
+        }
+        finally {
+            this.transitions.delete(external.id);
+        }
         if (result.activity !== undefined)
             this.options.state.externalActivity.set(external.id, result.activity);
         if (result.session !== undefined) {

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

@@ -32,6 +32,7 @@ export declare class NativeSessionProjectionService {
     })[]>;
     discoverWorkspace(workspaceId: string): Promise<readonly NodeAgentSession[]>;
     resolve(sessionId: string): Promise<NodeAgentSession | undefined>;
+    resolveCurrent(sessionId: string): Promise<NodeAgentSession | undefined>;
     createMetadataProjection(sessionId: string): Promise<NodeAgentSession | undefined>;
     resumedConfiguration(session: NodeAgentSession): RunnerDefaultConfiguration;
     ensureResumedConfiguration(session: NodeAgentSession): NodeAgentSession;

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

@@ -81,6 +81,10 @@ export class NativeSessionProjectionService {
             createdAt: 0
         };
     }
+    async resolveCurrent(sessionId) {
+        const direct = await this.resolve(sessionId);
+        return direct === undefined ? undefined : (this.projectionForNative(direct) ?? direct);
+    }
     async createMetadataProjection(sessionId) {
         const direct = await this.resolve(sessionId);
         if (direct === undefined || direct.externalSessionId === null)

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

@@ -6,6 +6,7 @@ export interface NativeSessionWatchOptions<TPage extends {
 }> {
     readonly resolve: (sessionId: string) => Promise<NodeAgentSession | undefined>;
     readonly managedActive: (session: NodeAgentSession) => boolean;
+    readonly suspended?: (sessionId: string) => boolean;
     readonly refreshActivity: (session: NodeAgentSession) => Promise<void>;
     readonly present: (session: NodeAgentSession) => unknown;
     readonly readPage: (session: NodeAgentSession, limit: number) => Promise<TPage>;
@@ -16,6 +17,9 @@ export interface NativeSessionWatchOptions<TPage extends {
     readonly projectInitialPage?: (session: NodeAgentSession, page: TPage, unit: 'SEGMENT', limit: number) => unknown;
     readonly emitSession: (session: unknown) => void;
     readonly emitPage: (session: NodeAgentSession, page: TPage) => void;
+    readonly nodeId?: () => string;
+    readonly nodeGeneration?: () => string;
+    readonly emitWatchEvent?: (payload: unknown) => void;
 }
 export declare class NativeSessionWatchService<TPage extends {
     readonly turns: readonly unknown[];
@@ -23,9 +27,12 @@ export declare class NativeSessionWatchService<TPage extends {
 }> {
     private readonly options;
     private readonly watches;
+    private readonly leases;
+    private snapshotSequence;
     constructor(options: NativeSessionWatchOptions<TPage>);
     operations(): Readonly<Record<string, NodeOperationHandler>>;
     private executeWatch;
+    private executeUnwatch;
     watch(session: NodeAgentSession): {
         readonly expiresAt: number;
     } | undefined;
@@ -41,4 +48,15 @@ export declare class NativeSessionWatchService<TPage extends {
     get size(): number;
     refresh(sessionId: string, limit?: number, emit?: boolean): Promise<TPage | undefined>;
     private performRefresh;
+    private sessionHash;
+    private ownerKey;
+    private accepted;
+    private initializeLease;
+    private removeLease;
+    private emitObservedPage;
+    private failSession;
+    private releaseSessionLeases;
+    private leaseTimer;
+    private latestLeaseExpiry;
+    private refreshTimer;
 }

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

@@ -7,12 +7,15 @@ 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) {
@@ -20,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, false);
-        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)) {
@@ -75,8 +114,7 @@ export class NativeSessionWatchService {
             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 };
     }
@@ -97,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);
@@ -130,20 +171,27 @@ export class NativeSessionWatchService {
             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, 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) {
@@ -172,14 +220,164 @@ export class NativeSessionWatchService {
             watch.signature = signature;
             watch.page = accepted;
             if (emit)
-                this.options.emitPage(session, accepted);
+                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/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

@@ -204,6 +204,9 @@ export class SessionLifecycleService {
                 ...(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,7 +18,6 @@ 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 {