@codingame/monaco-vscode-api 37.6.1 → 38.0.1

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

@@ -9,13 +9,32 @@ import { isSessionAction, isChatAction, isChangesetAction, isAnnotationsAction }
 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 { canvasReducer } from './protocol/channels-canvas/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 './protocol/common/actions.js';
 import { automationReducer } from './protocol/channels-automation/reducer.js';
 import { automationRunReducer } from './protocol/channels-automation-run/reducer.js';
-import '../meta/agentPermissionRequestMeta.js';
+import '../../../sandbox/common/settings.js';
+import '../meta/copilotd/agentPermissionRequestMeta.js';
+import './protocol/channels-root/state.js';
+import './protocol/channels-session/state.js';
+import './protocol/channels-chat/state.js';
+import './protocol/channels-terminal/state.js';
+import './protocol/channels-changeset/state.js';
+import './protocol/channels-resource-watch/state.js';
+import './protocol/channels-automation/state.js';
+import './protocol/channels-automation-run/state.js';
+import '../../../../base/common/charCode.js';
+import '../../../../base/common/path.js';
+import '../../../../base/common/platform.js';
+import '../../../../base/common/strings.js';
+import '../../../../base/common/htmlContent.js';
+import '../../../../base/common/network.js';
+import '../../../../base/common/resources.js';
+import '../../../../nls.js';
+import '../../../../base/common/json.js';
 import { isAhpRootChannel, isAhpAutomationCatalogChannel, isAhpAutomationRunChannel, StateComponents } from './sessionState.js';
 import { normalizeLegacyChatStateErrors } from './legacyProtocolCompatibility.js';
 import { observableFromEvent } from '../../../../base/common/observableInternal/observables/observableFromEvent.js';
@@ -100,10 +119,13 @@ class BaseAgentSubscription extends Disposable {
                 if (envelope.serverSeq > _fromSeq) {
                     const isOwnAction = envelope.origin?.clientId === this._clientId;
                     this._reconcile(envelope, isOwnAction);
+                } else if (envelope.origin?.clientId === this._clientId) {
+                    this._acknowledgeSnapshotAction(envelope.origin.clientSeq);
                 }
             }
         }
     }
+    _acknowledgeSnapshotAction(_clientSeq) {}
     _reconcile(envelope, _isOwnAction) {
         if (envelope.rejectionReason) {
             return;
@@ -203,6 +225,9 @@ class SessionStateSubscription extends BaseAgentSubscription {
             channel: this._sessionUri
         }));
     }
+    _acknowledgeSnapshotAction(clientSeq) {
+        this.dropPendingByClientSeq(clientSeq);
+    }
     dropPendingByClientSeq(clientSeq) {
         const idx = this._pendingActions.findIndex(p => p.clientSeq === clientSeq);
         if (idx === -1) {
@@ -239,12 +264,29 @@ class ChatStateSubscription extends BaseAgentSubscription {
         return this._optimisticState;
     }
     _applyReducer(state, action) {
+        if (action.type === ActionType.SessionChatUpdated && action.chat === this._chatUri) {
+            const {
+                resource: _resource,
+                ...changes
+            } = action.changes;
+            return {
+                ...state,
+                ...changes
+            };
+        }
         return chatReducer(state, action, this._log);
     }
     _isRelevantEnvelope(envelope) {
-        return isChatAction(envelope.action) && envelope.channel === this._chatUri;
+        return isChatAction(envelope.action) && envelope.channel === this._chatUri || envelope.action.type === ActionType.SessionChatUpdated && envelope.action.chat === this._chatUri;
     }
     _onSnapshotApplied(fromSeq) {
+        const state = this._confirmedState;
+        for (let i = this._pendingActions.length - 1; i >= 0; i--) {
+            const action = this._pendingActions[i].action;
+            if (action.type === ActionType.ChatTurnStarted && (state?.activeTurn?.id === action.turnId || state?.turns.some(turn => turn.id === action.turnId))) {
+                this._pendingActions.splice(i, 1);
+            }
+        }
         super._onSnapshotApplied(fromSeq);
         this._recomputeOptimistic();
     }
@@ -319,6 +361,9 @@ class ChatStateSubscription extends BaseAgentSubscription {
             channel: this._chatUri
         }));
     }
+    _acknowledgeSnapshotAction(clientSeq) {
+        this.dropPendingByClientSeq(clientSeq);
+    }
     dropPendingByClientSeq(clientSeq) {
         const idx = this._pendingActions.findIndex(p => p.clientSeq === clientSeq);
         if (idx === -1) {
@@ -373,6 +418,18 @@ class AutomationRunSubscription extends BaseAgentSubscription {
         }
     }
 }
+class CanvasStateSubscription extends BaseAgentSubscription {
+    constructor(_resource, clientId, log) {
+        super(clientId, log);
+        this._resource = _resource;
+    }
+    _applyReducer(state, action) {
+        return action.type === ActionType.CanvasStateChanged ? canvasReducer(state, action, this._log) : state;
+    }
+    _isRelevantEnvelope(envelope) {
+        return envelope.channel === this._resource && envelope.action.type === ActionType.CanvasStateChanged;
+    }
+}
 class ChangesetStateSubscription extends BaseAgentSubscription {
     constructor(changesetUri, clientId, seqAllocator, log) {
         super(clientId, log);
@@ -529,6 +586,9 @@ class AnnotationsStateSubscription extends BaseAgentSubscription {
             channel: this._annotationsUri
         }));
     }
+    _acknowledgeSnapshotAction(clientSeq) {
+        this.dropPendingByClientSeq(clientSeq);
+    }
     dropPendingByClientSeq(clientSeq) {
         const index = this._pendingActions.findIndex(p => p.clientSeq === clientSeq);
         if (index === -1) {
@@ -561,6 +621,34 @@ class AgentSubscriptionManager extends Disposable {
         const entry = this._subscriptions.get(resource);
         return entry?.sub;
     }
+    refreshSubscription(resource) {
+        const entry = this._subscriptions.get(resource);
+        if (!entry) {
+            return Promise.reject(( new Error(`Subscription not found: ${resource}`)));
+        }
+        if (entry.refresh) {
+            return entry.refresh;
+        }
+        const snapshotVersion = ++entry.snapshotVersion;
+        entry.sub.beginSnapshotRefresh();
+        const refresh = (async () => {
+            try {
+                const snapshot = await this._subscribe(resource);
+                if (this._subscriptions.get(resource) === entry && entry.snapshotVersion === snapshotVersion) {
+                    entry.sub.handleSnapshot(snapshot.state, snapshot.fromSeq);
+                }
+            } catch (error) {
+                if (this._subscriptions.get(resource) === entry && entry.snapshotVersion === snapshotVersion) {
+                    entry.sub.cancelSnapshotRefresh();
+                }
+                throw error;
+            } finally {
+                entry.refresh = undefined;
+            }
+        })();
+        entry.refresh = refresh;
+        return refresh;
+    }
     getInflightSessionCreate(resource) {
         return this._inflightCreates.get(resource);
     }
@@ -589,10 +677,12 @@ class AgentSubscriptionManager extends Disposable {
             sub,
             kind,
             refCount: 1,
-            holders: ( new Map())
+            holders: ( new Map()),
+            snapshotVersion: 0
         };
         this._subscriptions.set(resource, entry);
-        void (async () => {
+        const snapshotVersion = ++entry.snapshotVersion;
+        entry.refresh = (async () => {
             const inflight = this._inflightCreates.get(resource);
             if (inflight) {
                 try {
@@ -601,15 +691,19 @@ class AgentSubscriptionManager extends Disposable {
             }
             try {
                 const snapshot = await this._subscribe(resource);
-                if (this._subscriptions.get(resource) === entry) {
+                if (this._subscriptions.get(resource) === entry && entry.snapshotVersion === snapshotVersion) {
                     sub.handleSnapshot(snapshot.state, snapshot.fromSeq);
                 }
             } catch (err) {
-                if (this._subscriptions.get(resource) === entry) {
+                if (this._subscriptions.get(resource) === entry && entry.snapshotVersion === snapshotVersion) {
                     sub.setError(err instanceof Error ? err : ( new Error(String(err))));
                 }
+                throw err;
             }
-        })();
+        })().finally(() => {
+            entry.refresh = undefined;
+        });
+        void entry.refresh.catch(() => {});
         return this._acquireReference(resource, entry, owner);
     }
     _acquireReference(resource, entry, owner) {
@@ -729,15 +823,28 @@ class AgentSubscriptionManager extends Disposable {
         if (!entry) {
             return;
         }
+        entry.snapshotVersion++;
         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();
+        if (isAhpRootChannel(( resource.toString()))) {
+            this._rootState.beginSnapshotRefresh();
+            return;
+        }
+        const entry = this._subscriptions.get(resource);
+        if (entry) {
+            entry.snapshotVersion++;
+            entry.sub.beginSnapshotRefresh();
+        }
     }
     cancelSnapshotRefresh(resource) {
+        if (isAhpRootChannel(( resource.toString()))) {
+            this._rootState.cancelSnapshotRefresh();
+            return;
+        }
         this._subscriptions.get(resource)?.sub.cancelSnapshotRefresh();
     }
     markSubscriptionsMissing(missing) {
@@ -767,6 +874,8 @@ class AgentSubscriptionManager extends Disposable {
             return ( new AutomationCatalogSubscription(this._clientId, this._log));
         case StateComponents.AutomationRun:
             return ( new AutomationRunSubscription(key, this._clientId, this._log));
+        case StateComponents.Canvas:
+            return ( new CanvasStateSubscription(key, this._clientId, this._log));
         case StateComponents.Root:
             throw ( new Error("_createSubscription: root subscription is managed separately"));
         default:
@@ -800,4 +909,4 @@ function observableFromSubscription(owner, sub) {
     });
 }
 
-export { AgentSubscriptionManager, AnnotationsStateSubscription, AutomationCatalogSubscription, AutomationRunSubscription, ChangesetStateSubscription, ChatStateSubscription, RootStateSubscription, SessionStateSubscription, TerminalStateSubscription, observableFromSubscription };
+export { AgentSubscriptionManager, AnnotationsStateSubscription, AutomationCatalogSubscription, AutomationRunSubscription, CanvasStateSubscription, ChangesetStateSubscription, ChatStateSubscription, RootStateSubscription, SessionStateSubscription, TerminalStateSubscription, observableFromSubscription };

package/vscode/src/vs/platform/agentHost/common/state/protocol/action-origin.generated.d.ts

@@ -1,4 +1,4 @@
-import { type StateAction, type RootAgentsChangedAction, type RootActiveSessionsChangedAction, type RootTerminalsChangedAction, type RootConfigChangedAction, type SessionReadyAction, type SessionCreationFailedAction, type SessionChatAddedAction, type SessionChatRemovedAction, type SessionChatUpdatedAction, type SessionDefaultChatChangedAction, type SessionTitleChangedAction, type SessionServerToolsChangedAction, type SessionActiveClientSetAction, type SessionActiveClientRemovedAction, type SessionWorkingDirectorySetAction, type SessionWorkingDirectoryRemovedAction, type SessionWorkingDirectoryReplacedAction, type SessionInputNeededSetAction, type SessionInputNeededRemovedAction, type SessionCustomizationsChangedAction, type SessionCustomizationToggledAction, type SessionCustomizationUpdatedAction, type SessionCustomizationRemovedAction, type SessionMcpServerStateChangedAction, type SessionMcpServerStartRequestedAction, type SessionMcpServerStopRequestedAction, type SessionIsReadChangedAction, type SessionIsArchivedChangedAction, type SessionActivityChangedAction, type SessionChangesetsChangedAction, type SessionConfigChangedAction, type SessionMetaChangedAction, type ChatTurnStartedAction, type ChatDeltaAction, type ChatResponsePartAction, type ChatToolCallStartAction, type ChatToolCallDeltaAction, type ChatToolCallReadyAction, type ChatToolCallConfirmedAction, type ChatToolCallCompleteAction, type ChatToolCallResultConfirmedAction, type ChatToolCallContentChangedAction, type ChatToolCallAuthRequiredAction, type ChatToolCallAuthResolvedAction, type ChatTurnCompleteAction, type ChatTurnCancelledAction, type ChatErrorAction, type ChatTurnResumeAction, type ChatActivityChangedAction, type ChatWorkingDirectorySetAction, type ChatWorkingDirectoryRemovedAction, type ChatUsageAction, type ChatReasoningAction, type ChatPendingMessageSetAction, type ChatPendingMessageRemovedAction, type ChatQueuedMessagesReorderedAction, type ChatDraftChangedAction, type ChatInputRequestedAction, type ChatInputAnswerChangedAction, type ChatInputCompletedAction, type ChatTruncatedAction, type ChatTurnsLoadedAction, type ChangesetStatusChangedAction, type ChangesetFileSetAction, type ChangesetFileRemovedAction, type ChangesetFilesReviewChangedAction, type ChangesetContentChangedAction, type ChangesetOperationsChangedAction, type ChangesetOperationStatusChangedAction, type ChangesetClearedAction, type AnnotationsSetAction, type AnnotationsUpdatedAction, type AnnotationsRemovedAction, type AnnotationsEntrySetAction, type AnnotationsEntryRemovedAction, type TerminalDataAction, type TerminalInputAction, type TerminalResizedAction, type TerminalClaimedAction, type TerminalTitleChangedAction, type TerminalCwdChangedAction, type TerminalExitedAction, type TerminalClearedAction, type TerminalCommandDetectionAvailableAction, type TerminalCommandExecutedAction, type TerminalCommandFinishedAction, type ResourceWatchChangedAction, type AutomationCreateRequestedAction, type AutomationUpdateRequestedAction, type AutomationSetAction, type AutomationRemovedAction, type AutomationRunLifecycleChangedAction, type AutomationRunSessionSetAction, type AutomationRunSessionRemovedAction, type AutomationRunPrimarySessionChangedAction, type AutomationRunCancelRequestedAction } from "./actions.js";
+import { type StateAction, type RootAgentsChangedAction, type RootActiveSessionsChangedAction, type RootTerminalsChangedAction, type RootConfigChangedAction, type SessionReadyAction, type SessionCreationFailedAction, type SessionChatAddedAction, type SessionChatRemovedAction, type SessionChatUpdatedAction, type SessionChatsReorderedAction, type SessionDefaultChatChangedAction, type SessionTitleChangedAction, type SessionServerToolsChangedAction, type SessionActiveClientSetAction, type SessionActiveClientRemovedAction, type SessionWorkingDirectorySetAction, type SessionWorkingDirectoryRemovedAction, type SessionWorkingDirectoryReplacedAction, type SessionInputNeededSetAction, type SessionInputNeededRemovedAction, type SessionCustomizationsChangedAction, type SessionCustomizationToggledAction, type SessionCustomizationUpdatedAction, type SessionCustomizationRemovedAction, type SessionMcpServerStateChangedAction, type SessionMcpServerStartRequestedAction, type SessionMcpServerStopRequestedAction, type SessionMcpServerBackgroundRequestedAction, type SessionIsReadChangedAction, type SessionIsArchivedChangedAction, type SessionActivityChangedAction, type SessionChangesetsChangedAction, type SessionConfigChangedAction, type SessionMetaChangedAction, type ChatTurnStartedAction, type ChatDeltaAction, type ChatResponsePartAction, type ChatToolCallStartAction, type ChatToolCallDeltaAction, type ChatToolCallReadyAction, type ChatToolCallConfirmedAction, type ChatToolCallCompleteAction, type ChatToolCallResultConfirmedAction, type ChatToolCallContentChangedAction, type ChatToolCallAuthRequiredAction, type ChatToolCallAuthResolvedAction, type ChatTurnCompleteAction, type ChatTurnCancelledAction, type ChatErrorAction, type ChatTurnResumeAction, type ChatActivityChangedAction, type ChatBackgroundWorkSetAction, type ChatBackgroundWorkRemovedAction, type ChatMovableChangedAction, type ChatChangesetsChangedAction, type ChatCanvasesChangedAction, type CanvasStateChangedAction, type ChatWorkingDirectorySetAction, type ChatWorkingDirectoryRemovedAction, type ChatUsageAction, type ChatReasoningAction, type ChatPendingMessageSetAction, type ChatPendingMessageRemovedAction, type ChatQueuedMessagesReorderedAction, type ChatDraftChangedAction, type ChatIsReadChangedAction, type ChatIsArchivedChangedAction, type ChatInputRequestedAction, type ChatInputAnswerChangedAction, type ChatInputCompletedAction, type ChatTruncatedAction, type ChatTurnsLoadedAction, type ChangesetStatusChangedAction, type ChangesetFileSetAction, type ChangesetFileRemovedAction, type ChangesetFilesReviewChangedAction, type ChangesetContentChangedAction, type ChangesetOperationsChangedAction, type ChangesetOperationStatusChangedAction, type ChangesetClearedAction, type AnnotationsSetAction, type AnnotationsUpdatedAction, type AnnotationsRemovedAction, type AnnotationsEntrySetAction, type AnnotationsEntryRemovedAction, type TerminalDataAction, type TerminalInputAction, type TerminalResizedAction, type TerminalClaimedAction, type TerminalTitleChangedAction, type TerminalCwdChangedAction, type TerminalExitedAction, type TerminalClearedAction, type TerminalCommandDetectionAvailableAction, type TerminalCommandExecutedAction, type TerminalCommandFinishedAction, type ResourceWatchChangedAction, type AutomationCreateRequestedAction, type AutomationUpdateRequestedAction, type AutomationSetAction, type AutomationRemovedAction, type AutomationRunLifecycleChangedAction, type AutomationRunSessionSetAction, type AutomationRunSessionRemovedAction, type AutomationRunPrimarySessionChangedAction, type AutomationRunCancelRequestedAction } from "./actions.js";
 /** Union of all root-scoped actions. */
 export type RootAction = RootAgentsChangedAction | RootActiveSessionsChangedAction | RootTerminalsChangedAction | RootConfigChangedAction;
 /** Union of root actions that clients may dispatch. */
@@ -6,17 +6,23 @@ export type ClientRootAction = RootConfigChangedAction;
 /** Union of root actions that only the server may produce. */
 export type ServerRootAction = RootAgentsChangedAction | RootActiveSessionsChangedAction | RootTerminalsChangedAction;
 /** Union of all session-scoped actions. */
-export type SessionAction = SessionReadyAction | SessionCreationFailedAction | SessionChatAddedAction | SessionChatRemovedAction | SessionChatUpdatedAction | SessionDefaultChatChangedAction | SessionTitleChangedAction | SessionServerToolsChangedAction | SessionActiveClientSetAction | SessionActiveClientRemovedAction | SessionWorkingDirectorySetAction | SessionWorkingDirectoryRemovedAction | SessionWorkingDirectoryReplacedAction | SessionInputNeededSetAction | SessionInputNeededRemovedAction | SessionCustomizationsChangedAction | SessionCustomizationToggledAction | SessionCustomizationUpdatedAction | SessionCustomizationRemovedAction | SessionMcpServerStateChangedAction | SessionMcpServerStartRequestedAction | SessionMcpServerStopRequestedAction | SessionIsReadChangedAction | SessionIsArchivedChangedAction | SessionActivityChangedAction | SessionChangesetsChangedAction | SessionConfigChangedAction | SessionMetaChangedAction;
+export type SessionAction = SessionReadyAction | SessionCreationFailedAction | SessionChatAddedAction | SessionChatRemovedAction | SessionChatUpdatedAction | SessionChatsReorderedAction | SessionDefaultChatChangedAction | SessionTitleChangedAction | SessionServerToolsChangedAction | SessionActiveClientSetAction | SessionActiveClientRemovedAction | SessionWorkingDirectorySetAction | SessionWorkingDirectoryRemovedAction | SessionWorkingDirectoryReplacedAction | SessionInputNeededSetAction | SessionInputNeededRemovedAction | SessionCustomizationsChangedAction | SessionCustomizationToggledAction | SessionCustomizationUpdatedAction | SessionCustomizationRemovedAction | SessionMcpServerStateChangedAction | SessionMcpServerStartRequestedAction | SessionMcpServerStopRequestedAction | SessionMcpServerBackgroundRequestedAction | SessionIsReadChangedAction | SessionIsArchivedChangedAction | SessionActivityChangedAction | SessionChangesetsChangedAction | SessionConfigChangedAction | SessionMetaChangedAction;
 /** Union of session actions that clients may dispatch. */
-export type ClientSessionAction = SessionTitleChangedAction | SessionActiveClientSetAction | SessionActiveClientRemovedAction | SessionWorkingDirectorySetAction | SessionWorkingDirectoryRemovedAction | SessionWorkingDirectoryReplacedAction | SessionCustomizationToggledAction | SessionMcpServerStartRequestedAction | SessionMcpServerStopRequestedAction | SessionIsReadChangedAction | SessionIsArchivedChangedAction | SessionConfigChangedAction;
+export type ClientSessionAction = SessionTitleChangedAction | SessionActiveClientSetAction | SessionActiveClientRemovedAction | SessionWorkingDirectorySetAction | SessionWorkingDirectoryRemovedAction | SessionWorkingDirectoryReplacedAction | SessionCustomizationToggledAction | SessionMcpServerStartRequestedAction | SessionMcpServerStopRequestedAction | SessionMcpServerBackgroundRequestedAction | SessionIsReadChangedAction | SessionIsArchivedChangedAction | SessionConfigChangedAction;
 /** Union of session actions that only the server may produce. */
-export type ServerSessionAction = SessionReadyAction | SessionCreationFailedAction | SessionChatAddedAction | SessionChatRemovedAction | SessionChatUpdatedAction | SessionDefaultChatChangedAction | SessionServerToolsChangedAction | SessionInputNeededSetAction | SessionInputNeededRemovedAction | SessionCustomizationsChangedAction | SessionCustomizationUpdatedAction | SessionCustomizationRemovedAction | SessionMcpServerStateChangedAction | SessionActivityChangedAction | SessionChangesetsChangedAction | SessionMetaChangedAction;
+export type ServerSessionAction = SessionReadyAction | SessionCreationFailedAction | SessionChatAddedAction | SessionChatRemovedAction | SessionChatUpdatedAction | SessionChatsReorderedAction | SessionDefaultChatChangedAction | SessionServerToolsChangedAction | SessionInputNeededSetAction | SessionInputNeededRemovedAction | SessionCustomizationsChangedAction | SessionCustomizationUpdatedAction | SessionCustomizationRemovedAction | SessionMcpServerStateChangedAction | SessionActivityChangedAction | SessionChangesetsChangedAction | SessionMetaChangedAction;
 /** Union of all chat-scoped actions. */
-export type ChatAction = ChatTurnStartedAction | ChatDeltaAction | ChatResponsePartAction | ChatToolCallStartAction | ChatToolCallDeltaAction | ChatToolCallReadyAction | ChatToolCallConfirmedAction | ChatToolCallCompleteAction | ChatToolCallResultConfirmedAction | ChatToolCallContentChangedAction | ChatToolCallAuthRequiredAction | ChatToolCallAuthResolvedAction | ChatTurnCompleteAction | ChatTurnCancelledAction | ChatErrorAction | ChatTurnResumeAction | ChatActivityChangedAction | ChatWorkingDirectorySetAction | ChatWorkingDirectoryRemovedAction | ChatUsageAction | ChatReasoningAction | ChatPendingMessageSetAction | ChatPendingMessageRemovedAction | ChatQueuedMessagesReorderedAction | ChatDraftChangedAction | ChatInputRequestedAction | ChatInputAnswerChangedAction | ChatInputCompletedAction | ChatTruncatedAction | ChatTurnsLoadedAction;
+export type ChatAction = ChatTurnStartedAction | ChatDeltaAction | ChatResponsePartAction | ChatToolCallStartAction | ChatToolCallDeltaAction | ChatToolCallReadyAction | ChatToolCallConfirmedAction | ChatToolCallCompleteAction | ChatToolCallResultConfirmedAction | ChatToolCallContentChangedAction | ChatToolCallAuthRequiredAction | ChatToolCallAuthResolvedAction | ChatTurnCompleteAction | ChatTurnCancelledAction | ChatErrorAction | ChatTurnResumeAction | ChatActivityChangedAction | ChatBackgroundWorkSetAction | ChatBackgroundWorkRemovedAction | ChatMovableChangedAction | ChatChangesetsChangedAction | ChatCanvasesChangedAction | ChatWorkingDirectorySetAction | ChatWorkingDirectoryRemovedAction | ChatUsageAction | ChatReasoningAction | ChatPendingMessageSetAction | ChatPendingMessageRemovedAction | ChatQueuedMessagesReorderedAction | ChatDraftChangedAction | ChatIsReadChangedAction | ChatIsArchivedChangedAction | ChatInputRequestedAction | ChatInputAnswerChangedAction | ChatInputCompletedAction | ChatTruncatedAction | ChatTurnsLoadedAction;
 /** Union of chat actions that clients may dispatch. */
-export type ClientChatAction = ChatTurnStartedAction | ChatToolCallConfirmedAction | ChatToolCallCompleteAction | ChatToolCallResultConfirmedAction | ChatToolCallContentChangedAction | ChatTurnCancelledAction | ChatTurnResumeAction | ChatWorkingDirectorySetAction | ChatWorkingDirectoryRemovedAction | ChatPendingMessageSetAction | ChatPendingMessageRemovedAction | ChatQueuedMessagesReorderedAction | ChatDraftChangedAction | ChatInputAnswerChangedAction | ChatInputCompletedAction | ChatTruncatedAction;
+export type ClientChatAction = ChatTurnStartedAction | ChatToolCallConfirmedAction | ChatToolCallCompleteAction | ChatToolCallResultConfirmedAction | ChatToolCallContentChangedAction | ChatTurnCancelledAction | ChatTurnResumeAction | ChatWorkingDirectorySetAction | ChatWorkingDirectoryRemovedAction | ChatPendingMessageSetAction | ChatPendingMessageRemovedAction | ChatQueuedMessagesReorderedAction | ChatDraftChangedAction | ChatIsReadChangedAction | ChatIsArchivedChangedAction | ChatInputAnswerChangedAction | ChatInputCompletedAction | ChatTruncatedAction;
 /** Union of chat actions that only the server may produce. */
-export type ServerChatAction = ChatDeltaAction | ChatResponsePartAction | ChatToolCallStartAction | ChatToolCallDeltaAction | ChatToolCallReadyAction | ChatToolCallAuthRequiredAction | ChatToolCallAuthResolvedAction | ChatTurnCompleteAction | ChatErrorAction | ChatActivityChangedAction | ChatUsageAction | ChatReasoningAction | ChatInputRequestedAction | ChatTurnsLoadedAction;
+export type ServerChatAction = ChatDeltaAction | ChatResponsePartAction | ChatToolCallStartAction | ChatToolCallDeltaAction | ChatToolCallReadyAction | ChatToolCallAuthRequiredAction | ChatToolCallAuthResolvedAction | ChatTurnCompleteAction | ChatErrorAction | ChatActivityChangedAction | ChatBackgroundWorkSetAction | ChatBackgroundWorkRemovedAction | ChatMovableChangedAction | ChatChangesetsChangedAction | ChatCanvasesChangedAction | ChatUsageAction | ChatReasoningAction | ChatInputRequestedAction | ChatTurnsLoadedAction;
+/** Union of all canvas-scoped actions. */
+export type CanvasAction = CanvasStateChangedAction;
+/** Union of canvas actions that clients may dispatch. */
+export type ClientCanvasAction = never;
+/** Union of canvas actions that only the server may produce. */
+export type ServerCanvasAction = CanvasStateChangedAction;
 /** Union of all terminal-scoped actions. */
 export type TerminalAction = TerminalDataAction | TerminalInputAction | TerminalResizedAction | TerminalClaimedAction | TerminalTitleChangedAction | TerminalCwdChangedAction | TerminalExitedAction | TerminalClearedAction | TerminalCommandDetectionAvailableAction | TerminalCommandExecutedAction | TerminalCommandFinishedAction;
 /** Union of terminal actions that clients may dispatch. */

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

@@ -2,6 +2,7 @@ export * from "./common/actions.js";
 export * from "./channels-root/actions.js";
 export * from "./channels-session/actions.js";
 export * from "./channels-chat/actions.js";
+export * from "./channels-canvas/actions.js";
 export * from "./channels-terminal/actions.js";
 export * from "./channels-changeset/actions.js";
 export * from "./channels-annotations/actions.js";

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

@@ -1,7 +1,7 @@
 import { ActionType } from "../common/actions.js";
 import type { Message } from "../channels-chat/state.js";
 import type { URI } from "../common/state.js";
-import type { AutomationDefinition, AutomationEntry, AutomationSessionTemplate, AutomationTrigger } from "./state.js";
+import type { AutomationDefinition, AutomationDisableCondition, AutomationEntry, AutomationSessionTemplate, AutomationTrigger } from "./state.js";
 /**
  * Partial replacement of editable {@link AutomationDefinition} fields.
  *
@@ -17,7 +17,9 @@ export interface AutomationDefinitionPatch {
     message?: Message;
     /**
      * Replacement {@link AutomationDefinition.session}. The host revalidates
-     * affected event triggers when their discovery context changes.
+     * affected event triggers when their discovery context changes, and
+     * captures {@link AutomationSessionTemplate.customizations} entries that
+     * are new or whose `uri` or `nonce` changed.
      */
     session?: AutomationSessionTemplate;
     /** Replacement {@link AutomationDefinition.enabled}. */
@@ -27,6 +29,15 @@ export interface AutomationDefinitionPatch {
      * validates event ids and normalizes event-trigger titles and descriptions.
      */
     triggers?: AutomationTrigger[];
+    /**
+     * Complete replacement {@link AutomationDefinition.disableConditions}.
+     * Omit to leave unchanged; supply an empty array to remove all conditions.
+     * Each kind may appear at most once; hosts MUST reject duplicate kinds.
+     * Clearing conditions does not change {@link AutomationDefinition.enabled}.
+     *
+     * @uniqueItemsBy kind
+     */
+    disableConditions?: AutomationDisableCondition[];
     /** Complete replacement {@link AutomationDefinition._meta}. */
     _meta?: Record<string, unknown>;
 }
@@ -40,7 +51,9 @@ export interface AutomationDefinitionPatch {
  *
  * This side-effect request leaves optimistic catalogue state unchanged. The
  * host validates trigger ids and configuration, normalizes event-trigger
- * titles and descriptions, persists the definition, then publishes the
+ * titles and descriptions, captures any
+ * {@link AutomationSessionTemplate.customizations | session customizations}
+ * from the dispatching client, persists the definition, then publishes the
  * authoritative result with {@link AutomationSetAction | `automation/set`}.
  * Rejections leave the catalogue unchanged.
  *

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

@@ -2,7 +2,7 @@ import type { Message } from "../channels-chat/state.js";
 import type { ConfigSchema, URI } from "../common/state.js";
 import type { AutomationRunSummary } from "../channels-automation-run/state.js";
 import type { ModelSelection } from "../channels-root/state.js";
-import type { AgentSelection } from "../channels-session/state.js";
+import type { AgentSelection, ClientPluginCustomization, PluginCustomization } from "../channels-session/state.js";
 /**
  * Operations the host currently permits for an automation.
  *
@@ -157,6 +157,49 @@ export interface AutomationEventTrigger {
  * @category Automation State
  */
 export type AutomationTrigger = AutomationScheduleTrigger | AutomationEventTrigger;
+/**
+ * Discriminant for an {@link AutomationDisableCondition}.
+ *
+ * @category Automation State
+ * @exhaustive
+ */
+export declare enum AutomationDisableConditionKind {
+    /** Stop scheduling after a fixed number of scheduled runs. */
+    AfterRuns = "afterRuns",
+    /** Stop scheduling once a wall-clock date passes. */
+    AfterDate = "afterDate"
+}
+/**
+ * Stops scheduling after a fixed number of scheduled runs.
+ *
+ * @category Automation State
+ */
+export interface AutomationAfterRunsCondition {
+    kind: AutomationDisableConditionKind.AfterRuns;
+    /**
+     * Positive-integer cap on scheduled runs.
+     * @integer
+     * @minimum 1
+     */
+    max: number;
+}
+/**
+ * Stops scheduling once a wall-clock date passes.
+ *
+ * @category Automation State
+ */
+export interface AutomationAfterDateCondition {
+    kind: AutomationDisableConditionKind.AfterDate;
+    /** ISO 8601 timestamp after which scheduling stops. */
+    date: string;
+}
+/**
+ * One self-disable rule in {@link AutomationDefinition.disableConditions}.
+ * The host disables scheduling once any rule is met (logical OR).
+ *
+ * @category Automation State
+ */
+export type AutomationDisableCondition = AutomationAfterRunsCondition | AutomationAfterDateCondition;
 /**
  * Describes one host-defined trigger event.
  *
@@ -223,6 +266,32 @@ export interface AutomationSessionTemplate {
      * {@link ResolveSessionConfigResult.values}.
      */
     config?: Record<string, unknown>;
+    /**
+     * Client plugins to make available in every run session, in the same
+     * published shape as
+     * {@link SessionActiveClient.customizations | `activeClients[].customizations`}.
+     * Entries are keyed by `id`.
+     *
+     * Runs usually start when no client is connected, so the host does not
+     * resolve these URIs at run time. Instead, when it accepts a
+     * {@link AutomationCreateRequestedAction | `automation/createRequested`} or
+     * {@link AutomationUpdateRequestedAction | `automation/updateRequested`}
+     * that adds an entry or changes an entry's `uri` or `nonce`, the host
+     * captures a host-owned copy of the plugin. For client-served URIs such as
+     * `virtual://…`, it reads the contents from the dispatching client with
+     * server→client `resource*` requests. If a capture fails, the host rejects
+     * the whole action. Entries whose `id`, `uri`, and `nonce` are unchanged keep
+     * their existing copy, so any client can re-submit a template it received
+     * without being able to serve the plugin itself. The resulting copies are
+     * reported in {@link AutomationEntry.customizations}.
+     *
+     * The host MAY share one stored copy between entries with equal `uri` and
+     * `nonce`, including across automations; this is not observable to clients.
+     *
+     * Clients MUST NOT set this field unless the host advertises
+     * {@link AutomationCapabilities.customizations}.
+     */
+    customizations?: ClientPluginCustomization[];
 }
 /**
  * Durable, client-editable definition of an automation.
@@ -251,6 +320,24 @@ export interface AutomationDefinition {
     enabled: boolean;
     /** Automatic triggers. An empty list means manual-only. */
     triggers: AutomationTrigger[];
+    /**
+     * Self-disable rules combined with logical OR: the host sets
+     * {@link AutomationDefinition.enabled} to `false` when any condition is met.
+     * Absent or empty means no automatic disable conditions. Each
+     * {@link AutomationDisableConditionKind} may appear at most once; hosts MUST
+     * reject create or update requests containing duplicate kinds.
+     *
+     * Only automatic (scheduled) runs are governed; manual runs via
+     * {@link RunAutomationParams | runAutomation} are never blocked. For a
+     * {@link AutomationAfterRunsCondition}, usage is tracked by the host-owned
+     * {@link AutomationEntry.runCount}. Adding that kind when absent or
+     * a disabled→enabled transition starts a fresh allowance. Clearing the
+     * conditions does not re-enable a disabled automation. See the
+     * {@link /guide/automations | Automations Guide}.
+     *
+     * @uniqueItemsBy kind
+     */
+    disableConditions?: AutomationDisableCondition[];
     /**
      * Opaque implementation-defined metadata. Clients MUST preserve unknown
      * entries when updating the definition.
@@ -273,6 +360,20 @@ export interface AutomationEntry {
     definition: AutomationDefinition;
     /** Earliest schedule occurrence awaiting evaluation, as an ISO 8601 timestamp. It may be in the past while catch-up is pending. */
     nextRunAt?: string;
+    /**
+     * Host-owned count of scheduled runs consumed against the current
+     * {@link AutomationAfterRunsCondition} allowance. Authoritative usage for the
+     * **current** allowance, not a lifetime total: the host resets it to `0` when
+     * a disabled→enabled transition starts a fresh allowance or a
+     * {@link AutomationAfterRunsCondition} is added when none was present. It is NOT
+     * reconstructed from {@link runs} (a bounded, prunable window). The host
+     * increments it atomically when it admits a scheduled run, including runs
+     * later cancelled or failed.
+     *
+     * Absent when {@link AutomationDefinition.disableConditions} contains no
+     * {@link AutomationAfterRunsCondition}.
+     */
+    runCount?: number;
     /**
      * Newest-first retained run summaries. This is a bounded window; use
      * {@link FetchAutomationRunsParams | fetchAutomationRuns} when
@@ -283,6 +384,22 @@ export interface AutomationEntry {
     runsNextCursor?: string;
     /** Operations currently permitted for this automation. */
     operations: AutomationOperation[];
+    /**
+     * Host-owned copies of the plugins in
+     * {@link AutomationSessionTemplate.customizations}, one per template entry
+     * with the same `id`. Absent when the template has no customizations.
+     *
+     * Each copy's `uri` identifies the captured contents, which clients can
+     * browse with `resourceRead`. `children` and `load` report what the host
+     * found in that copy, independent of whether the originating client is
+     * connected. `clientId` is absent because the copy no longer depends on a
+     * client.
+     *
+     * Every run session receives these plugins in
+     * {@link SessionState.customizations}, with the enablement from the
+     * matching template entry.
+     */
+    customizations?: PluginCustomization[];
     /** Creation timestamp in ISO 8601 format. */
     createdAt: string;
     /** Last definition modification timestamp in ISO 8601 format. */

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

@@ -16,5 +16,10 @@ var AutomationTriggerKind;
     AutomationTriggerKind["Schedule"] = "schedule";
     AutomationTriggerKind["Event"] = "event";
 })(AutomationTriggerKind || (AutomationTriggerKind = {}));
+var AutomationDisableConditionKind;
+(function (AutomationDisableConditionKind) {
+    AutomationDisableConditionKind["AfterRuns"] = "afterRuns";
+    AutomationDisableConditionKind["AfterDate"] = "afterDate";
+})(AutomationDisableConditionKind || (AutomationDisableConditionKind = {}));
 
-export { AutomationMisfirePolicy, AutomationOperation, AutomationTriggerKind };
+export { AutomationDisableConditionKind, AutomationMisfirePolicy, AutomationOperation, AutomationTriggerKind };

package/vscode/src/vs/platform/agentHost/common/state/protocol/channels-canvas/actions.d.ts

@@ -0,0 +1,17 @@
+import { ActionType } from "../common/actions.js";
+import type { CanvasState } from "./state.js";
+/**
+ * The presentation state for this canvas changed.
+ *
+ * Replaces the subscribed canvas channel state entirely. Full-replacement
+ * semantics intentionally keep this early-development channel free to evolve
+ * without expanding the stable chat action surface.
+ *
+ * @category Canvas Actions
+ * @version 1
+ */
+export interface CanvasStateChangedAction {
+    type: ActionType.CanvasStateChanged;
+    /** New authoritative canvas state. */
+    canvas: CanvasState;
+}

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

@@ -0,0 +1,10 @@
+import type { CanvasAction } from "../action-origin.generated.js";
+import type { CanvasState } from "./state.js";
+/**
+ * Pure reducer for canvas state.
+ *
+ * The channel currently has one full-replacement action. The `if` form keeps
+ * unknown future actions forward-compatible because TypeScript cannot narrow a
+ * single-variant action union to `never` for the usual exhaustiveness helper.
+ */
+export declare function canvasReducer(state: CanvasState, action: CanvasAction, log?: (msg: string) => void): CanvasState;

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

@@ -0,0 +1,12 @@
+
+import { ActionType } from '../common/actions.js';
+
+function canvasReducer(state, action, log) {
+    if (action.type === ActionType.CanvasStateChanged) {
+        return action.canvas;
+    }
+    (log ?? console.warn)(`Unhandled action type: ${JSON.stringify(action)}`);
+    return state;
+}
+
+export { canvasReducer };

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

@@ -0,0 +1,45 @@
+import type { URI } from "../common/state.js";
+/**
+ * Stable reference to a subscribable canvas channel.
+ *
+ * Chat state intentionally carries only this reference so the experimental
+ * canvas presentation model can evolve without changing the stable chat
+ * channel shape.
+ *
+ * @category Canvas State
+ */
+export interface CanvasReference {
+    /** Canvas channel URI. Subscribe to this resource for the full state. */
+    resource: URI;
+}
+/**
+ * Full state for one live canvas, returned when a client subscribes to its
+ * `ahp-canvas:` URI.
+ *
+ * The client already knows the subscribed resource, so the state does not
+ * redundantly carry its channel URI.
+ *
+ * @category Canvas State
+ */
+export interface CanvasState {
+    /** Stable caller-supplied instance identifier. */
+    instanceId: string;
+    /** Owning extension/provider identifier. */
+    extensionId: string;
+    /** Owning extension display name, when available. */
+    extensionName?: string;
+    /** Provider-local canvas type identifier. */
+    canvasId: string;
+    /** Provider-supplied title, when available. */
+    title?: string;
+    /** Provider-supplied status text, when available. */
+    status?: string;
+    /**
+     * Current absolute HTTP(S) source URL; absent when the live source is unavailable.
+     * Hosts MUST clear this field when the provider becomes unavailable.
+     *
+     * Source URLs MUST be redacted from diagnostic logs and MUST NOT be reused
+     * from persisted state after a provider or host restart.
+     */
+    url?: URI;
+}

package/vscode/src/vs/platform/agentHost/common/state/protocol/channels-changeset/actions.d.ts

@@ -3,8 +3,9 @@ import type { ErrorInfo } from "../common/state.js";
 import { ChangesetStatus, type ChangesetFile, type ChangesetOperation, type ChangesetOperationStatus } from "./state.js";
 /**
  * The {@link ChangesetState.status} for this changeset transitioned (e.g.
- * `computing → ready`). The error payload is set together with `status`
- * whenever it transitions to {@link ChangesetStatus.Error | Error}.
+ * `computing → ready` or `recomputing → ready`). The error payload is set
+ * together with `status` whenever it transitions to
+ * {@link ChangesetStatus.Error | Error}.
  *
  * @category Changeset Actions
  * @version 2