@codingame/monaco-vscode-chat-service-override 34.1.3 → 35.0.1

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

@@ -5,11 +5,13 @@ import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/l
 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, isChangesetAction } from './sessionActions.js';
+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 { isAhpRootChannel, StateComponents } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
 
@@ -18,6 +20,8 @@ class BaseAgentSubscription extends Disposable {
         super();
         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()));
@@ -42,6 +46,7 @@ class BaseAgentSubscription extends Disposable {
     }
     setError(error) {
         this._error = error;
+        this._onDidError.fire(error);
     }
     receiveEnvelope(envelope) {
         if (!this._isRelevantEnvelope(envelope)) {
@@ -120,6 +125,100 @@ class SessionStateSubscription extends BaseAgentSubscription {
         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;
+    }
+    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;
+    }
+    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);
@@ -140,14 +239,14 @@ class SessionStateSubscription extends BaseAgentSubscription {
         this._recomputeOptimistic();
     }
     _promotePendingTurnStartIfTerminal(action) {
-        if (!isSessionAction(action)) {
+        if (!isChatAction(action)) {
             return;
         }
-        if (action.type !== ActionType.SessionTurnComplete && action.type !== ActionType.SessionTurnCancelled && action.type !== ActionType.SessionError) {
+        if (action.type !== ActionType.ChatTurnComplete && action.type !== ActionType.ChatTurnCancelled && action.type !== ActionType.ChatError) {
             return;
         }
         const index = this._pendingActions.findIndex(
-            p => p.action.type === ActionType.SessionTurnStarted && p.action.turnId === action.turnId
+            p => p.action.type === ActionType.ChatTurnStarted && p.action.turnId === action.turnId
         );
         if (index === -1) {
             return;
@@ -177,7 +276,7 @@ class SessionStateSubscription extends BaseAgentSubscription {
         }
         let state = confirmed;
         for (const pending of this._pendingActions) {
-            state = sessionReducer(state, pending.action, this._log);
+            state = chatReducer(state, pending.action, this._log);
         }
         this._optimisticState = state;
         this._onDidChange.fire(state);
@@ -190,7 +289,7 @@ class SessionStateSubscription extends BaseAgentSubscription {
         return ( this._pendingActions.map(p => ({
             clientSeq: p.clientSeq,
             action: p.action,
-            sessionUri: this._sessionUri
+            channel: this._chatUri
         })));
     }
     dropPendingByClientSeq(clientSeq) {
@@ -226,10 +325,84 @@ class ChangesetStateSubscription extends BaseAgentSubscription {
         return isChangesetAction(envelope.action) && envelope.channel === this._changesetUri;
     }
 }
+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);
+    }
+}
 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;
@@ -248,6 +421,17 @@ class AgentSubscriptionManager extends Disposable {
         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) {
@@ -268,15 +452,24 @@ class AgentSubscriptionManager extends Disposable {
             holders: ( new Map())
         };
         this._subscriptions.set(resource, entry);
-        this._subscribe(resource).then(snapshot => {
-            if (this._subscriptions.get(resource) === entry) {
-                sub.handleSnapshot(snapshot.state, snapshot.fromSeq);
+        void (async () => {
+            const inflight = this._inflightCreates.get(resource);
+            if (inflight) {
+                try {
+                    await inflight;
+                } catch {}
             }
-        }).catch(err => {
-            if (this._subscriptions.get(resource) === entry) {
-                sub.setError(err instanceof Error ? err : ( new Error(String(err))));
+            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) {
@@ -297,7 +490,7 @@ class AgentSubscriptionManager extends Disposable {
     }
     _disposeSubscriptionEntry(resource, entry) {
         this._tryUnsubscribe(resource);
-        if (entry.sub instanceof SessionStateSubscription) {
+        if (entry.sub instanceof SessionStateSubscription || entry.sub instanceof ChatStateSubscription) {
             entry.sub.clearPending();
         }
         entry.sub.dispose();
@@ -324,6 +517,16 @@ class AgentSubscriptionManager extends Disposable {
             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 (isAnnotationsAction(action)) {
+            const entry = this._subscriptions.get(( URI.parse(channel)));
+            if (entry?.sub instanceof AnnotationsStateSubscription) {
+                return entry.sub.applyOptimistic(action);
+            }
         }
         return this._seqAllocator();
     }
@@ -360,7 +563,7 @@ class AgentSubscriptionManager extends Disposable {
         for (const {
             sub
         } of ( this._subscriptions.values())) {
-            if (sub instanceof SessionStateSubscription) {
+            if (sub instanceof SessionStateSubscription || sub instanceof ChatStateSubscription) {
                 out.push(...sub.getPendingActions());
             }
         }
@@ -368,7 +571,7 @@ class AgentSubscriptionManager extends Disposable {
     }
     dropPendingSessionAction(sessionUri, clientSeq) {
         const entry = this._subscriptions.get(( URI.parse(sessionUri)));
-        if (entry?.sub instanceof SessionStateSubscription) {
+        if (entry?.sub instanceof SessionStateSubscription || entry?.sub instanceof ChatStateSubscription) {
             entry.sub.dropPendingByClientSeq(clientSeq);
         }
     }
@@ -381,7 +584,7 @@ class AgentSubscriptionManager extends Disposable {
         if (!entry) {
             return;
         }
-        if (entry.sub instanceof SessionStateSubscription) {
+        if (entry.sub instanceof SessionStateSubscription || entry.sub instanceof ChatStateSubscription) {
             entry.sub.clearPending();
         }
         entry.sub.handleSnapshot(state, fromSeq);
@@ -390,7 +593,7 @@ class AgentSubscriptionManager extends Disposable {
         for (const resource of missing) {
             const entry = this._subscriptions.get(resource);
             if (entry) {
-                if (entry.sub instanceof SessionStateSubscription) {
+                if (entry.sub instanceof SessionStateSubscription || entry.sub instanceof ChatStateSubscription) {
                     entry.sub.clearPending();
                 }
                 entry.sub.setError(( new Error(`Subscription no longer available after reconnect: ${( resource.toString())}`)));
@@ -401,10 +604,14 @@ class AgentSubscriptionManager extends Disposable {
         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._log));
+        case StateComponents.Annotations:
+            return ( new AnnotationsStateSubscription(key, this._clientId, this._seqAllocator, this._log));
         case StateComponents.Root:
             throw ( new Error("_createSubscription: root subscription is managed separately"));
         default:
@@ -432,4 +639,4 @@ class AgentSubscriptionManager extends Disposable {
     }
 }
 
-export { AgentSubscriptionManager, ChangesetStateSubscription, RootStateSubscription, SessionStateSubscription, TerminalStateSubscription };
+export { AgentSubscriptionManager, AnnotationsStateSubscription, ChangesetStateSubscription, ChatStateSubscription, RootStateSubscription, SessionStateSubscription, TerminalStateSubscription };

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

@@ -0,0 +1,18 @@
+import type { AnnotationsState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-annotations/state";
+import type { AnnotationsAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/action-origin.generated";
+/**
+ * Pure reducer for annotations state. Handles every {@link AnnotationsAction}
+ * variant.
+ *
+ * Per the spec, every annotations action is client-dispatchable; the reducer
+ * runs identically on the client (optimistic, write-ahead) and the server. It
+ * preserves the dispatch order of annotations (and of entries within an
+ * annotation): new entries are appended; `*Set` actions with a matching id
+ * replace in place, while actions whose target id is unknown are no-ops
+ * (mirroring `changeset/fileRemoved` semantics). The single-entry
+ * minimum invariant is enforced by producers, not the reducer — removing an
+ * annotation's last entry via {@link AnnotationsEntryRemovedAction} (instead
+ * of {@link AnnotationsRemovedAction}) would leave an empty annotation,
+ * which is observable but not catastrophic.
+ */
+export declare function annotationsReducer(state: AnnotationsState, action: AnnotationsAction, log?: (msg: string) => void): AnnotationsState;

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

@@ -0,0 +1,89 @@
+
+import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
+import { softAssertNever } from '../common/reducer-helpers.js';
+
+function annotationsReducer(state, action, log) {
+    switch (action.type) {
+        case ActionType.AnnotationsSet: {
+            const idx = state.annotations.findIndex(t => t.id === action.annotation.id);
+            if (idx < 0) {
+                return { ...state, annotations: [...state.annotations, action.annotation] };
+            }
+            const next = [...state.annotations];
+            next[idx] = action.annotation;
+            return { ...state, annotations: next };
+        }
+        case ActionType.AnnotationsUpdated: {
+            const idx = state.annotations.findIndex(t => t.id === action.annotationId);
+            if (idx < 0) {
+                return state;
+            }
+            const annotation = state.annotations[idx];
+            const updated = { ...annotation };
+            if (action.turnId !== undefined) {
+                updated.turnId = action.turnId;
+            }
+            if (action.resource !== undefined) {
+                updated.resource = action.resource;
+            }
+            if (action.range !== undefined) {
+                updated.range = action.range;
+            }
+            if (action.resolved !== undefined) {
+                updated.resolved = action.resolved;
+            }
+            const next = [...state.annotations];
+            next[idx] = updated;
+            return { ...state, annotations: next };
+        }
+        case ActionType.AnnotationsRemoved: {
+            const idx = state.annotations.findIndex(t => t.id === action.annotationId);
+            if (idx < 0) {
+                return state;
+            }
+            const next = [...state.annotations];
+            next.splice(idx, 1);
+            return { ...state, annotations: next };
+        }
+        case ActionType.AnnotationsEntrySet: {
+            const tIdx = state.annotations.findIndex(t => t.id === action.annotationId);
+            if (tIdx < 0) {
+                return state;
+            }
+            const annotation = state.annotations[tIdx];
+            const cIdx = annotation.entries.findIndex(c => c.id === action.entry.id);
+            let nextEntries;
+            if (cIdx < 0) {
+                nextEntries = [...annotation.entries, action.entry];
+            }
+            else {
+                nextEntries = [...annotation.entries];
+                nextEntries[cIdx] = action.entry;
+            }
+            const nextAnnotations = [...state.annotations];
+            nextAnnotations[tIdx] = { ...annotation, entries: nextEntries };
+            return { ...state, annotations: nextAnnotations };
+        }
+        case ActionType.AnnotationsEntryRemoved: {
+            const tIdx = state.annotations.findIndex(t => t.id === action.annotationId);
+            if (tIdx < 0) {
+                return state;
+            }
+            const annotation = state.annotations[tIdx];
+            const cIdx = annotation.entries.findIndex(c => c.id === action.entryId);
+            if (cIdx < 0) {
+                return state;
+            }
+            const nextEntries = [...annotation.entries];
+            nextEntries.splice(cIdx, 1);
+            const nextAnnotations = [...state.annotations];
+            nextAnnotations[tIdx] = { ...annotation, entries: nextEntries };
+            return { ...state, annotations: nextAnnotations };
+        }
+        default:
+            softAssertNever(action, log);
+            return state;
+    }
+}
+
+export { annotationsReducer };

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

@@ -30,6 +30,16 @@ function changesetReducer(state, action, log) {
             next.splice(idx, 1);
             return { ...state, files: next };
         }
+        case ActionType.ChangesetContentChanged: {
+            const next = action.operations === undefined
+                ? { ...state, files: action.files }
+                : { ...state, files: action.files, operations: action.operations };
+            if (action.error === undefined) {
+                const { error: _ignored, ...rest } = next;
+                return rest;
+            }
+            return { ...next, error: action.error };
+        }
         case ActionType.ChangesetOperationsChanged: {
             if (action.operations === undefined) {
                 const { operations: _ignored, ...rest } = state;

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

@@ -0,0 +1,6 @@
+import { type ChatState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/state";
+import type { ChatAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/action-origin.generated";
+/**
+ * Pure reducer for chat state. Handles all {@link ChatAction} variants.
+ */
+export declare function chatReducer(state: ChatState, action: ChatAction, log?: (msg: string) => void): ChatState;