@codingame/monaco-vscode-chat-service-override 37.2.0 → 37.3.0

package/vscode/src/vs/platform/agentHost/common/state/agentSubscription.js

@@ -1,803 +0,0 @@
-
-import { assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
-import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
-import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
-import { isSessionAction, isChatAction, isChangesetAction, isAnnotationsAction } from './sessionActions.js';
-import { rootReducer } from './protocol/channels-root/reducer.js';
-import { sessionReducer } from './protocol/channels-session/reducer.js';
-import { chatReducer } from './protocol/channels-chat/reducer.js';
-import { terminalReducer } from './protocol/channels-terminal/reducer.js';
-import { changesetReducer } from './protocol/channels-changeset/reducer.js';
-import { annotationsReducer } from './protocol/channels-annotations/reducer.js';
-import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
-import { automationReducer } from './protocol/channels-automation/reducer.js';
-import { automationRunReducer } from './protocol/channels-automation-run/reducer.js';
-import '@codingame/monaco-vscode-katex-common/vscode/vs/platform/agentHost/common/meta/agentPermissionRequestMeta';
-import { isAhpRootChannel, isAhpAutomationCatalogChannel, isAhpAutomationRunChannel, StateComponents } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
-import { normalizeLegacyChatStateErrors } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/legacyProtocolCompatibility';
-import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
-
-class BaseAgentSubscription extends Disposable {
-    constructor(clientId, log) {
-        super();
-        this._awaitingSnapshotRefresh = false;
-        this._onDidChange = this._register(( new Emitter()));
-        this.onDidChange = this._onDidChange.event;
-        this._onDidError = this._register(( new Emitter()));
-        this.onDidError = this._onDidError.event;
-        this._onWillApplyAction = this._register(( new Emitter()));
-        this.onWillApplyAction = this._onWillApplyAction.event;
-        this._onDidApplyAction = this._register(( new Emitter()));
-        this.onDidApplyAction = this._onDidApplyAction.event;
-        this._clientId = clientId;
-        this._log = log;
-    }
-    get value() {
-        if (this._error) {
-            return this._error;
-        }
-        return this._getOptimisticState() ?? this._confirmedState;
-    }
-    get verifiedValue() {
-        return this._confirmedState;
-    }
-    handleSnapshot(state, fromSeq) {
-        this._awaitingSnapshotRefresh = false;
-        this._confirmedState = state;
-        this._error = undefined;
-        this._onSnapshotApplied(fromSeq);
-        this._onDidChange.fire(this.value);
-    }
-    beginSnapshotRefresh() {
-        this._awaitingSnapshotRefresh = true;
-    }
-    cancelSnapshotRefresh() {
-        if (!this._awaitingSnapshotRefresh) {
-            return;
-        }
-        this._awaitingSnapshotRefresh = false;
-        const buffered = this._bufferedEnvelopes;
-        if (!buffered || this._confirmedState === undefined) {
-            return;
-        }
-        this._bufferedEnvelopes = undefined;
-        for (const envelope of buffered) {
-            this._reconcile(envelope, envelope.origin?.clientId === this._clientId);
-        }
-        this._onDidChange.fire(this.value);
-    }
-    setError(error) {
-        this._error = error;
-        this._onDidError.fire(error);
-    }
-    receiveEnvelope(envelope) {
-        if (!this._isRelevantEnvelope(envelope)) {
-            return;
-        }
-        if (this._confirmedState === undefined || this._awaitingSnapshotRefresh) {
-            if (!this._bufferedEnvelopes) {
-                this._bufferedEnvelopes = [];
-            }
-            this._bufferedEnvelopes.push(envelope);
-            return;
-        }
-        const isOwnAction = envelope.origin?.clientId === this._clientId;
-        this._onWillApplyAction.fire(envelope);
-        this._reconcile(envelope, isOwnAction);
-        this._onDidApplyAction.fire(envelope);
-    }
-    _getOptimisticState() {
-        return undefined;
-    }
-    _onSnapshotApplied(_fromSeq) {
-        const buffered = this._bufferedEnvelopes;
-        if (buffered) {
-            this._bufferedEnvelopes = undefined;
-            for (const envelope of buffered) {
-                if (envelope.serverSeq > _fromSeq) {
-                    const isOwnAction = envelope.origin?.clientId === this._clientId;
-                    this._reconcile(envelope, isOwnAction);
-                }
-            }
-        }
-    }
-    _reconcile(envelope, _isOwnAction) {
-        if (envelope.rejectionReason) {
-            return;
-        }
-        this._confirmedState = this._applyReducer(this._confirmedState, envelope.action);
-        this._onDidChange.fire(this.value);
-    }
-}
-class RootStateSubscription extends BaseAgentSubscription {
-    _applyReducer(state, action) {
-        return rootReducer(state, action, this._log);
-    }
-    _isRelevantEnvelope(envelope) {
-        return isAhpRootChannel(envelope.channel) && envelope.action.type.startsWith("root/");
-    }
-}
-class SessionStateSubscription extends BaseAgentSubscription {
-    constructor(sessionUri, clientId, seqAllocator, log) {
-        super(clientId, log);
-        this._pendingActions = [];
-        this._sessionUri = sessionUri;
-        this._seqAllocator = seqAllocator;
-    }
-    applyOptimistic(action) {
-        const clientSeq = this._seqAllocator();
-        this._pendingActions.push({
-            clientSeq,
-            action
-        });
-        const base = this._optimisticState ?? this.verifiedValue;
-        if (base) {
-            this._optimisticState = sessionReducer(base, action, this._log);
-            this._onDidChange.fire(this._optimisticState);
-        }
-        return clientSeq;
-    }
-    _getOptimisticState() {
-        return this._optimisticState;
-    }
-    _applyReducer(state, action) {
-        return sessionReducer(state, action, this._log);
-    }
-    _isRelevantEnvelope(envelope) {
-        return isSessionAction(envelope.action) && envelope.channel === this._sessionUri;
-    }
-    _onSnapshotApplied(fromSeq) {
-        super._onSnapshotApplied(fromSeq);
-        this._recomputeOptimistic();
-    }
-    _reconcile(envelope, isOwnAction) {
-        if (isOwnAction && envelope.origin) {
-            const idx = this._pendingActions.findIndex(p => p.clientSeq === envelope.origin.clientSeq);
-            if (idx !== -1) {
-                if (!envelope.rejectionReason) {
-                    this._confirmedApply(envelope.action);
-                }
-                this._pendingActions.splice(idx, 1);
-            } else if (!envelope.rejectionReason) {
-                this._confirmedApply(envelope.action);
-            }
-        } else if (!envelope.rejectionReason) {
-            this._confirmedApply(envelope.action);
-        }
-        this._recomputeOptimistic();
-    }
-    _confirmedApply(action) {
-        if (this._confirmedState) {
-            this._confirmedState = this._applyReducer(this._confirmedState, action);
-        }
-    }
-    _recomputeOptimistic() {
-        const confirmed = this._confirmedState;
-        if (!confirmed) {
-            this._optimisticState = undefined;
-            return;
-        }
-        if (this._pendingActions.length === 0) {
-            this._optimisticState = undefined;
-            this._onDidChange.fire(confirmed);
-            return;
-        }
-        let state = confirmed;
-        for (const pending of this._pendingActions) {
-            state = sessionReducer(state, pending.action, this._log);
-        }
-        this._optimisticState = state;
-        this._onDidChange.fire(state);
-    }
-    clearPending() {
-        this._pendingActions.length = 0;
-        this._optimisticState = undefined;
-    }
-    getPendingActions() {
-        return ( this._pendingActions.map(p => ({
-            clientSeq: p.clientSeq,
-            action: p.action,
-            channel: this._sessionUri
-        })));
-    }
-    dropPendingByClientSeq(clientSeq) {
-        const idx = this._pendingActions.findIndex(p => p.clientSeq === clientSeq);
-        if (idx === -1) {
-            return false;
-        }
-        this._pendingActions.splice(idx, 1);
-        return true;
-    }
-}
-class ChatStateSubscription extends BaseAgentSubscription {
-    constructor(chatUri, clientId, seqAllocator, log) {
-        super(clientId, log);
-        this._pendingActions = [];
-        this._chatUri = chatUri;
-        this._seqAllocator = seqAllocator;
-    }
-    handleSnapshot(state, fromSeq) {
-        super.handleSnapshot(normalizeLegacyChatStateErrors(state), fromSeq);
-    }
-    applyOptimistic(action) {
-        const clientSeq = this._seqAllocator();
-        this._pendingActions.push({
-            clientSeq,
-            action
-        });
-        const base = this._optimisticState ?? this.verifiedValue;
-        if (base) {
-            this._optimisticState = chatReducer(base, action, this._log);
-            this._onDidChange.fire(this._optimisticState);
-        }
-        return clientSeq;
-    }
-    _getOptimisticState() {
-        return this._optimisticState;
-    }
-    _applyReducer(state, action) {
-        return chatReducer(state, action, this._log);
-    }
-    _isRelevantEnvelope(envelope) {
-        return isChatAction(envelope.action) && envelope.channel === this._chatUri;
-    }
-    _onSnapshotApplied(fromSeq) {
-        super._onSnapshotApplied(fromSeq);
-        this._recomputeOptimistic();
-    }
-    _reconcile(envelope, isOwnAction) {
-        if (isOwnAction && envelope.origin) {
-            const idx = this._pendingActions.findIndex(p => p.clientSeq === envelope.origin.clientSeq);
-            if (idx !== -1) {
-                if (!envelope.rejectionReason) {
-                    this._confirmedApply(envelope.action);
-                }
-                this._pendingActions.splice(idx, 1);
-            } else if (!envelope.rejectionReason) {
-                this._confirmedApply(envelope.action);
-            }
-        } else if (!envelope.rejectionReason) {
-            this._promotePendingTurnStartIfTerminal(envelope.action);
-            this._confirmedApply(envelope.action);
-        }
-        this._recomputeOptimistic();
-    }
-    _promotePendingTurnStartIfTerminal(action) {
-        if (!isChatAction(action)) {
-            return;
-        }
-        if (action.type !== ActionType.ChatTurnComplete && action.type !== ActionType.ChatTurnCancelled && action.type !== ActionType.ChatError) {
-            return;
-        }
-        const index = this._pendingActions.findIndex(
-            p => p.action.type === ActionType.ChatTurnStarted && p.action.turnId === action.turnId
-        );
-        if (index === -1) {
-            return;
-        }
-        const [{
-            action: pendingAction
-        }] = this._pendingActions.splice(index, 1);
-        if (this._confirmedState && (!this._confirmedState.activeTurn || this._confirmedState.activeTurn.id !== action.turnId)) {
-            this._confirmedState = this._applyReducer(this._confirmedState, pendingAction);
-        }
-    }
-    _confirmedApply(action) {
-        if (this._confirmedState) {
-            this._confirmedState = this._applyReducer(this._confirmedState, action);
-        }
-    }
-    _recomputeOptimistic() {
-        const confirmed = this._confirmedState;
-        if (!confirmed) {
-            this._optimisticState = undefined;
-            return;
-        }
-        if (this._pendingActions.length === 0) {
-            this._optimisticState = undefined;
-            this._onDidChange.fire(confirmed);
-            return;
-        }
-        let state = confirmed;
-        for (const pending of this._pendingActions) {
-            state = chatReducer(state, pending.action, this._log);
-        }
-        this._optimisticState = state;
-        this._onDidChange.fire(state);
-    }
-    clearPending() {
-        this._pendingActions.length = 0;
-        this._optimisticState = undefined;
-    }
-    getPendingActions() {
-        return ( this._pendingActions.map(p => ({
-            clientSeq: p.clientSeq,
-            action: p.action,
-            channel: this._chatUri
-        })));
-    }
-    dropPendingByClientSeq(clientSeq) {
-        const idx = this._pendingActions.findIndex(p => p.clientSeq === clientSeq);
-        if (idx === -1) {
-            return false;
-        }
-        this._pendingActions.splice(idx, 1);
-        return true;
-    }
-}
-class TerminalStateSubscription extends BaseAgentSubscription {
-    constructor(terminalUri, clientId, log) {
-        super(clientId, log);
-        this._terminalUri = terminalUri;
-    }
-    _applyReducer(state, action) {
-        return terminalReducer(state, action, this._log);
-    }
-    _isRelevantEnvelope(envelope) {
-        return envelope.action.type.startsWith("terminal/") && envelope.channel === this._terminalUri;
-    }
-}
-class AutomationCatalogSubscription extends BaseAgentSubscription {
-    constructor(clientId, log) {
-        super(clientId, log);
-    }
-    _applyReducer(state, action) {
-        return automationReducer(state, action, this._log);
-    }
-    _isRelevantEnvelope(envelope) {
-        return isAhpAutomationCatalogChannel(envelope.channel);
-    }
-    _reconcile(envelope, isOwnAction) {
-        if (!envelope.rejectionReason) {
-            super._reconcile(envelope, isOwnAction);
-        }
-    }
-}
-class AutomationRunSubscription extends BaseAgentSubscription {
-    constructor(resource, clientId, log) {
-        super(clientId, log);
-        this._resource = resource;
-    }
-    _applyReducer(state, action) {
-        return automationRunReducer(state, action, this._log);
-    }
-    _isRelevantEnvelope(envelope) {
-        return isAhpAutomationRunChannel(envelope.channel) && envelope.channel === this._resource;
-    }
-    _reconcile(envelope, isOwnAction) {
-        if (!envelope.rejectionReason) {
-            super._reconcile(envelope, isOwnAction);
-        }
-    }
-}
-class ChangesetStateSubscription extends BaseAgentSubscription {
-    constructor(changesetUri, clientId, seqAllocator, log) {
-        super(clientId, log);
-        this._pendingActions = [];
-        this._changesetUri = changesetUri;
-        this._seqAllocator = seqAllocator;
-    }
-    applyOptimistic(action) {
-        const clientSeq = this._seqAllocator();
-        this._pendingActions.push({
-            clientSeq,
-            action
-        });
-        const base = this._optimisticState ?? this.verifiedValue;
-        if (base) {
-            this._optimisticState = changesetReducer(base, action, this._log);
-            this._onDidChange.fire(this._optimisticState);
-        }
-        return clientSeq;
-    }
-    _getOptimisticState() {
-        return this._optimisticState;
-    }
-    _applyReducer(state, action) {
-        return changesetReducer(state, action, this._log);
-    }
-    _isRelevantEnvelope(envelope) {
-        return isChangesetAction(envelope.action) && envelope.channel === this._changesetUri;
-    }
-    _onSnapshotApplied(fromSeq) {
-        super._onSnapshotApplied(fromSeq);
-        this._recomputeOptimistic();
-    }
-    _reconcile(envelope, isOwnAction) {
-        if (isOwnAction && envelope.origin) {
-            const index = this._pendingActions.findIndex(pending => pending.clientSeq === envelope.origin.clientSeq);
-            if (index !== -1) {
-                if (!envelope.rejectionReason) {
-                    this._confirmedApply(envelope.action);
-                }
-                this._pendingActions.splice(index, 1);
-            } else {
-                this._confirmedApply(envelope.action);
-            }
-        } else {
-            this._confirmedApply(envelope.action);
-        }
-        this._recomputeOptimistic();
-    }
-    _confirmedApply(action) {
-        if (this._confirmedState) {
-            this._confirmedState = this._applyReducer(this._confirmedState, action);
-        }
-    }
-    _recomputeOptimistic() {
-        const confirmed = this._confirmedState;
-        if (!confirmed) {
-            this._optimisticState = undefined;
-            return;
-        }
-        if (this._pendingActions.length === 0) {
-            this._optimisticState = undefined;
-            this._onDidChange.fire(confirmed);
-            return;
-        }
-        let state = confirmed;
-        for (const pending of this._pendingActions) {
-            state = changesetReducer(state, pending.action, this._log);
-        }
-        this._optimisticState = state;
-        this._onDidChange.fire(state);
-    }
-}
-class AnnotationsStateSubscription extends BaseAgentSubscription {
-    constructor(annotationsUri, clientId, seqAllocator, log) {
-        super(clientId, log);
-        this._pendingActions = [];
-        this._annotationsUri = annotationsUri;
-        this._seqAllocator = seqAllocator;
-    }
-    applyOptimistic(action) {
-        const clientSeq = this._seqAllocator();
-        this._pendingActions.push({
-            clientSeq,
-            action
-        });
-        const base = this._optimisticState ?? this.verifiedValue;
-        if (base) {
-            this._optimisticState = annotationsReducer(base, action, this._log);
-            this._onDidChange.fire(this._optimisticState);
-        }
-        return clientSeq;
-    }
-    _getOptimisticState() {
-        return this._optimisticState;
-    }
-    _applyReducer(state, action) {
-        return annotationsReducer(state, action, this._log);
-    }
-    _isRelevantEnvelope(envelope) {
-        return isAnnotationsAction(envelope.action) && envelope.channel === this._annotationsUri;
-    }
-    _onSnapshotApplied(fromSeq) {
-        super._onSnapshotApplied(fromSeq);
-        this._recomputeOptimistic();
-    }
-    _reconcile(envelope, isOwnAction) {
-        if (isOwnAction && envelope.origin) {
-            const idx = this._pendingActions.findIndex(p => p.clientSeq === envelope.origin.clientSeq);
-            if (idx !== -1) {
-                if (!envelope.rejectionReason) {
-                    this._confirmedApply(envelope.action);
-                }
-                this._pendingActions.splice(idx, 1);
-            } else {
-                this._confirmedApply(envelope.action);
-            }
-        } else {
-            this._confirmedApply(envelope.action);
-        }
-        this._recomputeOptimistic();
-    }
-    _confirmedApply(action) {
-        if (this._confirmedState) {
-            this._confirmedState = this._applyReducer(this._confirmedState, action);
-        }
-    }
-    _recomputeOptimistic() {
-        const confirmed = this._confirmedState;
-        if (!confirmed) {
-            this._optimisticState = undefined;
-            return;
-        }
-        if (this._pendingActions.length === 0) {
-            this._optimisticState = undefined;
-            this._onDidChange.fire(confirmed);
-            return;
-        }
-        let state = confirmed;
-        for (const pending of this._pendingActions) {
-            state = annotationsReducer(state, pending.action, this._log);
-        }
-        this._optimisticState = state;
-        this._onDidChange.fire(state);
-    }
-    clearPending() {
-        this._pendingActions.length = 0;
-        this._optimisticState = undefined;
-    }
-    getPendingActions() {
-        return ( this._pendingActions.map(p => ({
-            clientSeq: p.clientSeq,
-            action: p.action,
-            channel: this._annotationsUri
-        })));
-    }
-    dropPendingByClientSeq(clientSeq) {
-        const index = this._pendingActions.findIndex(p => p.clientSeq === clientSeq);
-        if (index === -1) {
-            return false;
-        }
-        this._pendingActions.splice(index, 1);
-        return true;
-    }
-}
-class AgentSubscriptionManager extends Disposable {
-    constructor(clientId, seqAllocator, log, subscribe, unsubscribe) {
-        super();
-        this._subscriptions = ( new ResourceMap());
-        this._inflightCreates = ( new ResourceMap());
-        this._referenceOwnerIds = 0;
-        this._clientId = clientId;
-        this._seqAllocator = seqAllocator;
-        this._log = log;
-        this._subscribe = subscribe;
-        this._unsubscribe = unsubscribe;
-        this._rootState = this._register(( new RootStateSubscription(clientId, log)));
-    }
-    get rootState() {
-        return this._rootState;
-    }
-    handleRootSnapshot(state, fromSeq) {
-        this._rootState.handleSnapshot(state, fromSeq);
-    }
-    getSubscriptionUnmanaged(resource) {
-        const entry = this._subscriptions.get(resource);
-        return entry?.sub;
-    }
-    getInflightSessionCreate(resource) {
-        return this._inflightCreates.get(resource);
-    }
-    trackSessionCreate(resource, promise) {
-        this._inflightCreates.set(resource, promise);
-        void promise.finally(() => {
-            if (this._inflightCreates.get(resource) === promise) {
-                this._inflightCreates.delete(resource);
-            }
-        }).catch(() => {});
-    }
-    getSubscription(kind, resource, owner) {
-        const existing = this._subscriptions.get(resource);
-        if (existing) {
-            if (existing.sub.value instanceof Error) {
-                this._subscriptions.delete(resource);
-                this._disposeSubscriptionEntry(resource, existing);
-            } else {
-                existing.refCount++;
-                return this._acquireReference(resource, existing, owner);
-            }
-        }
-        const key = ( resource.toString());
-        const sub = this._createSubscription(kind, key);
-        const entry = {
-            sub,
-            kind,
-            refCount: 1,
-            holders: ( new Map())
-        };
-        this._subscriptions.set(resource, entry);
-        void (async () => {
-            const inflight = this._inflightCreates.get(resource);
-            if (inflight) {
-                try {
-                    await inflight;
-                } catch {}
-            }
-            try {
-                const snapshot = await this._subscribe(resource);
-                if (this._subscriptions.get(resource) === entry) {
-                    sub.handleSnapshot(snapshot.state, snapshot.fromSeq);
-                }
-            } catch (err) {
-                if (this._subscriptions.get(resource) === entry) {
-                    sub.setError(err instanceof Error ? err : ( new Error(String(err))));
-                }
-            }
-        })();
-        return this._acquireReference(resource, entry, owner);
-    }
-    _acquireReference(resource, entry, owner) {
-        const ownerId = ++this._referenceOwnerIds;
-        entry.holders.set(ownerId, owner);
-        let isDisposed = false;
-        return {
-            object: entry.sub,
-            dispose: () => {
-                if (isDisposed) {
-                    return;
-                }
-                isDisposed = true;
-                entry.holders.delete(ownerId);
-                this._releaseSubscription(resource, entry);
-            }
-        };
-    }
-    _disposeSubscriptionEntry(resource, entry) {
-        this._tryUnsubscribe(resource);
-        if (entry.sub instanceof SessionStateSubscription || entry.sub instanceof ChatStateSubscription || entry.sub instanceof AnnotationsStateSubscription) {
-            entry.sub.clearPending();
-        }
-        entry.sub.dispose();
-    }
-    _tryUnsubscribe(resource) {
-        try {
-            this._unsubscribe(resource);
-        } catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            this._log(`Failed to unsubscribe ${( resource.toString())}: ${message}`);
-        }
-    }
-    receiveEnvelope(envelope) {
-        this._rootState.receiveEnvelope(envelope);
-        for (const {
-            sub
-        } of ( this._subscriptions.values())) {
-            sub.receiveEnvelope(envelope);
-        }
-    }
-    dispatchOptimistic(channel, action) {
-        if (isSessionAction(action)) {
-            const entry = this._subscriptions.get(( URI.parse(channel)));
-            if (entry?.sub instanceof SessionStateSubscription) {
-                return entry.sub.applyOptimistic(action);
-            }
-        } else if (isChatAction(action)) {
-            const entry = this._subscriptions.get(( URI.parse(channel)));
-            if (entry?.sub instanceof ChatStateSubscription) {
-                return entry.sub.applyOptimistic(action);
-            }
-        } else if (isChangesetAction(action)) {
-            const entry = this._subscriptions.get(( URI.parse(channel)));
-            if (entry?.sub instanceof ChangesetStateSubscription) {
-                return entry.sub.applyOptimistic(action);
-            }
-        } else if (isAnnotationsAction(action)) {
-            const entry = this._subscriptions.get(( URI.parse(channel)));
-            if (entry?.sub instanceof AnnotationsStateSubscription) {
-                return entry.sub.applyOptimistic(action);
-            }
-        }
-        return this._seqAllocator();
-    }
-    currentSubscriptionUris() {
-        return [...( this._subscriptions.keys())];
-    }
-    getActiveSubscriptions() {
-        const out = [];
-        for (const [resource, entry] of this._subscriptions) {
-            const value = entry.sub.value;
-            const status = value === undefined ? "pending" : value instanceof Error ? "error" : "snapshot";
-            out.push({
-                resource,
-                kind: entry.kind,
-                refCount: entry.refCount,
-                holders: this._summarizeHolders(entry),
-                status
-            });
-        }
-        return out;
-    }
-    _summarizeHolders(entry) {
-        const counts = ( new Map());
-        for (const owner of ( entry.holders.values())) {
-            counts.set(owner, (counts.get(owner) ?? 0) + 1);
-        }
-        return ( [...counts.entries()].map(([owner, count]) => ({
-            owner,
-            count
-        }))).sort((a, b) => b.count - a.count);
-    }
-    getPendingActions() {
-        const out = [];
-        for (const {
-            sub
-        } of ( this._subscriptions.values())) {
-            if (sub instanceof SessionStateSubscription || sub instanceof ChatStateSubscription || sub instanceof AnnotationsStateSubscription) {
-                out.push(...sub.getPendingActions());
-            }
-        }
-        return out;
-    }
-    dropPendingAction(resource, clientSeq) {
-        const entry = this._subscriptions.get(( URI.parse(resource)));
-        if (entry?.sub instanceof SessionStateSubscription || entry?.sub instanceof ChatStateSubscription || entry?.sub instanceof AnnotationsStateSubscription) {
-            entry.sub.dropPendingByClientSeq(clientSeq);
-        }
-    }
-    applyReconnectSnapshot(resource, state, fromSeq, preservePending = false) {
-        if (isAhpRootChannel(resource)) {
-            this._rootState.handleSnapshot(state, fromSeq);
-            return;
-        }
-        const entry = this._subscriptions.get(( URI.parse(resource)));
-        if (!entry) {
-            return;
-        }
-        if (!preservePending && (entry.sub instanceof SessionStateSubscription || entry.sub instanceof ChatStateSubscription || entry.sub instanceof AnnotationsStateSubscription)) {
-            entry.sub.clearPending();
-        }
-        entry.sub.handleSnapshot(state, fromSeq);
-    }
-    beginSnapshotRefresh(resource) {
-        this._subscriptions.get(resource)?.sub.beginSnapshotRefresh();
-    }
-    cancelSnapshotRefresh(resource) {
-        this._subscriptions.get(resource)?.sub.cancelSnapshotRefresh();
-    }
-    markSubscriptionsMissing(missing) {
-        for (const resource of missing) {
-            const entry = this._subscriptions.get(resource);
-            if (entry) {
-                if (entry.sub instanceof SessionStateSubscription || entry.sub instanceof ChatStateSubscription || entry.sub instanceof AnnotationsStateSubscription) {
-                    entry.sub.clearPending();
-                }
-                entry.sub.setError(( new Error(`Subscription no longer available after reconnect: ${( resource.toString())}`)));
-            }
-        }
-    }
-    _createSubscription(kind, key) {
-        switch (kind) {
-        case StateComponents.Session:
-            return ( new SessionStateSubscription(key, this._clientId, this._seqAllocator, this._log));
-        case StateComponents.Chat:
-            return ( new ChatStateSubscription(key, this._clientId, this._seqAllocator, this._log));
-        case StateComponents.Terminal:
-            return ( new TerminalStateSubscription(key, this._clientId, this._log));
-        case StateComponents.Changeset:
-            return ( new ChangesetStateSubscription(key, this._clientId, this._seqAllocator, this._log));
-        case StateComponents.Annotations:
-            return ( new AnnotationsStateSubscription(key, this._clientId, this._seqAllocator, this._log));
-        case StateComponents.AutomationCatalog:
-            return ( new AutomationCatalogSubscription(this._clientId, this._log));
-        case StateComponents.AutomationRun:
-            return ( new AutomationRunSubscription(key, this._clientId, this._log));
-        case StateComponents.Root:
-            throw ( new Error("_createSubscription: root subscription is managed separately"));
-        default:
-            assertNever(kind, `_createSubscription: unsupported StateComponents kind: ${kind}`);
-        }
-    }
-    _releaseSubscription(resource, expected) {
-        const entry = this._subscriptions.get(resource);
-        if (!entry || (expected && entry !== expected)) {
-            return;
-        }
-        entry.refCount--;
-        if (entry.refCount <= 0) {
-            this._subscriptions.delete(resource);
-            this._disposeSubscriptionEntry(resource, entry);
-        }
-    }
-    dispose() {
-        for (const [resource, entry] of this._subscriptions) {
-            this._tryUnsubscribe(resource);
-            entry.sub.dispose();
-        }
-        this._subscriptions.clear();
-        super.dispose();
-    }
-}
-function observableFromSubscription(owner, sub) {
-    return observableFromEvent(owner, sub.onDidChange, () => {
-        const v = sub.value;
-        return v instanceof Error ? undefined : v;
-    });
-}
-
-export { AgentSubscriptionManager, AnnotationsStateSubscription, AutomationCatalogSubscription, AutomationRunSubscription, ChangesetStateSubscription, ChatStateSubscription, RootStateSubscription, SessionStateSubscription, TerminalStateSubscription, observableFromSubscription };