@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

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

@@ -2,9 +2,9 @@ import { Emitter, Event } from "@codingame/monaco-vscode-api/vscode/vs/base/comm
 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, IRootConfigChangedAction, SessionAction, StateAction } from "./sessionActions.js";
+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, ChangesetState, ChatState, RootState, SessionState, TerminalState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+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";
 /**
@@ -79,6 +79,7 @@ declare abstract class BaseAgentSubscription<T> extends Disposable implements IA
     protected _confirmedState: T | undefined;
     private _error;
     private _bufferedEnvelopes;
+    private _awaitingSnapshotRefresh;
     protected readonly _onDidChange: Emitter<T>;
     readonly onDidChange: Event<T>;
     protected readonly _onDidError: Emitter<Error>;
@@ -96,6 +97,23 @@ declare abstract class BaseAgentSubscription<T> extends Disposable implements IA
      * 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.
      */
@@ -136,7 +154,7 @@ export declare class RootStateSubscription extends BaseAgentSubscription<RootSta
 export interface IPendingDispatchAction {
     readonly clientSeq: number;
     /** The optimistic action awaiting confirmation. */
-    readonly action: SessionAction | ChatAction;
+    readonly action: SessionAction | ChatAction | AnnotationsAction;
     /** URI of the channel this action targets, as stored on the subscription. */
     readonly channel: string;
 }
@@ -194,6 +212,7 @@ export declare class ChatStateSubscription extends BaseAgentSubscription<ChatSta
     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.
@@ -221,24 +240,45 @@ export declare class TerminalStateSubscription extends BaseAgentSubscription<Ter
     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`).
  *
- * Server-only mutations — no write-ahead. The subscription itself does NOT
- * self-tear-down on lifecycle events; cleanup is driven externally:
- * - Workbench-side: `BaseAgentHostSessionsProvider._handleSessionRemoved`
- *   disposes the per-session subscription map, which releases this
- *   subscription's `IReference` and triggers `_releaseSubscription` on
- *   the manager.
- * - Wire layer: {@link IAgentConnection} refcounts the underlying server
- *   subscription so multiple consumers can share one wire-level subscribe.
+ * 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;
-    constructor(changesetUri: string, clientId: string, log: (msg: string) => void);
+    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.
@@ -270,6 +310,9 @@ export declare class AnnotationsStateSubscription extends BaseAgentSubscription<
     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.
@@ -347,7 +390,7 @@ export declare class AgentSubscriptionManager extends Disposable {
      * `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 | ClientAnnotationsAction | IRootConfigChangedAction): number;
+    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
@@ -366,19 +409,19 @@ export declare class AgentSubscriptionManager extends Disposable {
     /** Group an entry's holders by owner name, sorted by descending count. */
     private _summarizeHolders;
     /**
-     * Snapshot of every pending optimistic action across all session
-     * subscriptions. Callers use this to replay actions after a transport
+     * 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 dropPendingSessionAction}.
+     * {@link dropPendingAction}.
      */
-    getPendingSessionActions(): IPendingDispatchAction[];
+    getPendingActions(): IPendingDispatchAction[];
     /**
-     * Remove a single pending optimistic action for a session by its
+     * 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.
      */
-    dropPendingSessionAction(sessionUri: string, clientSeq: number): void;
+    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
@@ -386,7 +429,15 @@ export declare class AgentSubscriptionManager extends Disposable {
      * 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): void;
+    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

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

@@ -13,11 +13,17 @@ 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 { isAhpRootChannel, StateComponents } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+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 './legacyProtocolCompatibility.js';
+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()));
@@ -39,11 +45,30 @@ class BaseAgentSubscription extends Disposable {
         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);
@@ -52,7 +77,7 @@ class BaseAgentSubscription extends Disposable {
         if (!this._isRelevantEnvelope(envelope)) {
             return;
         }
-        if (this._confirmedState === undefined) {
+        if (this._confirmedState === undefined || this._awaitingSnapshotRefresh) {
             if (!this._bufferedEnvelopes) {
                 this._bufferedEnvelopes = [];
             }
@@ -80,6 +105,9 @@ class BaseAgentSubscription extends Disposable {
         }
     }
     _reconcile(envelope, _isOwnAction) {
+        if (envelope.rejectionReason) {
+            return;
+        }
         this._confirmedState = this._applyReducer(this._confirmedState, envelope.action);
         this._onDidChange.fire(this.value);
     }
@@ -129,16 +157,14 @@ class SessionStateSubscription extends BaseAgentSubscription {
         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 {
+                if (!envelope.rejectionReason) {
                     this._confirmedApply(envelope.action);
-                    this._pendingActions.splice(idx, 1);
                 }
-            } else {
+                this._pendingActions.splice(idx, 1);
+            } else if (!envelope.rejectionReason) {
                 this._confirmedApply(envelope.action);
             }
-        } else {
+        } else if (!envelope.rejectionReason) {
             this._confirmedApply(envelope.action);
         }
         this._recomputeOptimistic();
@@ -193,6 +219,9 @@ class ChatStateSubscription extends BaseAgentSubscription {
         this._chatUri = chatUri;
         this._seqAllocator = seqAllocator;
     }
+    handleSnapshot(state, fromSeq) {
+        super.handleSnapshot(normalizeLegacyChatStateErrors(state), fromSeq);
+    }
     applyOptimistic(action) {
         const clientSeq = this._seqAllocator();
         this._pendingActions.push({
@@ -223,16 +252,14 @@ class ChatStateSubscription extends BaseAgentSubscription {
         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 {
+                if (!envelope.rejectionReason) {
                     this._confirmedApply(envelope.action);
-                    this._pendingActions.splice(idx, 1);
                 }
-            } else {
+                this._pendingActions.splice(idx, 1);
+            } else if (!envelope.rejectionReason) {
                 this._confirmedApply(envelope.action);
             }
-        } else {
+        } else if (!envelope.rejectionReason) {
             this._promotePendingTurnStartIfTerminal(envelope.action);
             this._confirmedApply(envelope.action);
         }
@@ -313,10 +340,61 @@ class TerminalStateSubscription extends BaseAgentSubscription {
         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, log) {
+    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);
@@ -324,6 +402,49 @@ class ChangesetStateSubscription extends BaseAgentSubscription {
     _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) {
@@ -397,6 +518,25 @@ class AnnotationsStateSubscription extends BaseAgentSubscription {
         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) {
@@ -490,7 +630,7 @@ class AgentSubscriptionManager extends Disposable {
     }
     _disposeSubscriptionEntry(resource, entry) {
         this._tryUnsubscribe(resource);
-        if (entry.sub instanceof SessionStateSubscription || entry.sub instanceof ChatStateSubscription) {
+        if (entry.sub instanceof SessionStateSubscription || entry.sub instanceof ChatStateSubscription || entry.sub instanceof AnnotationsStateSubscription) {
             entry.sub.clearPending();
         }
         entry.sub.dispose();
@@ -522,6 +662,11 @@ class AgentSubscriptionManager extends Disposable {
             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) {
@@ -558,24 +703,24 @@ class AgentSubscriptionManager extends Disposable {
             count
         }))).sort((a, b) => b.count - a.count);
     }
-    getPendingSessionActions() {
+    getPendingActions() {
         const out = [];
         for (const {
             sub
         } of ( this._subscriptions.values())) {
-            if (sub instanceof SessionStateSubscription || sub instanceof ChatStateSubscription) {
+            if (sub instanceof SessionStateSubscription || sub instanceof ChatStateSubscription || sub instanceof AnnotationsStateSubscription) {
                 out.push(...sub.getPendingActions());
             }
         }
         return out;
     }
-    dropPendingSessionAction(sessionUri, clientSeq) {
-        const entry = this._subscriptions.get(( URI.parse(sessionUri)));
-        if (entry?.sub instanceof SessionStateSubscription || entry?.sub instanceof ChatStateSubscription) {
+    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) {
+    applyReconnectSnapshot(resource, state, fromSeq, preservePending = false) {
         if (isAhpRootChannel(resource)) {
             this._rootState.handleSnapshot(state, fromSeq);
             return;
@@ -584,16 +729,22 @@ class AgentSubscriptionManager extends Disposable {
         if (!entry) {
             return;
         }
-        if (entry.sub instanceof SessionStateSubscription || entry.sub instanceof ChatStateSubscription) {
+        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) {
+                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())}`)));
@@ -609,9 +760,13 @@ class AgentSubscriptionManager extends Disposable {
         case StateComponents.Terminal:
             return ( new TerminalStateSubscription(key, this._clientId, this._log));
         case StateComponents.Changeset:
-            return ( new ChangesetStateSubscription(key, this._clientId, this._log));
+            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:
@@ -638,5 +793,11 @@ class AgentSubscriptionManager extends Disposable {
         super.dispose();
     }
 }
+function observableFromSubscription(owner, sub) {
+    return observableFromEvent(owner, sub.onDidChange, () => {
+        const v = sub.value;
+        return v instanceof Error ? undefined : v;
+    });
+}
 
-export { AgentSubscriptionManager, AnnotationsStateSubscription, ChangesetStateSubscription, ChatStateSubscription, RootStateSubscription, SessionStateSubscription, TerminalStateSubscription };
+export { AgentSubscriptionManager, AnnotationsStateSubscription, AutomationCatalogSubscription, AutomationRunSubscription, ChangesetStateSubscription, ChatStateSubscription, RootStateSubscription, SessionStateSubscription, TerminalStateSubscription, observableFromSubscription };

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

@@ -0,0 +1,30 @@
+import { type ActionEnvelope, type ChatErrorAction, type StateAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/actions";
+import { type ChatState, type ErrorInfo, type Turn } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+interface ILegacyChatErrorAction extends Omit<ChatErrorAction, "part"> {
+    readonly error: ErrorInfo;
+}
+type CompatibleTurn = Turn | (Turn & {
+    readonly error: ErrorInfo;
+});
+type CompatibleActionEnvelope = Omit<ActionEnvelope, "action"> & {
+    readonly action: StateAction | ILegacyChatErrorAction;
+};
+/**
+ * Reads the top-level error field emitted by AHP hosts before durable error
+ * response parts were introduced.
+ */
+export declare function readLegacyTurnError(turn: CompatibleTurn): ErrorInfo | undefined;
+/**
+ * Moves a legacy completed-turn error into its durable response-part position.
+ */
+export declare function normalizeLegacyTurnError(turn: CompatibleTurn): Turn;
+/**
+ * Normalizes legacy completed-turn errors in a chat snapshot.
+ */
+export declare function normalizeLegacyChatStateErrors(state: ChatState): ChatState;
+/**
+ * Normalizes legacy error payloads before a server action reaches reducers or
+ * action observers.
+ */
+export declare function normalizeLegacyActionEnvelope(envelope: CompatibleActionEnvelope): ActionEnvelope;
+export {};

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

@@ -0,0 +1,87 @@
+
+import { hasKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-root/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
+import { TurnState, ResponsePartKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-terminal/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-resource-watch/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation-run/state';
+
+function normalizeLegacyTurnError(turn) {
+    if (turn.state !== TurnState.Error || !hasKey(turn, {
+        error: true
+    })) {
+        return turn;
+    }
+    const {
+        error,
+        ...normalizedTurn
+    } = turn;
+    const finalPart = turn.responseParts[turn.responseParts.length - 1];
+    return {
+        ...normalizedTurn,
+        responseParts: finalPart?.kind === ResponsePartKind.Error ? turn.responseParts : [...turn.responseParts, {
+            kind: ResponsePartKind.Error,
+            error
+        }]
+    };
+}
+function normalizeLegacyChatStateErrors(state) {
+    const turns = ( state.turns.map(normalizeLegacyTurnError));
+    return ( turns.some((turn, index) => turn !== state.turns[index])) ? {
+        ...state,
+        turns
+    } : state;
+}
+function normalizeLegacyActionEnvelope(envelope) {
+    const action = envelope.action;
+    switch (action.type) {
+    case ActionType.ChatError:
+        if (hasKey(action, {
+            error: true
+        })) {
+            const {
+                error,
+                ...normalizedAction
+            } = action;
+            return {
+                ...envelope,
+                action: {
+                    ...normalizedAction,
+                    part: {
+                        kind: ResponsePartKind.Error,
+                        error
+                    }
+                }
+            };
+        }
+        return {
+            ...envelope,
+            action
+        };
+    case ActionType.ChatTurnsLoaded:
+        {
+            const turns = ( action.turns.map(normalizeLegacyTurnError));
+            return ( turns.some((turn, index) => turn !== action.turns[index])) ? {
+                ...envelope,
+                action: {
+                    ...action,
+                    turns
+                }
+            } : {
+                ...envelope,
+                action
+            };
+        }
+    default:
+        return {
+            ...envelope,
+            action
+        };
+    }
+}
+
+export { normalizeLegacyActionEnvelope, normalizeLegacyChatStateErrors, normalizeLegacyTurnError };

package/vscode/src/vs/platform/agentHost/common/state/protocol/channels-annotations/reducer.js

@@ -20,8 +20,8 @@ function annotationsReducer(state, action, log) {
             }
             const annotation = state.annotations[idx];
             const updated = { ...annotation };
-            if (action.turnId !== undefined) {
-                updated.turnId = action.turnId;
+            if (action.origin !== undefined) {
+                updated.origin = action.origin;
             }
             if (action.resource !== undefined) {
                 updated.resource = action.resource;

package/vscode/src/vs/platform/agentHost/common/state/protocol/channels-automation/reducer.d.ts

@@ -0,0 +1,4 @@
+import type { AutomationAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/action-origin.generated";
+import type { AutomationState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation/state";
+/** Pure reducer for automation catalogue state. */
+export declare function automationReducer(state: AutomationState, action: AutomationAction, log?: (msg: string) => void): AutomationState;