@myagentroam/node 0.9.2 → 0.9.4

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-connection-lifecycle-service.d.ts

@@ -3,7 +3,6 @@ import { type NodeConfig } from '../config.js';
 import type { NodeMetrics } from '../operational.js';
 import type { NodeControlChannel } from './node-control-channel.js';
 import type { NodeTerminalChannel } from './node-terminal-channel.js';
-import type { WorkbenchEventService } from './workbench-event-service.js';
 interface NodeConnectionLifecycleServiceOptions {
     readonly config: () => NodeConfig | undefined;
     readonly setConfig: (config: NodeConfig) => void;
@@ -15,7 +14,6 @@ interface NodeConnectionLifecycleServiceOptions {
     readonly setCapabilities: (capabilities: NodeCapabilities) => void;
     readonly control: NodeControlChannel;
     readonly terminal: NodeTerminalChannel;
-    readonly events: WorkbenchEventService;
     readonly metrics: NodeMetrics;
     readonly heartbeatMs: number;
     readonly refreshMs: number;

package/dist/service/node-connection-lifecycle-service.js

@@ -48,7 +48,6 @@ export class NodeConnectionLifecycleService {
         this.options.terminal.connect();
         this.options.control.send('heartbeat', {});
         this.options.metrics.heartbeatSent();
-        this.options.events.replay();
         this.heartbeat = setInterval(() => {
             this.options.metrics.heartbeatSent();
             this.options.control.send('heartbeat', {});

package/dist/service/node-control-channel.js

@@ -5,7 +5,7 @@ import { nodeConnectEndpoint } from '../runner/codex/conversation-parser.js';
 export class NodeControlChannel {
     options;
     socket;
-    outbound = new ControlOutboundScheduler(() => this.socket);
+    outbound = new ControlOutboundScheduler(() => this.socket, () => this.socket?.close(1013, 'NODE_CONTROL_BACKPRESSURE_TIMEOUT'));
     reconnectTimer;
     attempts = 0;
     constructor(options) {

package/dist/service/node-control-message-service.d.ts

@@ -8,7 +8,6 @@ interface NodeControlMessageServiceOptions {
     readonly close: (code: number, reason: string) => void;
     readonly inspectWorkspace: (envelope: NodeEnvelope) => Promise<void>;
     readonly handleNodeRequest: (envelope: NodeEnvelope) => Promise<void>;
-    readonly acknowledgeWorkbenchEvent: (replyTo: string | undefined) => void;
     readonly reconcileRuns: (envelope: NodeEnvelope) => void;
     readonly runners: RunnerRegistry;
     readonly deliverSessionChannelMessage: (envelope: NodeEnvelope) => void;

package/dist/service/node-control-message-service.js

@@ -33,12 +33,8 @@ export class NodeControlMessageService {
             void this.options.handleNodeRequest(envelope);
             return;
         }
-        if (envelope.type === 'ack') {
-            const payload = envelope.payload;
-            if (payload.type === 'workbench.event')
-                this.options.acknowledgeWorkbenchEvent(envelope.replyTo);
+        if (envelope.type === 'ack')
             return;
-        }
         if (envelope.type === 'runs.reconcile') {
             this.options.reconcileRuns(envelope);
             return;
@@ -49,7 +45,14 @@ export class NodeControlMessageService {
         }
         if (envelope.type === 'run.start') {
             this.options.send('ack', { type: envelope.type }, envelope.id);
-            this.options.runners.startManagedRun(envelope);
+            try {
+                this.options.runners.startManagedRun(envelope);
+            }
+            catch (error) {
+                // A delayed internal start may arrive after the terminal projection was removed.
+                if (!(error instanceof Error) || error.message !== 'RUN_TERMINAL')
+                    throw error;
+            }
             return;
         }
         if (envelope.type === 'session.channel.message') {

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/node-workspace-coordinator.d.ts

@@ -1,7 +1,6 @@
 import type { NodeEnvelope } from '@myagentroam/protocol';
 import type { NodeConfig } from '../config.js';
 import type { NodeAgentSession, NodeDatabase, NodeWorkspace } from '../database.js';
-import type { NodeRuntimeState } from '../runtime-state.js';
 import type { TerminalSummary } from '../terminal.js';
 import type { WorkspaceChangeService } from './workspace-change-service.js';
 import type { WorkspaceSessionService } from './workspace-session-service.js';
@@ -9,14 +8,13 @@ import type { WorkspaceWatchService } from './workspace-watch-service.js';
 interface NodeWorkspaceCoordinatorOptions {
     readonly config: () => NodeConfig | undefined;
     readonly database: () => NodeDatabase | undefined;
-    readonly runtime: NodeRuntimeState;
     readonly watches: WorkspaceWatchService;
     readonly sessions: WorkspaceSessionService;
     readonly changes: WorkspaceChangeService;
     readonly emit: (workspaceId: string, topic: 'files' | 'changes', revision: number) => void;
     readonly send: (type: string, payload: unknown, replyTo?: string) => void;
 }
-/** Coordinates Workspace invalidation, inspection, snapshots and persisted Terminal summaries. */
+/** Coordinates Workspace invalidation, inspection and persisted Terminal summaries. */
 export declare class NodeWorkspaceCoordinator {
     private readonly options;
     constructor(options: NodeWorkspaceCoordinatorOptions);
@@ -27,6 +25,5 @@ export declare class NodeWorkspaceCoordinator {
     invalidateChanges(workspaceId: string): void;
     persistTerminal(summary: TerminalSummary): void;
     inspect(envelope: NodeEnvelope): Promise<void>;
-    captureRunSnapshot(runId: string, cwd: string): Promise<void>;
 }
 export {};

package/dist/service/node-workspace-coordinator.js

@@ -1,5 +1,5 @@
-import { inspectWorkspace, readGitSummary } from '../workspace.js';
-/** Coordinates Workspace invalidation, inspection, snapshots and persisted Terminal summaries. */
+import { inspectWorkspace } from '../workspace.js';
+/** Coordinates Workspace invalidation, inspection and persisted Terminal summaries. */
 export class NodeWorkspaceCoordinator {
     options;
     constructor(options) {
@@ -67,14 +67,4 @@ export class NodeWorkspaceCoordinator {
             this.options.send('workspace.inspect.result', { error: 'WORKSPACE_INVALID' }, envelope.id);
         }
     }
-    async captureRunSnapshot(runId, cwd) {
-        try {
-            const snapshot = await readGitSummary(cwd);
-            this.options.runtime.saveSnapshot(runId, snapshot);
-            this.options.send('workspace.snapshot', { runId, snapshot });
-        }
-        catch {
-            // Ordinary directories have no Git snapshot and keep the existing Run result.
-        }
-    }
 }

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

@@ -4,6 +4,7 @@ import { lstat, mkdir, mkdtemp, readFile, realpath, rm, writeFile } from 'node:f
 import { AttachmentDomainState } from './attachment-domain-state.js';
 const MAX_ATTACHMENT_BYTES = 5 * 1024 * 1024;
 const IMAGE_CACHE_TTL_MS = 60 * 60_000;
+const NATIVE_IMAGE_INDEX_TTL_MS = 60 * 60_000;
 export class RunAttachmentService {
     nativeImageRoots;
     state = new AttachmentDomainState();
@@ -43,21 +44,28 @@ export class RunAttachmentService {
             throw new Error('MESSAGE_ATTACHMENT_DIRECTORY_INVALID');
         const runDirectory = join(filesDirectory, runId);
         await mkdir(runDirectory, { mode: 0o700 });
+        this.state.runFileDirectories.set(runId, runDirectory);
         try {
             await Promise.all(attachments.map((attachment) => writeFile(join(runDirectory, attachment.name), Buffer.from(attachment.dataBase64, 'base64'), { flag: 'wx', mode: 0o600 })));
             return attachments.map((attachment) => `.mar/temp-files/${runId}/${attachment.name}`);
         }
         catch (error) {
+            this.state.runFileDirectories.delete(runId);
             await rm(runDirectory, { recursive: true, force: true });
             throw error;
         }
     }
     cleanup(runId) {
         const directory = this.state.runDirectories.get(runId);
-        if (directory === undefined)
-            return;
-        this.state.runDirectories.delete(runId);
-        void rm(directory, { recursive: true, force: true }).catch(() => undefined);
+        if (directory !== undefined) {
+            this.state.runDirectories.delete(runId);
+            void rm(directory, { recursive: true, force: true }).catch(() => undefined);
+        }
+        const fileDirectory = this.state.runFileDirectories.get(runId);
+        if (fileDirectory !== undefined) {
+            this.state.runFileDirectories.delete(runId);
+            void rm(fileDirectory, { recursive: true, force: true }).catch(() => undefined);
+        }
     }
     cache(runId, images) {
         if (images.length === 0)
@@ -122,8 +130,18 @@ export class RunAttachmentService {
             }
             attachments.push({ name: image.name, mime: image.mime, runId, imageIndex });
         }
-        if (sources.length > 0)
+        if (sources.length > 0) {
             this.state.nativeHistoryImages.set(runId, sources);
+            const previousTimer = this.state.nativeHistoryImageTimers.get(runId);
+            if (previousTimer !== undefined)
+                clearTimeout(previousTimer);
+            const timer = setTimeout(() => {
+                this.state.nativeHistoryImageTimers.delete(runId);
+                this.state.nativeHistoryImages.delete(runId);
+            }, NATIVE_IMAGE_INDEX_TTL_MS);
+            timer.unref();
+            this.state.nativeHistoryImageTimers.set(runId, timer);
+        }
         return attachments;
     }
     async readNative(runId, imageIndex) {
@@ -161,10 +179,16 @@ export class RunAttachmentService {
         this.state.runImages.delete(runId);
     }
     dispose() {
-        for (const runId of this.state.runDirectories.keys())
+        for (const runId of new Set([
+            ...this.state.runDirectories.keys(),
+            ...this.state.runFileDirectories.keys()
+        ]))
             this.cleanup(runId);
         for (const runId of this.state.runImages.keys())
             this.clear(runId);
+        for (const timer of this.state.nativeHistoryImageTimers.values())
+            clearTimeout(timer);
+        this.state.nativeHistoryImageTimers.clear();
         this.state.nativeHistoryImages.clear();
     }
 }

package/dist/service/run-event-service.d.ts

@@ -29,4 +29,5 @@ export declare class RunEventService {
     private enqueueText;
     private flushText;
     private emitNow;
+    private notificationPayload;
 }

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

@@ -50,6 +50,9 @@ export class RunEventService {
         this.emitNow(runId, 'text.delta', { text: pending.text });
     }
     emitNow(runId, eventType, payload, status) {
+        if (this.options.runtime.getRun(runId) === undefined)
+            return;
+        const notificationPayload = this.notificationPayload(runId, eventType, payload, status);
         const event = {
             runId,
             sequence: (this.sequences.get(runId) ?? 0) + 1,
@@ -76,6 +79,7 @@ export class RunEventService {
             /* A stale relayed run may race the storage boundary. */
         }
         if (status !== undefined && isTerminalRunStatus(status)) {
+            this.options.state.active.delete(runId);
             this.options.state.interruptRequested.delete(runId);
             const terminalRun = this.options.runtime.getRun(runId);
             if (terminalRun !== undefined && this.options.isBootstrapSession(terminalRun.sessionId))
@@ -91,6 +95,19 @@ export class RunEventService {
         this.options.emitWorkbench('conversation', {
             event: { ...event, createdAt: 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);
@@ -102,7 +119,70 @@ export class RunEventService {
         const run = this.options.runtime.getRun(runId);
         if (run !== undefined) {
             this.options.scheduleContextRefresh(run.sessionId);
+            this.options.runtime.removeTerminalRun(runId);
+            this.sequences.delete(runId);
             void this.options.dispatchQueue(run.sessionId);
         }
     }
+    notificationPayload(runId, eventType, payload, status) {
+        if (eventType === 'notification')
+            return undefined;
+        const run = this.options.runtime.getRun(runId);
+        if (run === undefined)
+            return undefined;
+        const session = this.options.runtime.getAgentSession(run.sessionId);
+        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;
+            if (status === 'SUCCEEDED' &&
+                this.options.runtime.sessionQueue(run.sessionId).runIds.length > 0)
+                return undefined;
+            return {
+                ...base,
+                notificationId: `run:${run.workspaceId}:${runId}`,
+                kind: 'RUN_TERMINAL',
+                outcome: status
+            };
+        }
+        if (eventType === 'approval.request' && isPlainRecord(payload)) {
+            const approvalId = payload.approvalId;
+            if (typeof approvalId !== 'string')
+                return undefined;
+            return {
+                ...base,
+                notificationId: `approval:${run.workspaceId}:${runId}:${approvalId}`,
+                kind: 'APPROVAL_REQUIRED'
+            };
+        }
+        if (eventType !== 'conversation.item' || !isPlainRecord(payload))
+            return undefined;
+        if (payload.kind === 'plan' && typeof payload.itemId === 'string')
+            return {
+                ...base,
+                notificationId: `plan:${run.workspaceId}:${runId}:${payload.itemId}`,
+                kind: 'PLAN_READY'
+            };
+        if (payload.kind === 'user_input_request' &&
+            typeof payload.itemId === 'string' &&
+            isPlainRecord(payload.payload) &&
+            Array.isArray(payload.payload.questions) &&
+            payload.payload.questions.length > 0)
+            return {
+                ...base,
+                notificationId: `user-input:${run.workspaceId}:${runId}:${payload.itemId}`,
+                kind: 'USER_INPUT_REQUIRED'
+            };
+        return undefined;
+    }
 }

package/dist/service/run-workbench-service.d.ts

@@ -6,6 +6,7 @@ export interface RunWorkbenchServiceOptions {
     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 emitRun: (runId: string, eventType: string, payload: unknown, status?: 'CANCELLED') => void;
     readonly control: (operation: string, payload: Record<string, unknown>) => void;
@@ -16,7 +17,6 @@ export declare class RunWorkbenchService {
     constructor(options: RunWorkbenchServiceOptions);
     operations(): Readonly<Record<string, NodeOperationHandler>>;
     private get;
-    private snapshot;
     private image;
     private respond;
     private interruptSession;

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

@@ -8,7 +8,6 @@ export class RunWorkbenchService {
     operations() {
         return {
             'run.get': (data) => this.get(record(data)),
-            'run.snapshot': (data) => this.snapshot(record(data)),
             'run.image.read': (data) => this.image(record(data)),
             'run.user-input.respond': (data) => this.respond(record(data)),
             'session.interrupt': (data) => this.interruptSession(record(data)),
@@ -21,10 +20,6 @@ export class RunWorkbenchService {
     get(input) {
         return { run: this.requireRun(input.runId) };
     }
-    snapshot(input) {
-        const run = this.requireRun(input.runId);
-        return { snapshot: this.options.runtime.getSnapshot(run.id) ?? null };
-    }
     async image(input) {
         if (typeof input.runId !== 'string' ||
             typeof input.imageIndex !== 'number' ||
@@ -63,6 +58,7 @@ export class RunWorkbenchService {
             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);
             return { cancelled: true };
         }

package/dist/service/runner-interaction-service.d.ts

@@ -13,7 +13,6 @@ interface RunnerInteractionServiceOptions {
     readonly runners: RunnerRegistry;
     readonly emitRun: (runId: string, eventType: string, payload: unknown, status?: 'FAILED' | 'CANCELLED' | 'INTERRUPTED') => void;
     readonly emitItem: (runId: string, item: PublicConversationItem) => void;
-    readonly captureSnapshot: (runId: string, cwd: string) => Promise<void>;
     readonly approvalTimeoutMs: number;
     readonly publishApproval: (input: {
         readonly runId: string;
@@ -33,7 +32,7 @@ export declare class RunnerInteractionService {
     cancelClaudeRun(runId: string, intent: 'CANCEL' | 'INTERRUPT'): boolean;
     cancelCodexTurn(runId: string, threadId: string, turnId: string, cwd: string, terminalStatus: 'CANCELLED' | 'INTERRUPTED'): Promise<void>;
     respondUserInput(runId: string, requestId: string, rawAnswers: Record<string, unknown>): void;
-    completeCancelledRun(runId: string, cwd: string | undefined): boolean;
+    completeCancelledRun(runId: string): boolean;
     private respondCodexUserInput;
     private answers;
 }

package/dist/service/runner-interaction-service.js

@@ -162,7 +162,6 @@ export class RunnerInteractionService {
             codex.execution.runs.delete(runId);
             codex.releaseEnvironment(runId);
             this.options.state.active.delete(runId);
-            void this.options.captureSnapshot(runId, cwd);
         }
     }
     respondUserInput(runId, requestId, rawAnswers) {
@@ -194,7 +193,7 @@ export class RunnerInteractionService {
             merge: true
         });
     }
-    completeCancelledRun(runId, cwd) {
+    completeCancelledRun(runId) {
         const run = this.options.runtime.getRun(runId);
         if (run === undefined)
             return false;
@@ -206,8 +205,6 @@ export class RunnerInteractionService {
             return false;
         this.options.codex().execution.runs.delete(runId);
         this.options.state.active.delete(runId);
-        if (cwd !== undefined)
-            void this.options.captureSnapshot(runId, cwd);
         return true;
     }
     respondCodexUserInput(runId, requestId, rawAnswers) {

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

@@ -24,6 +24,7 @@ export interface SessionContextServiceOptions {
 export declare class SessionContextService {
     private readonly options;
     private readonly snapshots;
+    private readonly snapshotTimers;
     private readonly timers;
     private readonly versions;
     constructor(options: SessionContextServiceOptions);

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

@@ -1,7 +1,9 @@
 const REFRESH_DELAYS_MS = [100, 400, 1_000];
+const CONTEXT_SNAPSHOT_TTL_MS = 30 * 60_000;
 export class SessionContextService {
     options;
     snapshots = new Map();
+    snapshotTimers = new Map();
     timers = new Map();
     versions = new Map();
     constructor(options) {
@@ -20,6 +22,15 @@ export class SessionContextService {
             percentage: Math.round((usage.usedTokens / usage.maxTokens) * 1000) / 10
         };
         this.snapshots.set(session.id, context);
+        const previousTimer = this.snapshotTimers.get(session.id);
+        if (previousTimer !== undefined)
+            clearTimeout(previousTimer);
+        const timer = setTimeout(() => {
+            this.snapshotTimers.delete(session.id);
+            this.snapshots.delete(session.id);
+        }, CONTEXT_SNAPSHOT_TTL_MS);
+        timer.unref();
+        this.snapshotTimers.set(session.id, timer);
         return { context, pending: false };
     }
     schedule(sessionId) {
@@ -71,7 +82,10 @@ export class SessionContextService {
     dispose() {
         for (const timer of this.timers.values())
             clearTimeout(timer);
+        for (const timer of this.snapshotTimers.values())
+            clearTimeout(timer);
         this.timers.clear();
+        this.snapshotTimers.clear();
         this.versions.clear();
         this.snapshots.clear();
     }

package/dist/service/session-domain-state.d.ts

@@ -5,4 +5,5 @@ export declare class SessionDomainState<TSession, TActivity> {
     readonly resumeFailures: Map<string, string>;
     readonly messageResumeFailures: Map<string, string>;
     readonly resumeFailureDetails: Map<string, string>;
+    readonly failureTimers: Map<string, NodeJS.Timeout>;
 }

package/dist/service/session-domain-state.js

@@ -5,4 +5,5 @@ export class SessionDomainState {
     resumeFailures = new Map();
     messageResumeFailures = new Map();
     resumeFailureDetails = new Map();
+    failureTimers = new Map();
 }

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;