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

package/vscode/src/vs/platform/agentHost/common/sessionArtifacts.d.ts

@@ -1,75 +0,0 @@
-import type { SessionSummaryMeta } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
-/**
- * The kinds an agent can record on its session, as either an artifact (the
- * session produced it) or a reference (the session found it worth returning
- * to). Each kind carries the one field the client needs to open it, plus a
- * label.
- */
-export declare enum SessionArtifactType {
-    PullRequest = "pullRequest",
-    Issue = "issue",
-    Commit = "commit",
-    Website = "website",
-    File = "file",
-    Resource = "resource"
-}
-export declare const SESSION_ARTIFACT_TYPES: readonly SessionArtifactType[];
-/** A session artifact or reference as stored by the host and published to clients. */
-export interface ISessionArtifact {
-    readonly id: string;
-    readonly type: SessionArtifactType;
-    readonly label: string;
-    /**
-     * `true` for an artifact — something this session produced — and `false` for
-     * a reference, something it only points the user at.
-     */
-    readonly isArtifact: boolean;
-    /** Link for pull request, issue, commit and website entries. */
-    readonly link?: string;
-    /** Resource URI for file and resource entries. */
-    readonly uri?: string;
-    /** Commit hash for commit entries. */
-    readonly commitHash?: string;
-    /** Whether a pull request or issue link points at GitHub. Host-computed. */
-    readonly isGitHub?: boolean;
-}
-/**
- * Reserved key under {@link SessionSummaryMeta} holding the session's agent-set
- * artifacts and references. VS Code convention layered on the protocol's
- * generic `_meta` bag.
- */
-export declare const SESSION_META_ARTIFACTS_KEY = "agentHost/sessionArtifacts";
-/** Reads the artifacts recorded on a session's `_meta` bag. */
-export declare function readSessionArtifacts(meta: SessionSummaryMeta | undefined): readonly ISessionArtifact[];
-/**
- * The artifacts recorded on a session's `_meta` bag, most recent first.
- * Artifacts are appended as the agent records them, so the stored order runs
- * oldest to newest, while every surface lists the newest entry at the top of
- * its group.
- */
-export declare function readSessionArtifactsNewestFirst(meta: SessionSummaryMeta | undefined): readonly ISessionArtifact[];
-/** Returns `meta` with the artifact slot replaced, dropping it when empty. */
-export declare function withSessionArtifacts(meta: SessionSummaryMeta | undefined, artifacts: readonly ISessionArtifact[]): SessionSummaryMeta | undefined;
-/** Serializes artifacts for the session database. */
-export declare function stringifySessionArtifacts(artifacts: readonly ISessionArtifact[]): string;
-/** The outcome of reading persisted artifacts: what was read, and what was lost. */
-export interface IParsedSessionArtifacts {
-    readonly artifacts: readonly ISessionArtifact[];
-    /** Why nothing could be read, when the payload itself was unreadable. */
-    readonly error?: Error;
-    /** How many individual entries were rejected as malformed. */
-    readonly dropped: number;
-}
-/**
- * Parses artifacts previously written by {@link stringifySessionArtifacts}.
- * Reports what could not be read rather than silently returning less, so a
- * corrupt row does not empty a session's artifacts without a trace.
- */
-export declare function parseSessionArtifacts(value: string | undefined): IParsedSessionArtifacts;
-/**
- * The value that identifies an entry for de-duplication: its link, resource
- * URI or commit hash, normalized for comparison.
- */
-export declare function getSessionArtifactValue(artifact: ISessionArtifact): string;
-/** Whether a pull request or issue link points at github.com or a GitHub Enterprise host. */
-export declare function isGitHubArtifactLink(link: string): boolean;

package/vscode/src/vs/platform/agentHost/common/sessionArtifacts.js

@@ -1,84 +0,0 @@
-
-
-var SessionArtifactType;
-(function(SessionArtifactType) {
-    SessionArtifactType["PullRequest"] = "pullRequest";
-    SessionArtifactType["Issue"] = "issue";
-    SessionArtifactType["Commit"] = "commit";
-    SessionArtifactType["Website"] = "website";
-    SessionArtifactType["File"] = "file";
-    SessionArtifactType["Resource"] = "resource";
-})(SessionArtifactType || (SessionArtifactType = {}));
-const SESSION_ARTIFACT_TYPES = [
-    SessionArtifactType.PullRequest,
-    SessionArtifactType.Issue,
-    SessionArtifactType.Commit,
-    SessionArtifactType.Website,
-    SessionArtifactType.File,
-    SessionArtifactType.Resource
-];
-const SESSION_META_ARTIFACTS_KEY = "agentHost/sessionArtifacts";
-function isSessionArtifactType(value) {
-    return typeof value === "string" && SESSION_ARTIFACT_TYPES.includes(value);
-}
-function parseSessionArtifact(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return undefined;
-    }
-    const raw = value;
-    if (typeof raw["id"] !== "string" || typeof raw["label"] !== "string" || !isSessionArtifactType(raw["type"])) {
-        return undefined;
-    }
-    const isArtifact = raw["isArtifact"];
-    if (isArtifact !== undefined && typeof isArtifact !== "boolean") {
-        return undefined;
-    }
-    const artifact = {
-        id: raw["id"],
-        type: raw["type"],
-        label: raw["label"],
-        isArtifact: isArtifact ?? true
-    };
-    if (typeof raw["link"] === "string") {
-        artifact.link = raw["link"];
-    }
-    if (typeof raw["uri"] === "string") {
-        artifact.uri = raw["uri"];
-    }
-    if (typeof raw["commitHash"] === "string") {
-        artifact.commitHash = raw["commitHash"];
-    }
-    if (typeof raw["isGitHub"] === "boolean") {
-        artifact.isGitHub = raw["isGitHub"];
-    }
-    return artifact;
-}
-function readSessionArtifacts(meta) {
-    const value = meta?.[SESSION_META_ARTIFACTS_KEY];
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    const artifacts = [];
-    for (const entry of value) {
-        const artifact = parseSessionArtifact(entry);
-        if (artifact) {
-            artifacts.push(artifact);
-        }
-    }
-    return artifacts;
-}
-function readSessionArtifactsNewestFirst(meta) {
-    return readSessionArtifacts(meta).slice().reverse();
-}
-function isGitHubArtifactLink(link) {
-    try {
-        const {
-            hostname
-        } = ( new URL(link));
-        return hostname === "github.com" || hostname === "www.github.com" || hostname.endsWith(".github.com") || hostname.startsWith("github.");
-    } catch {
-        return false;
-    }
-}
-
-export { SESSION_ARTIFACT_TYPES, SESSION_META_ARTIFACTS_KEY, SessionArtifactType, isGitHubArtifactLink, readSessionArtifacts, readSessionArtifactsNewestFirst };

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

@@ -1,461 +0,0 @@
-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 { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
-import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { ActionEnvelope, ChatAction, AnnotationsAction, ClientAnnotationsAction, type ClientAutomationAction, type ClientAutomationRunAction, ClientChangesetAction, IRootConfigChangedAction, SessionAction, StateAction } from "./sessionActions.js";
-import type { TerminalAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/action-origin.generated";
-import type { AnnotationsState, AutomationRunState, AutomationState, ChangesetState, ChatState, RootState, SessionState, TerminalState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
-import type { IStateSnapshot } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionProtocol";
-import { StateComponents } from "@codingame/monaco-vscode-api/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 when the subscription enters an error state. */
-    readonly onDidError?: Event<Error>;
-    /** Fires before a server-originated action is applied to this subscription's state. */
-    readonly onWillApplyAction: Event<ActionEnvelope>;
-    /** Fires after a server-originated action is applied to this subscription's state. */
-    readonly onDidApplyAction: Event<ActionEnvelope>;
-}
-/**
- * Read-only snapshot describing a single active resource subscription. Used by
- * inspection/debug surfaces that enumerate everything a connection is currently
- * subscribed to. Does not include the always-live root state.
- */
-export interface IActiveSubscriptionInfo {
-    /** The protocol resource URI subscribed to. */
-    readonly resource: URI;
-    /** Which state component this subscription tracks. */
-    readonly kind: StateComponents;
-    /** Number of outstanding {@link IReference} holders. */
-    readonly refCount: number;
-    /**
-     * The named owners currently holding a reference to this subscription,
-     * with how many references each holds. Names come from the `owner`
-     * argument passed to {@link AgentSubscriptionManager.getSubscription}.
-     */
-    readonly holders: readonly IActiveSubscriptionHolder[];
-    /**
-     * Lifecycle status derived from the subscription's value:
-     * `pending` before the first snapshot, `error` if it failed, otherwise
-     * `snapshot`.
-     */
-    readonly status: "pending" | "snapshot" | "error";
-}
-/** A named owner holding one or more references to a subscription. */
-export interface IActiveSubscriptionHolder {
-    readonly owner: string;
-    readonly count: number;
-}
-/**
- * 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;
-    private _awaitingSnapshotRefresh;
-    protected readonly _onDidChange: Emitter<T>;
-    readonly onDidChange: Event<T>;
-    protected readonly _onDidError: Emitter<Error>;
-    readonly onDidError: Event<Error>;
-    protected readonly _onWillApplyAction: Emitter<ActionEnvelope>;
-    readonly onWillApplyAction: Event<ActionEnvelope>;
-    protected readonly _onDidApplyAction: Emitter<ActionEnvelope>;
-    readonly onDidApplyAction: Event<ActionEnvelope>;
-    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;
-    /**
-     * Buffer incoming envelopes until the next {@link handleSnapshot}.
-     *
-     * Needed when a subscription that already holds confirmed state is
-     * re-subscribed to be reseated from a restarted host: the snapshot is
-     * computed at some `fromSeq`, but the channel is already live, so newer
-     * actions can reach the client before the subscribe response does.
-     * Applying them first and then installing the older snapshot would drop
-     * them silently — losing, say, the action that ends a turn.
-     */
-    beginSnapshotRefresh(): void;
-    /**
-     * Abandon a refresh started by {@link beginSnapshotRefresh} when the
-     * snapshot never arrives, applying whatever was buffered meanwhile so the
-     * subscription does not silently lose those actions too.
-     */
-    cancelSnapshotRefresh(): 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 _isRelevantEnvelope}.
-     */
-    receiveEnvelope(envelope: ActionEnvelope): void;
-    /** Apply the reducer to confirmed state. Subclasses must implement. */
-    protected abstract _applyReducer(state: T, action: StateAction): T;
-    /** Whether the given envelope targets this subscription. */
-    protected abstract _isRelevantEnvelope(envelope: ActionEnvelope): 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: ActionEnvelope, _isOwnAction: boolean): void;
-}
-/**
- * Subscription to the root state at `agenthost:/root`.
- * Server-only mutations — no write-ahead.
- */
-export declare class RootStateSubscription extends BaseAgentSubscription<RootState> {
-    protected _applyReducer(state: RootState, action: StateAction): RootState;
-    protected _isRelevantEnvelope(envelope: ActionEnvelope): boolean;
-}
-/**
- * A pending optimistic action awaiting server confirmation, paired with the
- * channel it was dispatched to so it can be replayed across a reconnect. The
- * channel is a session channel for {@link SessionStateSubscription} actions and
- * a chat channel for {@link ChatStateSubscription} actions.
- */
-export interface IPendingDispatchAction {
-    readonly clientSeq: number;
-    /** The optimistic action awaiting confirmation. */
-    readonly action: SessionAction | ChatAction | AnnotationsAction;
-    /** URI of the channel this action targets, as stored on the subscription. */
-    readonly channel: string;
-}
-/**
- * Subscription to a session at `copilot:/<uuid>`.
- * Supports write-ahead reconciliation for client-dispatchable actions.
- */
-export declare class SessionStateSubscription extends BaseAgentSubscription<SessionState> {
-    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: SessionAction): number;
-    protected _getOptimisticState(): SessionState | undefined;
-    protected _applyReducer(state: SessionState, action: StateAction): SessionState;
-    protected _isRelevantEnvelope(envelope: ActionEnvelope): boolean;
-    protected _onSnapshotApplied(fromSeq: number): void;
-    protected _reconcile(envelope: ActionEnvelope, isOwnAction: boolean): void;
-    private _confirmedApply;
-    private _recomputeOptimistic;
-    /**
-     * Clear pending actions for this session (e.g., on unsubscribe).
-     */
-    clearPending(): void;
-    /**
-     * Snapshot of the currently-pending optimistic actions, with the session
-     * URI included so callers can re-issue them across a reconnect. The
-     * actions remain in the subscription so the optimistic state continues
-     * to reflect them — the client must explicitly drop entries echoed back
-     * by the server.
-     */
-    getPendingActions(): IPendingDispatchAction[];
-    /**
-     * Drop the pending entry whose `clientSeq` matches the supplied value.
-     * Used during reconnect to evict actions the server already echoed back
-     * in the replay buffer so they're not resent.
-     */
-    dropPendingByClientSeq(clientSeq: number): boolean;
-}
-/**
- * Subscription to a chat channel (e.g. a session's default chat URI). Turns,
- * tool calls and pending/input state moved off the session onto the chat
- * channel in the multi-chat protocol, so this subscription carries the
- * conversation contents. Supports write-ahead reconciliation for
- * client-dispatchable chat actions (turn starts, confirmations, etc.).
- */
-export declare class ChatStateSubscription extends BaseAgentSubscription<ChatState> {
-    private readonly _pendingActions;
-    private _optimisticState;
-    private readonly _chatUri;
-    private readonly _seqAllocator;
-    constructor(chatUri: string, clientId: string, seqAllocator: () => number, log: (msg: string) => void);
-    handleSnapshot(state: ChatState, fromSeq: number): void;
-    /**
-     * Optimistically apply a chat action. Returns the clientSeq to send to
-     * the server so it can echo back for reconciliation.
-     */
-    applyOptimistic(action: ChatAction): number;
-    protected _getOptimisticState(): ChatState | undefined;
-    protected _applyReducer(state: ChatState, action: StateAction): ChatState;
-    protected _isRelevantEnvelope(envelope: ActionEnvelope): boolean;
-    protected _onSnapshotApplied(fromSeq: number): void;
-    protected _reconcile(envelope: ActionEnvelope, isOwnAction: boolean): void;
-    private _promotePendingTurnStartIfTerminal;
-    private _confirmedApply;
-    private _recomputeOptimistic;
-    clearPending(): void;
-    getPendingActions(): IPendingDispatchAction[];
-    dropPendingByClientSeq(clientSeq: number): boolean;
-}
-/**
- * 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<TerminalState> {
-    private readonly _terminalUri;
-    constructor(terminalUri: string, clientId: string, log: (msg: string) => void);
-    protected _applyReducer(state: TerminalState, action: StateAction): TerminalState;
-    protected _isRelevantEnvelope(envelope: ActionEnvelope): boolean;
-}
-/** Subscription to the singleton host-owned automation catalogue. */
-export declare class AutomationCatalogSubscription extends BaseAgentSubscription<AutomationState> {
-    constructor(clientId: string, log: (msg: string) => void);
-    protected _applyReducer(state: AutomationState, action: StateAction): AutomationState;
-    protected _isRelevantEnvelope(envelope: ActionEnvelope): boolean;
-    protected _reconcile(envelope: ActionEnvelope, isOwnAction: boolean): void;
-}
-/** Subscription to one host-owned automation run. */
-export declare class AutomationRunSubscription extends BaseAgentSubscription<AutomationRunState> {
-    private readonly _resource;
-    constructor(resource: string, clientId: string, log: (msg: string) => void);
-    protected _applyReducer(state: AutomationRunState, action: StateAction): AutomationRunState;
-    protected _isRelevantEnvelope(envelope: ActionEnvelope): boolean;
-    protected _reconcile(envelope: ActionEnvelope, isOwnAction: boolean): void;
-}
-/**
- * Subscription to a changeset at an expanded changeset URI (e.g.
- * `<sessionUri>/changeset/session`).
- *
- * Changeset review actions are client-dispatchable, so this subscription
- * supports write-ahead reconciliation.
- */
-export declare class ChangesetStateSubscription extends BaseAgentSubscription<ChangesetState> {
-    private readonly _pendingActions;
-    private _optimisticState;
-    private readonly _changesetUri;
-    private readonly _seqAllocator;
-    constructor(changesetUri: string, clientId: string, seqAllocator: () => number, log: (msg: string) => void);
-    /**
-     * Optimistically apply a changeset action and return its client sequence.
-     */
-    applyOptimistic(action: ClientChangesetAction): number;
-    protected _getOptimisticState(): ChangesetState | undefined;
-    protected _applyReducer(state: ChangesetState, action: StateAction): ChangesetState;
-    protected _isRelevantEnvelope(envelope: ActionEnvelope): boolean;
-    protected _onSnapshotApplied(fromSeq: number): void;
-    protected _reconcile(envelope: ActionEnvelope, isOwnAction: boolean): void;
-    private _confirmedApply;
-    private _recomputeOptimistic;
-}
-/**
- * Subscription to a session's annotations channel (e.g.
- * `<sessionUri>/annotations`).
- *
- * Annotations actions are client-dispatchable, so this subscription supports
- * write-ahead reconciliation: optimistic state is layered on top of confirmed
- * state and reconciled as the server echoes the client's own actions back.
- *
- * Like {@link ChangesetStateSubscription}, the subscription does NOT
- * self-tear-down on lifecycle events; cleanup is driven externally by the
- * holder releasing its `IReference`.
- */
-export declare class AnnotationsStateSubscription extends BaseAgentSubscription<AnnotationsState> {
-    private readonly _pendingActions;
-    private _optimisticState;
-    private readonly _annotationsUri;
-    private readonly _seqAllocator;
-    constructor(annotationsUri: string, clientId: string, seqAllocator: () => number, log: (msg: string) => void);
-    /**
-     * Optimistically apply an annotations action. Returns the clientSeq to
-     * send to the server so it can echo back for reconciliation.
-     */
-    applyOptimistic(action: AnnotationsAction): number;
-    protected _getOptimisticState(): AnnotationsState | undefined;
-    protected _applyReducer(state: AnnotationsState, action: StateAction): AnnotationsState;
-    protected _isRelevantEnvelope(envelope: ActionEnvelope): boolean;
-    protected _onSnapshotApplied(fromSeq: number): void;
-    protected _reconcile(envelope: ActionEnvelope, isOwnAction: boolean): void;
-    private _confirmedApply;
-    private _recomputeOptimistic;
-    clearPending(): void;
-    getPendingActions(): IPendingDispatchAction[];
-    dropPendingByClientSeq(clientSeq: number): 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 _inflightCreates;
-    private _referenceOwnerIds;
-    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<RootState>;
-    /**
-     * Initialize the root state from a snapshot received during the
-     * connection handshake.
-     */
-    handleRootSnapshot(state: RootState, 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;
-    /**
-     * Returns the in-flight `createSession` Promise for this URI, or `undefined` if no create is pending. Used by
-     * callers that need to gate their own work on a still-running eager `createSession` (e.g. the chat handler awaits
-     * this before deciding whether the sessions provider's eager-create raced first send).
-     */
-    getInflightSessionCreate(resource: URI): Promise<unknown> | undefined;
-    /**
-     * Register an in-flight `createSession` Promise for a session URI. Any
-     * subscribe issued for this resource while the create is pending waits
-     * for the Promise before issuing the wire-level subscribe.
-     */
-    trackSessionCreate(resource: URI, promise: Promise<unknown>): void;
-    /**
-     * 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.
-     *
-     * `owner` names the caller holding the reference so inspection surfaces
-     * (see {@link getActiveSubscriptions}) can attribute who is retaining a
-     * subscription. Use a stable, human-readable identifier such as the
-     * acquiring class name.
-     */
-    getSubscription<T>(kind: StateComponents, resource: URI, owner: string): IReference<IAgentSubscription<T>>;
-    /**
-     * Register `owner` as a holder of `entry` and return a reference whose
-     * disposal removes that holder and releases the subscription. The
-     * caller is responsible for the matching refcount increment (a fresh
-     * entry starts at 1; an existing entry is bumped before calling this).
-     */
-    private _acquireReference;
-    private _disposeSubscriptionEntry;
-    private _tryUnsubscribe;
-    /**
-     * Route an incoming action envelope to all active subscriptions.
-     */
-    receiveEnvelope(envelope: ActionEnvelope): void;
-    /**
-     * Dispatch a client action. Applies optimistically to the relevant
-     * subscription if applicable, then returns the clientSeq.
-     *
-     * `channel` is the protocol URI string identifying the channel the
-     * action targets (a session URI for session actions, etc.).
-     */
-    dispatchOptimistic(channel: string, action: SessionAction | ChatAction | TerminalAction | ClientChangesetAction | ClientAnnotationsAction | ClientAutomationAction | ClientAutomationRunAction | IRootConfigChangedAction): number;
-    /**
-     * URIs currently subscribed to via {@link getSubscription}. Used to
-     * build the `subscriptions` payload for a `reconnect` RPC so the
-     * server can restore them in one round-trip.
-     *
-     * Does NOT include the always-live root state, which the protocol
-     * client manages separately.
-     */
-    currentSubscriptionUris(): URI[];
-    /**
-     * Read-only descriptors of every active resource subscription, for
-     * inspection/debug surfaces. Does NOT include the always-live root
-     * state, which the connection exposes separately via {@link rootState}.
-     */
-    getActiveSubscriptions(): readonly IActiveSubscriptionInfo[];
-    /** Group an entry's holders by owner name, sorted by descending count. */
-    private _summarizeHolders;
-    /**
-     * Snapshot of every pending optimistic action that must survive reconnect.
-     * Callers use this to replay actions after a transport
-     * reconnect; entries are kept on their subscriptions until they're
-     * either echoed back by the server or explicitly dropped via
-     * {@link dropPendingAction}.
-     */
-    getPendingActions(): IPendingDispatchAction[];
-    /**
-     * Remove a single pending optimistic action by its
-     * `clientSeq`. Used during reconnect to evict actions the server
-     * already processed (and replayed back to us) so they're not resent.
-     */
-    dropPendingAction(resource: string, clientSeq: number): void;
-    /**
-     * Apply a fresh snapshot to a subscribed resource — used when the server
-     * responds to a `reconnect` request with `type: 'snapshot'` because the
-     * replay buffer no longer covers the client's gap. Routes to the root
-     * subscription when {@link ROOT_STATE_URI} matches, otherwise reseats the
-     * matching entry in {@link _subscriptions}. Unknown resources are ignored.
-     */
-    applyReconnectSnapshot(resource: string, state: unknown, fromSeq: number, preservePending?: boolean): void;
-    /**
-     * Put a subscription into snapshot-refresh mode ahead of an explicit
-     * re-`subscribe` that reseats it from a restarted host. See
-     * {@link BaseAgentSubscription.beginSnapshotRefresh}.
-     */
-    beginSnapshotRefresh(resource: URI): void;
-    /** Abandon a refresh started by {@link beginSnapshotRefresh}. */
-    cancelSnapshotRefresh(resource: URI): void;
-    /**
-     * Mark a set of subscriptions as no longer resumable on the server
-     * (reported via `ReconnectReplayResult.missing`). The subscriptions
-     * themselves stay alive so consumers continue to hold valid references,
-     * but their value transitions to an `Error` until they're recreated.
-     */
-    markSubscriptionsMissing(missing: readonly URI[]): void;
-    private _createSubscription;
-    private _releaseSubscription;
-    dispose(): void;
-}
-/** Returns whether an action envelope targets one of the subscribed channel URIs. */
-export declare function isActionEnvelopeRelevantToSubscriptionUris(envelope: ActionEnvelope, subscribedUris: Iterable<string>): boolean;
-/**
- * Adapts an {@link IAgentSubscription} into an {@link IObservable} of the
- * subscription's value. Errors and the pre-snapshot phase are surfaced as
- * `undefined`; consumers that need the error itself should read
- * {@link IAgentSubscription.value} directly.
- */
-export declare function observableFromSubscription<T>(owner: object | undefined, sub: IAgentSubscription<T>): IObservable<T | undefined>;
-export {};