@modelprofile.com/flexharness 10.17.1 → 10.18.0

package/dist_ts_chat_harness_server/classes.chathub.js

@@ -0,0 +1,332 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessChatSessionLists } from './classes.sessionlists.js';
+import { FlexHarnessChatSubscription } from './classes.chatsubscription.js';
+import { FlexHarnessChatTurnGate } from './classes.turngate.js';
+import { FlexHarnessChatRequestError, FlexHarnessChatTabUnavailableError } from './errors.js';
+import { BAD_REQUEST_MESSAGE, STOPPED_MESSAGE, isSameTab, readRandomId, tabKey, readSendDetail, readSessionId, readTitle, titleFromMessage, } from './functions.validation.js';
+const NOT_FOUND_MESSAGE = 'This conversation does not exist.';
+const READ_ONLY_MESSAGE = 'This conversation was imported and can only be read. Start a new conversation to continue.';
+const DECISIONS = ['once', 'always', 'reject'];
+export const defaultFlexHarnessChatLimits = Object.freeze({
+    turnTimeoutMs: 10 * 60 * 1000,
+    admissionWaitMs: 30 * 1000,
+    toolTimeoutMs: 2 * 60 * 1000,
+    maxPendingDeltas: 2_000,
+    maxMessageChars: 100_000,
+    maxAttachments: 16,
+    maxAttachmentChars: 8 * 1024 * 1024,
+    maxTitleChars: 200,
+    sweepIntervalMs: 5 * 60 * 1000,
+});
+/** A conversation as a session list shows it; an imported one says so. */
+export const flexHarnessChatSessionMeta = (sessionArg) => ({
+    ...plugins.flexSessionToHarnessMeta(sessionArg),
+    ...(sessionArg.origin?.kind === 'import' ? { statusLabel: 'Imported' } : {}),
+});
+/**
+ * Serves `dees-harness-chat` conversations of one FlexHarness to browser tabs, over any transport:
+ * a tab attaches, follows one conversation through numbered updates, sends messages that start or
+ * steer a turn, stops turns, answers permission requests, undoes and redoes turns, and renames and
+ * deletes conversations. A turn runs the tools the host gives it; `runClientTool()` runs one in the
+ * tab that started the turn.
+ *
+ * The host authenticates every request and names its caller: the tab and the scope it may reach. A
+ * session of another scope reads as not found. `stop()` stops the turns the hub started, its
+ * subscriptions and its timers; the harness stays the host's.
+ */
+export class FlexHarnessChatHub {
+    limits;
+    harness;
+    peers;
+    readContext;
+    titleOf;
+    gate;
+    sessionLists;
+    subscriptions = new Map();
+    unsubscribe;
+    sweepTimer;
+    /** the requests under way that may start a turn or a subscription; `stop()` waits for them */
+    requestsUnderWay = new Set();
+    /** the sequence of the last harness event the hub received */
+    lastSequence;
+    stopped = false;
+    constructor(optionsArg) {
+        this.limits = Object.freeze({ ...defaultFlexHarnessChatLimits, ...optionsArg.limits });
+        this.harness = optionsArg.harness;
+        this.peers = optionsArg.peers;
+        this.readContext = optionsArg.readContext;
+        this.titleOf = optionsArg.titleOf ?? titleFromMessage;
+        this.gate = new FlexHarnessChatTurnGate(this.harness, this.limits);
+        this.sessionLists = new FlexHarnessChatSessionLists(this.peers, flexHarnessChatSessionMeta);
+        this.unsubscribe = this.harness.subscribe((eventArg) => this.takeEvent(eventArg));
+        this.sweepTimer = setInterval(() => void this.forgetClosedTabs(), this.limits.sweepIntervalMs);
+        this.sweepTimer.unref?.();
+    }
+    // ---------------- requests ----------------
+    /** Attaches a tab: it follows nothing until it opens a conversation again. */
+    async attach(callerArg) {
+        this.assertRunning();
+        this.closeSubscriptionsOf(callerArg);
+        this.sessionLists.attach(callerArg);
+        const sessions = await this.call(() => this.harness.listSessions(callerArg.scopeId));
+        return {
+            sessions: sessions
+                .filter((session) => !session.parentSessionId)
+                .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
+                .map(flexHarnessChatSessionMeta),
+        };
+    }
+    open(callerArg, requestArg) {
+        return this.underWay(() => this.openUnderWay(callerArg, requestArg));
+    }
+    async openUnderWay(callerArg, requestArg) {
+        this.assertRunning();
+        const subscriptionId = readRandomId(requestArg?.subscriptionId);
+        const session = await this.requireSession(callerArg, requestArg.sessionId);
+        this.assertRunning();
+        if (this.subscriptions.has(subscriptionId))
+            throw new FlexHarnessChatRequestError(BAD_REQUEST_MESSAGE);
+        this.closeSubscriptionsOf(callerArg);
+        const subscription = new FlexHarnessChatSubscription({
+            id: subscriptionId,
+            tabId: callerArg.tabId,
+            scopeId: callerArg.scopeId,
+            sessionId: session.sessionId,
+            harness: this.harness,
+            peers: this.peers,
+            limits: this.limits,
+            onClosed: (closedArg) => this.forgetSubscription(closedArg),
+        });
+        // subscribed before the session is read: what changes meanwhile is buffered, not lost
+        this.subscriptions.set(subscriptionId, subscription);
+        try {
+            await subscription.load();
+            this.assertRunning();
+        }
+        catch (error) {
+            this.closeSubscription(subscription);
+            throw this.toRequestError(error);
+        }
+        return { session: flexHarnessChatSessionMeta(session), readOnly: session.origin?.kind === 'import' };
+    }
+    async close(callerArg, requestArg) {
+        const subscription = this.subscriptions.get(requestArg?.subscriptionId);
+        if (subscription && isSameTab(subscription, callerArg))
+            this.closeSubscription(subscription);
+        return {};
+    }
+    send(callerArg, requestArg) {
+        // the wait for a turn that is ending counts from here
+        const deadline = Date.now() + this.limits.admissionWaitMs;
+        return this.underWay(() => this.sendUnderWay(callerArg, requestArg, deadline));
+    }
+    async sendUnderWay(callerArg, requestArg, deadlineArg) {
+        this.assertRunning();
+        const send = readSendDetail(requestArg?.send, this.limits);
+        const context = this.readSendContext(requestArg.context);
+        let sessionId;
+        let created = false;
+        if (requestArg.sessionId === undefined) {
+            sessionId = (await this.call(() => this.harness.createSession(callerArg.scopeId, { title: this.titleOf(send) }))).sessionId;
+            created = true;
+        }
+        else {
+            const session = await this.requireSession(callerArg, requestArg.sessionId);
+            if (session.origin?.kind === 'import')
+                throw new FlexHarnessChatRequestError(READ_ONLY_MESSAGE);
+            sessionId = session.sessionId;
+        }
+        try {
+            // the hub may have stopped while the conversation was read or created
+            this.assertRunning();
+            return await this.gate.admit(callerArg, sessionId, send, context, deadlineArg);
+        }
+        catch (error) {
+            // a conversation created for this message that never got it is not kept
+            if (created && !(error instanceof plugins.FlexHarnessClosedError)) {
+                await this.harness.deleteSession(callerArg.scopeId, sessionId).catch(() => undefined);
+            }
+            throw this.toRequestError(error);
+        }
+    }
+    async abort(callerArg, requestArg) {
+        const session = await this.requireSession(callerArg, requestArg?.sessionId);
+        await this.call(() => this.harness.abort(callerArg.scopeId, session.sessionId));
+        return {};
+    }
+    async respondToPermission(callerArg, requestArg) {
+        const session = await this.requireSession(callerArg, requestArg?.sessionId);
+        if (typeof requestArg.permissionId !== 'string' || !DECISIONS.includes(requestArg.decision)) {
+            throw new FlexHarnessChatRequestError(BAD_REQUEST_MESSAGE);
+        }
+        await this.call(() => this.harness.respondToPermission(callerArg.scopeId, session.sessionId, requestArg.permissionId, requestArg.decision));
+        return {};
+    }
+    async moveHistory(callerArg, requestArg) {
+        const session = await this.requireSession(callerArg, requestArg?.sessionId);
+        if (requestArg.direction === 'undo') {
+            const result = await this.call(() => this.harness.undoSession(callerArg.scopeId, session.sessionId));
+            return { runId: result.revertedRunId };
+        }
+        if (requestArg.direction === 'redo') {
+            const result = await this.call(() => this.harness.redoSession(callerArg.scopeId, session.sessionId));
+            return { runId: result.restoredRunId };
+        }
+        throw new FlexHarnessChatRequestError(BAD_REQUEST_MESSAGE);
+    }
+    async renameSession(callerArg, requestArg) {
+        const title = readTitle(requestArg?.title, this.limits);
+        const session = await this.requireSession(callerArg, requestArg.sessionId);
+        const updated = await this.call(() => this.harness.updateSession(callerArg.scopeId, session.sessionId, { title }));
+        return { session: flexHarnessChatSessionMeta(updated) };
+    }
+    async deleteSession(callerArg, requestArg) {
+        const session = await this.requireSession(callerArg, requestArg?.sessionId);
+        await this.call(() => this.harness.deleteSession(callerArg.scopeId, session.sessionId));
+        return {};
+    }
+    // ---------------- turns ----------------
+    /** The running turn of a conversation; the host's model resolver and tool provider read it. */
+    turnOf(scopeIdArg, sessionIdArg) {
+        return this.gate.turnOf(scopeIdArg, sessionIdArg);
+    }
+    /**
+     * Runs a tool of the turn in the tab that started it and answers with the tab's output. Fails with
+     * `FlexHarnessChatTabUnavailableError` when the tab is gone or does not answer in time.
+     */
+    async runClientTool(turnArg, requestArg, optionsArg = {}) {
+        const peer = await this.peers.find({ tabId: turnArg.tabId, scopeId: turnArg.scopeId });
+        if (!peer)
+            throw new FlexHarnessChatTabUnavailableError();
+        try {
+            return await peer.runTool(requestArg, {
+                timeoutMs: optionsArg.timeoutMs ?? this.limits.toolTimeoutMs,
+                ...(optionsArg.abortSignal ? { abortSignal: optionsArg.abortSignal } : {}),
+            });
+        }
+        catch (error) {
+            if (optionsArg.abortSignal?.aborted)
+                throw error;
+            throw new FlexHarnessChatTabUnavailableError({ cause: error });
+        }
+    }
+    // ---------------- tabs and lifecycle ----------------
+    /** Forgets a tab that is gone: its conversation list and the conversation it followed. */
+    forgetTab(tabArg) {
+        this.closeSubscriptionsOf(tabArg);
+        this.sessionLists.forget(tabArg);
+    }
+    /** Stops the turns the hub started and waits until they ended; clears subscriptions and timers. */
+    async stop() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        clearInterval(this.sweepTimer);
+        this.unsubscribe();
+        for (const subscription of [...this.subscriptions.values()])
+            this.closeSubscription(subscription);
+        this.sessionLists.clear();
+        // requests under way refuse at their next step; the gate refuses and cancels what reaches it
+        await Promise.all([this.gate.stop(), ...this.requestsUnderWay]);
+    }
+    /** Runs a request that may start a turn or a subscription, so that `stop()` can wait for it. */
+    underWay(requestArg) {
+        const request = requestArg();
+        const settled = request.then(() => undefined, () => undefined);
+        this.requestsUnderWay.add(settled);
+        void settled.then(() => this.requestsUnderWay.delete(settled));
+        return request;
+    }
+    takeEvent(eventArg) {
+        const preceding = this.lastSequence;
+        this.lastSequence = eventArg.sequence;
+        this.gate.takeEvent(eventArg);
+        for (const subscription of this.subscriptions.values())
+            subscription.takeEvent(eventArg, preceding);
+        if (eventArg.type === 'session.created' || eventArg.type === 'session.updated' || eventArg.type === 'session.deleted') {
+            if (!eventArg.session.parentSessionId)
+                this.sessionLists.publish(eventArg);
+        }
+    }
+    /** Forgets the tabs that are gone and run no turn; runs every `sweepIntervalMs` on its own. */
+    async forgetClosedTabs() {
+        const tabs = new Map();
+        for (const tab of [...this.sessionLists.tabs, ...this.subscriptions.values()]) {
+            tabs.set(tabKey(tab), { tabId: tab.tabId, scopeId: tab.scopeId });
+        }
+        for (const tab of tabs.values()) {
+            if (this.stopped)
+                return;
+            if (this.gate.hasTurnOf(tab))
+                continue;
+            const peer = await this.peers.find(tab).catch(() => null);
+            if (!peer && !this.gate.hasTurnOf(tab))
+                this.forgetTab(tab);
+        }
+    }
+    closeSubscriptionsOf(tabArg) {
+        for (const subscription of [...this.subscriptions.values()]) {
+            if (isSameTab(subscription, tabArg))
+                this.closeSubscription(subscription);
+        }
+    }
+    closeSubscription(subscriptionArg) {
+        subscriptionArg.close();
+        this.forgetSubscription(subscriptionArg);
+    }
+    forgetSubscription(subscriptionArg) {
+        if (this.subscriptions.get(subscriptionArg.id) === subscriptionArg)
+            this.subscriptions.delete(subscriptionArg.id);
+    }
+    // ---------------- checks and errors ----------------
+    assertRunning() {
+        if (this.stopped)
+            throw new FlexHarnessChatRequestError(STOPPED_MESSAGE);
+    }
+    readSendContext(valueArg) {
+        try {
+            return this.readContext(valueArg ?? null);
+        }
+        catch (error) {
+            if (error instanceof FlexHarnessChatRequestError)
+                throw error;
+            throw new FlexHarnessChatRequestError(BAD_REQUEST_MESSAGE);
+        }
+    }
+    /** A root session of the caller's scope; another scope's session id reads as not found. */
+    async requireSession(callerArg, sessionIdArg) {
+        const sessionId = readSessionId(sessionIdArg, NOT_FOUND_MESSAGE);
+        let session;
+        try {
+            session = await this.harness.getSession(callerArg.scopeId, sessionId);
+        }
+        catch (error) {
+            if (error instanceof plugins.FlexHarnessNotFoundError || error instanceof plugins.FlexHarnessValidationError) {
+                throw new FlexHarnessChatRequestError(NOT_FOUND_MESSAGE);
+            }
+            throw this.toRequestError(error);
+        }
+        if (session.parentSessionId)
+            throw new FlexHarnessChatRequestError(NOT_FOUND_MESSAGE);
+        return session;
+    }
+    async call(fnArg) {
+        try {
+            return await fnArg();
+        }
+        catch (error) {
+            throw this.toRequestError(error);
+        }
+    }
+    /** FlexHarness states its refusals for people; anything else stays an internal error. */
+    toRequestError(errorArg) {
+        if (errorArg instanceof FlexHarnessChatRequestError)
+            return errorArg;
+        if (errorArg instanceof plugins.FlexHarnessClosedError)
+            return new FlexHarnessChatRequestError(STOPPED_MESSAGE);
+        if (errorArg instanceof plugins.FlexHarnessError)
+            return new FlexHarnessChatRequestError(errorArg.message);
+        return errorArg;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.chathub.js","sourceRoot":"","sources":["../ts_chat_harness_server/classes.chathub.ts"],"names":[],"mappings":"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"}

package/dist_ts_chat_harness_server/classes.chatsubscription.d.ts

@@ -0,0 +1,55 @@
+import * as plugins from './plugins.js';
+import type { IFlexHarnessChatLimits, IFlexHarnessChatPeers } from './interfaces.js';
+/** The harness reads a subscription makes. */
+export type TFlexHarnessChatSubscriptionHarness = Pick<plugins.FlexHarness<unknown>, 'getSessionView' | 'getSessionReversionInfo'>;
+export interface IFlexHarnessChatSubscriptionOptions {
+    id: string;
+    tabId: string;
+    scopeId: string;
+    sessionId: string;
+    harness: TFlexHarnessChatSubscriptionHarness;
+    peers: IFlexHarnessChatPeers;
+    limits: IFlexHarnessChatLimits;
+    /** called once when the subscription closes itself: its tab is gone or its session unreadable */
+    onClosed: (subscriptionArg: FlexHarnessChatSubscription) => void;
+}
+/**
+ * One tab following one conversation. A `FlexHarnessTranscript` takes every event of the harness
+ * instance; what changed reaches the tab as numbered updates, one at a time. A transcript that
+ * loses track, or an update the tab does not acknowledge, makes the next update a `reset`.
+ */
+export declare class FlexHarnessChatSubscription {
+    readonly id: string;
+    readonly tabId: string;
+    readonly scopeId: string;
+    readonly sessionId: string;
+    private readonly harness;
+    private readonly peers;
+    private readonly limits;
+    private readonly onClosed;
+    private readonly transcript;
+    /** `loading` buffers events until the transcript holds the session's state */
+    private state;
+    private buffered;
+    private seq;
+    /** the rows as the tab last received them, as JSON, by id */
+    private sentRows;
+    private pending;
+    private sending;
+    private closed;
+    constructor(optionsArg: IFlexHarnessChatSubscriptionOptions);
+    /** Takes one event of the harness instance, in the order the harness emitted them. */
+    takeEvent(eventArg: plugins.TFlexHarnessEvent, precedingArg: number | undefined): void;
+    /** Reads the session into the transcript, replays what changed meanwhile and sends a reset. */
+    load(): Promise<void>;
+    /** Stops following; nothing more reaches the tab. */
+    close(): void;
+    private applyEvent;
+    /** The transcript lost track of the session: read it again; the tab gets a reset. */
+    private reload;
+    /** Sends what is pending, one update at a time, in seq order. */
+    private pump;
+    private takeUpdate;
+    private readHistory;
+    private closeSelf;
+}

package/dist_ts_chat_harness_server/classes.chatsubscription.js

@@ -0,0 +1,236 @@
+import * as plugins from './plugins.js';
+const emptyPending = () => ({
+    reset: false,
+    rows: false,
+    deltas: [],
+    status: false,
+    usage: false,
+    permissions: false,
+    history: false,
+    steers: [],
+});
+const hasPending = (pendingArg) => pendingArg.reset
+    || pendingArg.rows
+    || pendingArg.deltas.length > 0
+    || pendingArg.status
+    || pendingArg.usage
+    || pendingArg.permissions
+    || pendingArg.history
+    || pendingArg.steers.length > 0;
+/**
+ * One tab following one conversation. A `FlexHarnessTranscript` takes every event of the harness
+ * instance; what changed reaches the tab as numbered updates, one at a time. A transcript that
+ * loses track, or an update the tab does not acknowledge, makes the next update a `reset`.
+ */
+export class FlexHarnessChatSubscription {
+    id;
+    tabId;
+    scopeId;
+    sessionId;
+    harness;
+    peers;
+    limits;
+    onClosed;
+    transcript;
+    /** `loading` buffers events until the transcript holds the session's state */
+    state = 'loading';
+    buffered = [];
+    seq = 0;
+    /** the rows as the tab last received them, as JSON, by id */
+    sentRows = new Map();
+    pending = emptyPending();
+    sending = false;
+    closed = false;
+    constructor(optionsArg) {
+        this.id = optionsArg.id;
+        this.tabId = optionsArg.tabId;
+        this.scopeId = optionsArg.scopeId;
+        this.sessionId = optionsArg.sessionId;
+        this.harness = optionsArg.harness;
+        this.peers = optionsArg.peers;
+        this.limits = optionsArg.limits;
+        this.onClosed = optionsArg.onClosed;
+        this.transcript = new plugins.FlexHarnessTranscript({ scopeId: this.scopeId, sessionId: this.sessionId });
+    }
+    /** Takes one event of the harness instance, in the order the harness emitted them. */
+    takeEvent(eventArg, precedingArg) {
+        if (this.closed)
+            return;
+        if (this.state === 'loading')
+            this.buffered.push({ event: eventArg, preceding: precedingArg });
+        else
+            this.applyEvent(eventArg, precedingArg);
+    }
+    /** Reads the session into the transcript, replays what changed meanwhile and sends a reset. */
+    async load() {
+        this.state = 'loading';
+        this.buffered = [];
+        const view = await this.harness.getSessionView(this.scopeId, this.sessionId);
+        if (this.closed)
+            return;
+        this.transcript.load({
+            messages: view.messages,
+            permissions: view.pendingPermissions,
+            session: view.session,
+            sequence: view.sequence,
+        });
+        const buffered = this.buffered;
+        this.buffered = [];
+        this.state = 'live';
+        this.pending = { ...emptyPending(), reset: true, steers: this.pending.steers };
+        for (const entry of buffered) {
+            if (this.state !== 'live') {
+                this.buffered.push(entry);
+                continue;
+            }
+            this.applyEvent(entry.event, entry.preceding);
+        }
+        void this.pump();
+    }
+    /** Stops following; nothing more reaches the tab. */
+    close() {
+        this.closed = true;
+        this.buffered = [];
+    }
+    applyEvent(eventArg, precedingArg) {
+        const change = this.transcript.applyEvent(eventArg, { precedingSequence: precedingArg });
+        if (change.reload) {
+            void this.reload();
+            return;
+        }
+        const pending = this.pending;
+        if (eventArg.scopeId === this.scopeId && eventArg.sessionId === this.sessionId) {
+            if (eventArg.type === 'prompt.steer.applied') {
+                pending.steers.push({ steerId: eventArg.steerId, outcome: 'applied' });
+            }
+            else if (eventArg.type === 'run.finished') {
+                for (const steerId of eventArg.unappliedSteerIds)
+                    pending.steers.push({ steerId, outcome: 'unapplied' });
+                pending.history = true;
+            }
+        }
+        if (change.messages) {
+            // the rows are read when the update is sent; they hold every delta up to then
+            pending.rows = true;
+            pending.deltas = [];
+        }
+        else if (change.deltas.length && !pending.rows) {
+            pending.deltas.push(...change.deltas);
+            if (pending.deltas.length > this.limits.maxPendingDeltas) {
+                pending.rows = true;
+                pending.deltas = [];
+            }
+        }
+        if (change.status)
+            pending.status = true;
+        if (change.usage)
+            pending.usage = true;
+        if (change.permissions)
+            pending.permissions = true;
+        if (hasPending(pending))
+            void this.pump();
+    }
+    /** The transcript lost track of the session: read it again; the tab gets a reset. */
+    async reload() {
+        if (this.state === 'loading' || this.closed)
+            return;
+        try {
+            await this.load();
+        }
+        catch {
+            // the session is gone or unreadable; the tab sees it in its list and opens another
+            this.closeSelf();
+        }
+    }
+    /** Sends what is pending, one update at a time, in seq order. */
+    async pump() {
+        if (this.sending)
+            return;
+        this.sending = true;
+        let inFlight = null;
+        try {
+            while (!this.closed && this.state === 'live' && hasPending(this.pending)) {
+                const peer = await this.peers.find({ tabId: this.tabId, scopeId: this.scopeId });
+                if (!peer) {
+                    this.closeSelf();
+                    return;
+                }
+                if (this.closed || this.state !== 'live')
+                    return;
+                inFlight = await this.takeUpdate();
+                await peer.update(inFlight);
+                inFlight = null;
+            }
+        }
+        catch {
+            // the tab may have missed an update; it starts over with a reset at the next change
+            this.pending = {
+                ...emptyPending(),
+                reset: true,
+                steers: [...(inFlight?.steers ?? []), ...this.pending.steers],
+            };
+        }
+        finally {
+            this.sending = false;
+        }
+    }
+    async takeUpdate() {
+        const pending = this.pending;
+        this.pending = emptyPending();
+        const update = { subscriptionId: this.id, seq: ++this.seq };
+        const reset = pending.reset;
+        const view = reset || pending.rows || pending.status || pending.usage || pending.permissions
+            ? this.transcript.view()
+            : null;
+        if (reset) {
+            update.reset = true;
+            this.sentRows.clear();
+        }
+        if (view && (reset || pending.rows)) {
+            const sent = new Map();
+            const upserts = [];
+            for (const row of view.messages) {
+                const json = JSON.stringify(row);
+                if (this.sentRows.get(row.id) !== json)
+                    upserts.push(row);
+                sent.set(row.id, json);
+            }
+            this.sentRows = sent;
+            update.rows = { upserts, order: view.messages.map((row) => row.id) };
+        }
+        else if (pending.deltas.length) {
+            update.deltas = pending.deltas;
+        }
+        if (view && (reset || pending.status))
+            update.status = view.status;
+        if (view && (reset || pending.usage))
+            update.usage = view.usage;
+        if (view && (reset || pending.permissions))
+            update.permissions = view.permissions;
+        if (reset || pending.history) {
+            const history = await this.readHistory();
+            if (history)
+                update.history = history;
+        }
+        if (pending.steers.length)
+            update.steers = pending.steers;
+        return update;
+    }
+    async readHistory() {
+        try {
+            const info = await this.harness.getSessionReversionInfo(this.scopeId, this.sessionId);
+            return { undoAvailable: info.undoAvailable, redoAvailable: info.redoAvailable };
+        }
+        catch {
+            // the session is being deleted; its next state reaches the tab through the session list
+            return undefined;
+        }
+    }
+    closeSelf() {
+        if (this.closed)
+            return;
+        this.close();
+        this.onClosed(this);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.chatsubscription.js","sourceRoot":"","sources":["../ts_chat_harness_server/classes.chatsubscription.ts"],"names":[],"mappings":"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"}