@codingame/monaco-vscode-chat-service-override 30.0.0 → 31.0.0

package/vscode/src/vs/platform/agentHost/common/state/agentSubscription.d.ts

@@ -0,0 +1,182 @@
+import { Emitter, Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable, IReference } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IActionEnvelope, ISessionAction, IStateAction } from "./sessionActions.js";
+import type { ITerminalAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/action-origin.generated";
+import type { IRootState, ISessionState, ITerminalState } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/state";
+import type { IStateSnapshot } from "./sessionProtocol.js";
+import { StateComponents } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/sessionState";
+/**
+ * A read-only subscription to an agent host resource (root, session, or terminal).
+ *
+ * Subscriptions are hydrated from an initial server snapshot and kept in sync
+ * via action envelopes. Session subscriptions support write-ahead
+ * reconciliation — optimistic state is layered on top of confirmed state.
+ */
+export interface IAgentSubscription<T> {
+    /**
+     * The current state value. For write-ahead subscriptions (sessions) this
+     * reflects the optimistic state (confirmed + pending replayed). For
+     * server-only subscriptions (root, terminal) this equals `verifiedValue`.
+     *
+     * `undefined` until the first snapshot arrives. An `Error` if subscription
+     * failed.
+     */
+    readonly value: T | Error | undefined;
+    /**
+     * The server-confirmed state with no pending optimistic actions applied.
+     * `undefined` until the first snapshot arrives.
+     */
+    readonly verifiedValue: T | undefined;
+    /** Fires when {@link value} changes (optimistic or confirmed). */
+    readonly onDidChange: Event<T>;
+    /** Fires before a server-originated action is applied to this subscription's state. */
+    readonly onWillApplyAction: Event<IActionEnvelope>;
+    /** Fires after a server-originated action is applied to this subscription's state. */
+    readonly onDidApplyAction: Event<IActionEnvelope>;
+}
+/**
+ * Base class for agent subscriptions. Handles envelope reception, confirmed
+ * state management, and action event emission.
+ *
+ * Subclasses provide the reducer and optionally override reconciliation
+ * behavior.
+ */
+declare abstract class BaseAgentSubscription<T> extends Disposable implements IAgentSubscription<T> {
+    protected _confirmedState: T | undefined;
+    private _error;
+    private _bufferedEnvelopes;
+    protected readonly _onDidChange: Emitter<T>;
+    readonly onDidChange: Event<T>;
+    protected readonly _onWillApplyAction: Emitter<IActionEnvelope>;
+    readonly onWillApplyAction: Event<IActionEnvelope>;
+    protected readonly _onDidApplyAction: Emitter<IActionEnvelope>;
+    readonly onDidApplyAction: Event<IActionEnvelope>;
+    protected readonly _clientId: string;
+    protected readonly _log: (msg: string) => void;
+    constructor(clientId: string, log: (msg: string) => void);
+    get value(): T | Error | undefined;
+    get verifiedValue(): T | undefined;
+    /**
+     * Apply an initial snapshot from the server.
+     */
+    handleSnapshot(state: T, fromSeq: number): void;
+    /**
+     * Mark this subscription as failed.
+     */
+    setError(error: Error): void;
+    /**
+     * Process an incoming action envelope. The subscription determines
+     * whether the action is relevant via {@link _isRelevantAction}.
+     */
+    receiveEnvelope(envelope: IActionEnvelope): void;
+    /** Apply the reducer to confirmed state. Subclasses must implement. */
+    protected abstract _applyReducer(state: T, action: IStateAction): T;
+    /** Whether the given action targets this subscription. */
+    protected abstract _isRelevantAction(action: IStateAction): boolean;
+    /** Return optimistic state if write-ahead is active, otherwise `undefined`. */
+    protected _getOptimisticState(): T | undefined;
+    /** Hook called after a snapshot is applied. Replays buffered actions. */
+    protected _onSnapshotApplied(_fromSeq: number): void;
+    /**
+     * Default reconciliation: apply to confirmed, fire change event.
+     * Session subscriptions override this for write-ahead.
+     */
+    protected _reconcile(envelope: IActionEnvelope, _isOwnAction: boolean): void;
+}
+/**
+ * Subscription to the root state at `agenthost:/root`.
+ * Server-only mutations — no write-ahead.
+ */
+export declare class RootStateSubscription extends BaseAgentSubscription<IRootState> {
+    protected _applyReducer(state: IRootState, action: IStateAction): IRootState;
+    protected _isRelevantAction(action: IStateAction): boolean;
+}
+/**
+ * Subscription to a session at `copilot:/<uuid>`.
+ * Supports write-ahead reconciliation for client-dispatchable actions.
+ */
+export declare class SessionStateSubscription extends BaseAgentSubscription<ISessionState> {
+    private readonly _pendingActions;
+    private _optimisticState;
+    private readonly _sessionUri;
+    private readonly _seqAllocator;
+    constructor(sessionUri: string, clientId: string, seqAllocator: () => number, log: (msg: string) => void);
+    /**
+     * Optimistically apply a session action. Returns the clientSeq to send
+     * to the server so it can echo back for reconciliation.
+     */
+    applyOptimistic(action: ISessionAction): number;
+    protected _getOptimisticState(): ISessionState | undefined;
+    protected _applyReducer(state: ISessionState, action: IStateAction): ISessionState;
+    protected _isRelevantAction(action: IStateAction): boolean;
+    protected _onSnapshotApplied(fromSeq: number): void;
+    protected _reconcile(envelope: IActionEnvelope, isOwnAction: boolean): void;
+    private _confirmedApply;
+    private _recomputeOptimistic;
+    /**
+     * Clear pending actions for this session (e.g., on unsubscribe).
+     */
+    clearPending(): void;
+}
+/**
+ * Subscription to a terminal at an agent-host terminal URI.
+ * Server-only mutations — no write-ahead (terminal I/O is side-effect-only).
+ */
+export declare class TerminalStateSubscription extends BaseAgentSubscription<ITerminalState> {
+    private readonly _terminalUri;
+    constructor(terminalUri: string, clientId: string, log: (msg: string) => void);
+    protected _applyReducer(state: ITerminalState, action: IStateAction): ITerminalState;
+    protected _isRelevantAction(action: IStateAction): boolean;
+}
+/**
+ * Manages the lifecycle of resource subscriptions for an agent connection.
+ *
+ * Provides refcounted access via {@link getSubscription} — the subscription
+ * is created on first acquire, subscribes to the server, and stays alive
+ * until the last reference is disposed.
+ *
+ * The connection feeds action envelopes to all active subscriptions via
+ * {@link receiveEnvelope}.
+ */
+export declare class AgentSubscriptionManager extends Disposable {
+    private readonly _subscriptions;
+    private readonly _rootState;
+    private readonly _clientId;
+    private readonly _seqAllocator;
+    private readonly _log;
+    private readonly _subscribe;
+    private readonly _unsubscribe;
+    constructor(clientId: string, seqAllocator: () => number, log: (msg: string) => void, subscribe: (resource: URI) => Promise<IStateSnapshot>, unsubscribe: (resource: URI) => void);
+    /** The always-live root state subscription. */
+    get rootState(): IAgentSubscription<IRootState>;
+    /**
+     * Initialize the root state from a snapshot received during the
+     * connection handshake.
+     */
+    handleRootSnapshot(state: IRootState, fromSeq: number): void;
+    /**
+     * Returns an existing subscription without affecting its refcount.
+     * Returns `undefined` if no subscription is active for the given resource.
+     */
+    getSubscriptionUnmanaged<T>(resource: URI): IAgentSubscription<T> | undefined;
+    /**
+     * Get or create a refcounted subscription to any resource. Disposing
+     * the returned reference decrements the refcount; when it reaches zero
+     * the subscription is torn down and the server is notified.
+     */
+    getSubscription<T>(kind: StateComponents, resource: URI): IReference<IAgentSubscription<T>>;
+    /**
+     * Route an incoming action envelope to all active subscriptions.
+     */
+    receiveEnvelope(envelope: IActionEnvelope): void;
+    /**
+     * Dispatch a client action. Applies optimistically to the relevant
+     * subscription if applicable, then returns the clientSeq.
+     */
+    dispatchOptimistic(action: ISessionAction | ITerminalAction): number;
+    private _createSubscription;
+    private _releaseSubscription;
+    dispose(): void;
+}
+export {};

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

@@ -0,0 +1,282 @@
+
+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 { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { isSessionAction } from './sessionActions.js';
+import { rootReducer, sessionReducer, terminalReducer } from './protocol/reducers.js';
+import { StateComponents } from '@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/sessionState';
+
+class BaseAgentSubscription extends Disposable {
+    constructor(clientId, log) {
+        super();
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.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._confirmedState = state;
+        this._error = undefined;
+        this._onSnapshotApplied(fromSeq);
+        this._onDidChange.fire(this.value);
+    }
+    setError(error) {
+        this._error = error;
+    }
+    receiveEnvelope(envelope) {
+        if (!this._isRelevantAction(envelope.action)) {
+            return;
+        }
+        if (this._confirmedState === undefined) {
+            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) {
+        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);
+    }
+    _isRelevantAction(action) {
+        return 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);
+    }
+    _isRelevantAction(action) {
+        return isSessionAction(action) && action.session === 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._pendingActions.splice(idx, 1);
+                } else {
+                    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 = sessionReducer(state, pending.action, this._log);
+        }
+        this._optimisticState = state;
+        this._onDidChange.fire(state);
+    }
+    clearPending() {
+        this._pendingActions.length = 0;
+        this._optimisticState = undefined;
+    }
+}
+class TerminalStateSubscription extends BaseAgentSubscription {
+    constructor(terminalUri, clientId, log) {
+        super(clientId, log);
+        this._terminalUri = terminalUri;
+    }
+    _applyReducer(state, action) {
+        return terminalReducer(state, action, this._log);
+    }
+    _isRelevantAction(action) {
+        return action.type.startsWith("terminal/") && action.terminal === this._terminalUri;
+    }
+}
+class AgentSubscriptionManager extends Disposable {
+    constructor(clientId, seqAllocator, log, subscribe, unsubscribe) {
+        super();
+        this._subscriptions = ( new ResourceMap());
+        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;
+    }
+    getSubscription(kind, resource) {
+        const existing = this._subscriptions.get(resource);
+        if (existing) {
+            existing.refCount++;
+            return {
+                object: existing.sub,
+                dispose: () => this._releaseSubscription(resource)
+            };
+        }
+        const key = ( resource.toString());
+        const sub = this._createSubscription(kind, key);
+        const entry = {
+            sub,
+            refCount: 1
+        };
+        this._subscriptions.set(resource, entry);
+        this._subscribe(resource).then(snapshot => {
+            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 {
+            object: sub,
+            dispose: () => this._releaseSubscription(resource)
+        };
+    }
+    receiveEnvelope(envelope) {
+        this._rootState.receiveEnvelope(envelope);
+        for (const {
+            sub
+        } of ( this._subscriptions.values())) {
+            sub.receiveEnvelope(envelope);
+        }
+    }
+    dispatchOptimistic(action) {
+        if (isSessionAction(action)) {
+            const entry = this._subscriptions.get(( URI.parse(action.session)));
+            if (entry && entry.sub instanceof SessionStateSubscription) {
+                return entry.sub.applyOptimistic(action);
+            }
+        }
+        return this._seqAllocator();
+    }
+    _createSubscription(kind, key) {
+        switch (kind) {
+        case StateComponents.Session:
+            return ( new SessionStateSubscription(key, this._clientId, this._seqAllocator, this._log));
+        case StateComponents.Terminal:
+            return ( new TerminalStateSubscription(key, this._clientId, this._log));
+        default:
+            return ( new TerminalStateSubscription(key, this._clientId, this._log));
+        }
+    }
+    _releaseSubscription(resource) {
+        const entry = this._subscriptions.get(resource);
+        if (!entry) {
+            return;
+        }
+        entry.refCount--;
+        if (entry.refCount <= 0) {
+            this._subscriptions.delete(resource);
+            try {
+                this._unsubscribe(resource);
+            } catch {}
+            if (entry.sub instanceof SessionStateSubscription) {
+                entry.sub.clearPending();
+            }
+            entry.sub.dispose();
+        }
+    }
+    dispose() {
+        for (const [resource, entry] of this._subscriptions) {
+            try {
+                this._unsubscribe(resource);
+            } catch {}
+            entry.sub.dispose();
+        }
+        this._subscriptions.clear();
+        super.dispose();
+    }
+}
+
+export { AgentSubscriptionManager, RootStateSubscription, SessionStateSubscription, TerminalStateSubscription };