@codingame/monaco-vscode-chat-service-override 33.0.8 → 34.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostModeSynchronizer.js

@@ -0,0 +1,177 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { AgentSession } from '../../../../../../platform/agentHost/common/agentService.js';
+import { IAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service';
+import { fromAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { agentHostAgentPickerStorageKey } from '../../../../../../platform/agentHost/common/customAgents.js';
+import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
+import { StateComponents } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { ChatMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes';
+import { ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { IAgentHostUntitledProvisionalSessionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostUntitledProvisionalSessionService.service';
+
+const AGENT_HOST_SESSION_SCHEME_PREFIX = "agent-host-";
+let AgentHostModeSynchronizer = class AgentHostModeSynchronizer extends Disposable {
+    static {
+        this.ID = "workbench.contrib.agentHostModeSynchronizer";
+    }
+    constructor(
+        _chatWidgetService,
+        _agentHostService,
+        _provisionalSessionService,
+        _storageService,
+        environmentService
+    ) {
+        super();
+        this._chatWidgetService = _chatWidgetService;
+        this._agentHostService = _agentHostService;
+        this._provisionalSessionService = _provisionalSessionService;
+        this._storageService = _storageService;
+        this._widgetListeners = this._register(( new DisposableMap()));
+        this._updatingWidgets = ( new Set());
+        if (environmentService.isSessionsWindow) {
+            return;
+        }
+        for (const widget of this._chatWidgetService.getAllWidgets()) {
+            this._attachWidget(widget);
+        }
+        this._register(
+            this._chatWidgetService.onDidAddWidget(widget => this._attachWidget(widget))
+        );
+        this._register(this._chatWidgetService.onDidChangeFocusedSession(() => {
+            const widget = this._chatWidgetService.lastFocusedWidget;
+            if (widget) {
+                this._syncWidgetFromBackend(widget);
+            }
+        }));
+        this._register(this._provisionalSessionService.onDidChange(sessionResource => {
+            const widget = this._chatWidgetService.getWidgetBySessionResource(sessionResource);
+            if (widget) {
+                this._syncWidgetFromBackend(widget);
+            }
+        }));
+        this._register(this._agentHostService.onDidAction(envelope => {
+            if (envelope.action.type === ActionType.SessionAgentChanged) {
+                this._syncWidgetsFromBackend();
+            }
+        }));
+    }
+    _attachWidget(widget) {
+        if (( this._widgetListeners.has(widget))) {
+            return;
+        }
+        const store = ( new DisposableStore());
+        store.add(
+            widget.input.onDidChangeCurrentChatMode(() => this._onWidgetModeChanged(widget))
+        );
+        store.add(widget.onDidChangeViewModel(() => this._syncWidgetFromBackend(widget)));
+        this._widgetListeners.set(widget, store);
+        this._syncWidgetFromBackend(widget);
+    }
+    _syncWidgetsFromBackend() {
+        for (const widget of this._chatWidgetService.getAllWidgets()) {
+            this._syncWidgetFromBackend(widget);
+        }
+    }
+    _onWidgetModeChanged(widget) {
+        if (( this._updatingWidgets.has(widget))) {
+            return;
+        }
+        const sessionResource = widget.viewModel?.sessionResource;
+        const backendSession = sessionResource ? this._resolveBackendSession(sessionResource) : undefined;
+        if (!sessionResource || !backendSession) {
+            return;
+        }
+        const mode = widget.input.currentModeObs.get();
+        const agentUri = this._agentUriFromMode(mode);
+        this._storeSelectedAgent(sessionResource, agentUri);
+        const currentAgentUri = this._readSessionState(backendSession)?.summary.agent?.uri;
+        if (currentAgentUri === agentUri) {
+            return;
+        }
+        this._agentHostService.dispatch(( backendSession.toString()), {
+            type: ActionType.SessionAgentChanged,
+            ...(agentUri ? {
+                agent: {
+                    uri: agentUri
+                }
+            } : {})
+        });
+    }
+    _syncWidgetFromBackend(widget) {
+        const sessionResource = widget.viewModel?.sessionResource;
+        const backendSession = sessionResource ? this._resolveBackendSession(sessionResource) : undefined;
+        if (!sessionResource || !backendSession) {
+            return;
+        }
+        const agentUri = this._readSessionState(backendSession)?.summary.agent?.uri;
+        void this._applyMode(widget, sessionResource, agentUri);
+    }
+    async _applyMode(widget, sessionResource, agentUri) {
+        const modes = widget.input.currentChatModesObs.get();
+        await modes.waitForPendingUpdates();
+        if (widget.viewModel?.sessionResource.toString() !== ( sessionResource.toString())) {
+            return;
+        }
+        const modeId = agentUri ?? ChatMode.Agent.id;
+        const mode = this._findMode(modes, modeId);
+        if (!mode || widget.input.currentModeObs.get().id === mode.id) {
+            return;
+        }
+        this._updatingWidgets.add(widget);
+        try {
+            widget.input.setChatMode(mode.id, false);
+        } finally {
+            this._updatingWidgets.delete(widget);
+        }
+    }
+    _findMode(modes, modeId) {
+        return modes.findModeById(modeId) ?? modes.custom.find(mode => {
+            const uri = mode.uri?.get();
+            return uri && ( fromAgentHostUri(uri).toString()) === modeId;
+        });
+    }
+    _agentUriFromMode(mode) {
+        if (mode.kind !== ChatModeKind.Agent || mode.id === ChatMode.Agent.id || mode.isBuiltin) {
+            return undefined;
+        }
+        const uri = mode.uri?.get();
+        return uri ? ( fromAgentHostUri(uri).toString()) : ( ( URI.parse(mode.id)).toString());
+    }
+    _storeSelectedAgent(sessionResource, agentUri) {
+        const key = agentHostAgentPickerStorageKey(sessionResource.scheme);
+        if (agentUri) {
+            this._storageService.store(key, agentUri, StorageScope.PROFILE, StorageTarget.MACHINE);
+        } else {
+            this._storageService.remove(key, StorageScope.PROFILE);
+        }
+    }
+    _readSessionState(backendSession) {
+        const value = this._agentHostService.getSubscriptionUnmanaged(StateComponents.Session, backendSession)?.value;
+        return value && !(value instanceof Error) ? value : undefined;
+    }
+    _resolveBackendSession(sessionResource) {
+        const provisionalSession = this._provisionalSessionService.get(sessionResource);
+        if (provisionalSession) {
+            return provisionalSession;
+        }
+        if (!sessionResource.scheme.startsWith(AGENT_HOST_SESSION_SCHEME_PREFIX)) {
+            return undefined;
+        }
+        const provider = sessionResource.scheme.substring(AGENT_HOST_SESSION_SCHEME_PREFIX.length);
+        return provider ? AgentSession.uri(provider, sessionResource.path.substring(1)) : undefined;
+    }
+};
+AgentHostModeSynchronizer = ( __decorate([( __param(0, IChatWidgetService)), ( __param(1, IAgentHostService)), ( __param(2, IAgentHostUntitledProvisionalSessionService)), ( __param(3, IStorageService)), ( __param(4, IWorkbenchEnvironmentService))], AgentHostModeSynchronizer));
+registerWorkbenchContribution2(
+    AgentHostModeSynchronizer.ID,
+    AgentHostModeSynchronizer,
+    WorkbenchPhase.Eventually
+);

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostPermissionUiContribution.d.ts

@@ -1,10 +1,10 @@
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { IAgentHostPermissionService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostPermissionService.service";
+import { IAgentHostResourceService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostResourceService.service";
 import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
 import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
 import { IChatInputNotificationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService.service";
 /**
- * Bridges {@link IAgentHostPermissionService} to the chat input notification
+ * Bridges {@link IAgentHostResourceService} to the chat input notification
  * banner. While there are pending permission requests, the oldest one is
  * shown above the chat input with three actions:
  *
@@ -21,7 +21,7 @@ export declare class AgentHostPermissionUiContribution extends Disposable implem
     /** Stable id used in {@link IChatInputNotification} so updates replace in place. */
     private static readonly NOTIFICATION_ID;
     private _lastRequestId;
-    constructor(_permissionService: IAgentHostPermissionService, _chatInputNotificationService: IChatInputNotificationService, _labelService: ILabelService);
+    constructor(_permissionService: IAgentHostResourceService, _chatInputNotificationService: IChatInputNotificationService, _labelService: ILabelService);
     private _render;
     private _buildNotification;
     private _resolveHostName;

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostPermissionUiContribution.js

@@ -5,8 +5,8 @@ import { escapeMarkdownSyntaxTokens, MarkdownString } from '@codingame/monaco-vs
 import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { AgentHostPermissionMode } from '../../../../../../platform/agentHost/common/agentHostPermissionService.js';
-import { IAgentHostPermissionService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostPermissionService.service';
+import { AgentHostPermissionMode } from '../../../../../../platform/agentHost/common/agentHostResourceService.js';
+import { IAgentHostResourceService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostResourceService.service';
 import { agentHostAuthority, AGENT_HOST_SCHEME } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
 import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
 import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
@@ -19,13 +19,13 @@ const ALLOW_COMMAND = "_agentHost.permission.allow";
 const ALLOW_ALWAYS_COMMAND = "_agentHost.permission.allowAlways";
 const DENY_COMMAND = "_agentHost.permission.deny";
 CommandsRegistry.registerCommand(ALLOW_COMMAND, (accessor, requestId) => {
-    accessor.get(IAgentHostPermissionService).findPending(requestId)?.allow();
+    accessor.get(IAgentHostResourceService).findPending(requestId)?.allow();
 });
 CommandsRegistry.registerCommand(ALLOW_ALWAYS_COMMAND, (accessor, requestId) => {
-    accessor.get(IAgentHostPermissionService).findPending(requestId)?.allowAlways();
+    accessor.get(IAgentHostResourceService).findPending(requestId)?.allowAlways();
 });
 CommandsRegistry.registerCommand(DENY_COMMAND, (accessor, requestId) => {
-    accessor.get(IAgentHostPermissionService).findPending(requestId)?.deny();
+    accessor.get(IAgentHostResourceService).findPending(requestId)?.deny();
 });
 let AgentHostPermissionUiContribution = class AgentHostPermissionUiContribution extends Disposable {
     static {
@@ -64,23 +64,23 @@ let AgentHostPermissionUiContribution = class AgentHostPermissionUiContribution
         const path = request.uri.scheme === Schemas.file ? request.uri.fsPath : ( request.uri.toString());
         const fence = "`".repeat((path.match(/`+/g)?.reduce((m, s) => Math.max(m, s.length), 0) ?? 0) + 1);
         const codePath = `${fence}${path}${fence}`;
-        const message = ( new MarkdownString(request.mode === AgentHostPermissionMode.Write ? ( localize(5213, "Remote agent host \"{0}\" wants to write {1}", hostName, codePath)) : ( localize(5214, "Remote agent host \"{0}\" wants to read {1}", hostName, codePath))));
-        const description = totalPending > 1 ? totalPending === 2 ? ( localize(5215, "+1 more request waiting")) : ( localize(5216, "+{0} more requests waiting", totalPending - 1)) : undefined;
+        const message = ( new MarkdownString(request.mode === AgentHostPermissionMode.Write ? ( localize(5279, "Remote agent host \"{0}\" wants to write {1}", hostName, codePath)) : ( localize(5280, "Remote agent host \"{0}\" wants to read {1}", hostName, codePath))));
+        const description = totalPending > 1 ? totalPending === 2 ? ( localize(5281, "+1 more request waiting")) : ( localize(5282, "+{0} more requests waiting", totalPending - 1)) : undefined;
         return {
             id: AgentHostPermissionUiContribution_1.NOTIFICATION_ID,
             severity: ChatInputNotificationSeverity.Warning,
             message,
             description,
             actions: [{
-                label: ( localize(5217, "Deny")),
+                label: ( localize(5283, "Deny")),
                 commandId: DENY_COMMAND,
                 commandArgs: [request.id]
             }, {
-                label: ( localize(5218, "Allow")),
+                label: ( localize(5284, "Allow")),
                 commandId: ALLOW_COMMAND,
                 commandArgs: [request.id]
             }, {
-                label: ( localize(5219, "Always Allow")),
+                label: ( localize(5285, "Always Allow")),
                 commandId: ALLOW_ALWAYS_COMMAND,
                 commandArgs: [request.id]
             }],
@@ -94,6 +94,6 @@ let AgentHostPermissionUiContribution = class AgentHostPermissionUiContribution
         return label && label !== authority ? label : address;
     }
 };
-AgentHostPermissionUiContribution = AgentHostPermissionUiContribution_1 = ( __decorate([( __param(0, IAgentHostPermissionService)), ( __param(1, IChatInputNotificationService)), ( __param(2, ILabelService))], AgentHostPermissionUiContribution));
+AgentHostPermissionUiContribution = AgentHostPermissionUiContribution_1 = ( __decorate([( __param(0, IAgentHostResourceService)), ( __param(1, IChatInputNotificationService)), ( __param(2, ILabelService))], AgentHostPermissionUiContribution));
 
 export { AgentHostPermissionUiContribution };

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostToolUtils.d.ts

@@ -0,0 +1,6 @@
+import type { ToolDefinition } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+import type { IToolData } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
+/**
+ * Converts an internal {@link IToolData} to a protocol {@link ToolDefinition}.
+ */
+export declare function toolDataToDefinition(tool: IToolData): ToolDefinition;

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostToolUtils.js

@@ -0,0 +1,14 @@
+
+
+function toolDataToDefinition(tool) {
+    return {
+        name: tool.toolReferenceName ?? tool.id,
+        title: tool.displayName,
+        description: tool.modelDescription,
+        inputSchema: tool.inputSchema?.type === 'object'
+            ? tool.inputSchema
+            : undefined,
+    };
+}
+
+export { toolDataToDefinition };

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostUntitledProvisionalSessionService.d.ts

@@ -15,6 +15,8 @@ export declare class AgentHostUntitledProvisionalSessionService extends Disposab
     readonly _serviceBrand: undefined;
     private readonly _entries;
     private readonly _pending;
+    private readonly _resolvedConfigs;
+    private readonly _resolvedConfigRequestSeq;
     private readonly _rebound;
     private readonly _sequencer;
     private readonly _onDidChange;
@@ -32,6 +34,7 @@ export declare class AgentHostUntitledProvisionalSessionService extends Disposab
      */
     private _toBackendUri;
     getResolvedConfig(sessionResource: URI): ResolveSessionConfigResult | undefined;
+    refreshResolvedConfig(sessionResource: URI, provider: string, workingDirectory: URI | undefined, config: Record<string, unknown> | undefined): Promise<void>;
     applyConfigChange(sessionResource: URI, provider: string, workingDirectory: URI | undefined, partial: Record<string, unknown>): Promise<URI | undefined>;
     /**
      * Workbench-side initial config seed sent at `createSession` time so the

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostUntitledProvisionalSessionService.js

@@ -8,7 +8,7 @@ import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objec
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { IAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service';
 import { SessionConfigKey, KNOWN_AUTO_APPROVE_VALUES } from '@codingame/monaco-vscode-katex-common/vscode/vs/platform/agentHost/common/sessionConfigKeys';
-import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/actions';
+import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
@@ -32,6 +32,8 @@ let AgentHostUntitledProvisionalSessionService = class AgentHostUntitledProvisio
         this._environmentService = _environmentService;
         this._entries = ( new ResourceMap());
         this._pending = ( new ResourceMap());
+        this._resolvedConfigs = ( new ResourceMap());
+        this._resolvedConfigRequestSeq = ( new ResourceMap());
         this._rebound = ( new ResourceSet());
         this._sequencer = ( new SequencerByKey());
         this._onDidChange = this._register(( new Emitter()));
@@ -41,6 +43,8 @@ let AgentHostUntitledProvisionalSessionService = class AgentHostUntitledProvisio
                 if (( this._entries.has(sessionResource))) {
                     void this.disposeSession(sessionResource);
                 }
+                this._resolvedConfigs.delete(sessionResource);
+                this._resolvedConfigRequestSeq.delete(sessionResource);
                 this._rebound.delete(sessionResource);
             }
         }));
@@ -134,9 +138,12 @@ let AgentHostUntitledProvisionalSessionService = class AgentHostUntitledProvisio
             backendSession: created,
             config: {
                 ...config
-            }
+            },
+            resolvedConfig: oldEntry.resolvedConfig
         });
         this._entries.delete(oldSessionResource);
+        this._resolvedConfigs.delete(oldSessionResource);
+        this._resolvedConfigRequestSeq.delete(oldSessionResource);
         this._rebound.add(oldSessionResource);
         this._onDidChange.fire(newSessionResource);
         this._agentHostService.disposeSession(oldEntry.backendSession).catch(err => {
@@ -149,6 +156,8 @@ let AgentHostUntitledProvisionalSessionService = class AgentHostUntitledProvisio
     async disposeSession(sessionResource) {
         await this.waitForPending(sessionResource);
         const entry = this._entries.get(sessionResource);
+        this._resolvedConfigs.delete(sessionResource);
+        this._resolvedConfigRequestSeq.delete(sessionResource);
         if (!entry) {
             return;
         }
@@ -166,6 +175,8 @@ let AgentHostUntitledProvisionalSessionService = class AgentHostUntitledProvisio
         }
         this._entries.clear();
         this._pending.clear();
+        this._resolvedConfigs.clear();
+        this._resolvedConfigRequestSeq.clear();
         this._rebound.clear();
         super.dispose();
     }
@@ -177,7 +188,36 @@ let AgentHostUntitledProvisionalSessionService = class AgentHostUntitledProvisio
         }));
     }
     getResolvedConfig(sessionResource) {
-        return this._entries.get(sessionResource)?.resolvedConfig;
+        return this._entries.get(sessionResource)?.resolvedConfig ?? this._resolvedConfigs.get(sessionResource);
+    }
+    async refreshResolvedConfig(sessionResource, provider, workingDirectory, config) {
+        const seq = (this._resolvedConfigRequestSeq.get(sessionResource) ?? 0) + 1;
+        this._resolvedConfigRequestSeq.set(sessionResource, seq);
+        try {
+            const resolved = await this._agentHostService.resolveSessionConfig({
+                provider,
+                workingDirectory,
+                config
+            });
+            if (this._resolvedConfigRequestSeq.get(sessionResource) !== seq) {
+                return;
+            }
+            const entry = this._entries.get(sessionResource);
+            if (entry) {
+                entry.config = {
+                    ...entry.config,
+                    ...resolved.values
+                };
+                entry.resolvedConfig = resolved;
+            } else {
+                this._resolvedConfigs.set(sessionResource, resolved);
+            }
+            this._onDidChange.fire(sessionResource);
+        } catch (err) {
+            this._logService.warn(
+                `[AgentHostProvisional] schema re-resolve failed: ${err instanceof Error ? err.message : String(err)}`
+            );
+        }
     }
     async applyConfigChange(sessionResource, provider, workingDirectory, partial) {
         const preExisting = this._entries.get(sessionResource);
@@ -203,9 +243,8 @@ let AgentHostUntitledProvisionalSessionService = class AgentHostUntitledProvisio
                 Object.assign(entry.config, partial);
             }
         }
-        this._agentHostService.dispatch({
+        this._agentHostService.dispatch(( backend.toString()), {
             type: ActionType.SessionConfigChanged,
-            session: ( backend.toString()),
             config: partial
         });
         return this._sequencer.queue(( sessionResource.toString()), async () => {

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/syncedCustomizationBundler.d.ts

@@ -0,0 +1,60 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { PromptsType } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
+import { type ClientPluginCustomization } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+import { SYNCED_CUSTOMIZATION_SCHEME } from "../../../../../services/agentHost/common/agentHostFileSystemService.js";
+import { IAgentHostFileSystemService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/agentHost/common/agentHostFileSystemService.service";
+export { SYNCED_CUSTOMIZATION_SCHEME };
+interface ISyncableFile {
+    readonly uri: URI;
+    readonly type: PromptsType;
+}
+interface IBundleResult {
+    readonly ref: ClientPluginCustomization;
+}
+/**
+ * Bundles individual customization files into a synthetic Open Plugin
+ * backed by an in-memory filesystem.
+ *
+ * Each bundler instance is namespaced by its authority string so that
+ * multiple agents can coexist under the same scheme without conflicts.
+ * The plugin is mounted at `vscode-synced-customization:///{authority}/`
+ * and structured as:
+ *
+ * ```
+ * .plugin/plugin.json
+ * rules/          ← instruction files
+ * commands/       ← prompt files
+ * agents/         ← agent files
+ * skills/         ← skill files
+ * ```
+ *
+ * The bundler computes a content-based nonce so the agent host can
+ * skip re-loading when nothing has changed.
+ */
+export declare class SyncedCustomizationBundler extends Disposable {
+    private readonly _fileService;
+    private readonly _authority;
+    private _lastNonce;
+    constructor(authority: string, _fileService: IFileService, agentHostFileSystemService: IAgentHostFileSystemService);
+    /**
+     * Root URI of the virtual plugin directory for this bundler.
+     * The authority is encoded into the path (not the URI authority) because
+     * {@link InMemoryFileSystemProvider} only routes by path.
+     */
+    private get _rootUri();
+    /**
+     * Bundles the given files into the in-memory plugin filesystem.
+     *
+     * Overwrites any previous bundle content. Returns a {@link ClientPluginCustomization}
+     * pointing at the virtual plugin directory with a content-based nonce.
+     *
+     * @returns The bundle result, or `undefined` if no syncable files were provided.
+     */
+    bundle(files: readonly ISyncableFile[]): Promise<IBundleResult | undefined>;
+    /**
+     * Returns the last computed nonce, or `undefined` if no bundle has been created.
+     */
+    get lastNonce(): string | undefined;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/syncedCustomizationBundler.js

@@ -0,0 +1,103 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { basename, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { hash } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { PromptsType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { customizationId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-root/state';
+import { CustomizationType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/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 '../../../../../services/agentHost/common/agentHostFileSystemService.js';
+import { IAgentHostFileSystemService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/agentHost/common/agentHostFileSystemService.service';
+import { SYNCED_CUSTOMIZATION_SCHEME } from '../../../../../../platform/agentHost/common/agentHostFileSystemService.js';
+
+const DISPLAY_NAME = "VS Code Synced Data";
+const MANIFEST_CONTENT = JSON.stringify({
+    name: DISPLAY_NAME,
+    description: "Customization data synced from VS Code"
+}, null, "\t");
+function pluginDirForType(type) {
+    switch (type) {
+    case PromptsType.instructions:
+        return "rules";
+    case PromptsType.prompt:
+        return "commands";
+    case PromptsType.agent:
+        return "agents";
+    case PromptsType.skill:
+        return "skills";
+    case PromptsType.hook:
+        return undefined;
+    }
+}
+let SyncedCustomizationBundler = class SyncedCustomizationBundler extends Disposable {
+    constructor(authority, _fileService, agentHostFileSystemService) {
+        super();
+        this._fileService = _fileService;
+        this._authority = authority;
+        agentHostFileSystemService.ensureSyncedCustomizationProvider();
+    }
+    get _rootUri() {
+        return ( URI.from({
+            scheme: SYNCED_CUSTOMIZATION_SCHEME,
+            path: `/${this._authority}`
+        }));
+    }
+    async bundle(files) {
+        const syncable = files.filter(f => pluginDirForType(f.type) !== undefined);
+        if (syncable.length === 0) {
+            return undefined;
+        }
+        try {
+            await this._fileService.del(this._rootUri, {
+                recursive: true
+            });
+        } catch {}
+        const manifestUri = URI.joinPath(this._rootUri, ".plugin", "plugin.json");
+        await this._fileService.writeFile(manifestUri, VSBuffer.fromString(MANIFEST_CONTENT));
+        const hashParts = [];
+        for (const file of syncable) {
+            const dir = pluginDirForType(file.type);
+            const fileName = basename(file.uri);
+            let destUri;
+            let hashKey;
+            if (file.type === PromptsType.skill && fileName.toLowerCase() === "skill.md") {
+                const skillDirName = basename(dirname(file.uri));
+                destUri = URI.joinPath(this._rootUri, dir, skillDirName, fileName);
+                hashKey = `${dir}/${skillDirName}/${fileName}`;
+            } else {
+                destUri = URI.joinPath(this._rootUri, dir, fileName);
+                hashKey = `${dir}/${fileName}`;
+            }
+            const content = await this._fileService.readFile(file.uri);
+            await this._fileService.writeFile(destUri, content.value);
+            hashParts.push(`${hashKey}:${( content.value.toString())}`);
+        }
+        hashParts.sort();
+        const nonce = String(hash(hashParts.join("\n")));
+        this._lastNonce = nonce;
+        const rootUriString = ( this._rootUri.toString());
+        return {
+            ref: {
+                type: CustomizationType.Plugin,
+                id: customizationId(rootUriString),
+                uri: rootUriString,
+                name: DISPLAY_NAME,
+                enabled: true,
+                nonce
+            }
+        };
+    }
+    get lastNonce() {
+        return this._lastNonce;
+    }
+};
+SyncedCustomizationBundler = ( __decorate([( __param(1, IFileService)), ( __param(2, IAgentHostFileSystemService))], SyncedCustomizationBundler));
+
+export { SYNCED_CUSTOMIZATION_SCHEME, SyncedCustomizationBundler };

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentSessions.contribution.js

@@ -17,6 +17,7 @@ import { FocusAgentSessionsAction, PickAgentSessionAction, ArchiveAllAgentSessio
 import { AGENT_SESSIONS_QUICK_ACCESS_PREFIX, AgentSessionsQuickAccessProvider } from './agentSessionsQuickAccess.js';
 import { AgentHostPermissionUiContribution } from './agentHost/agentHostPermissionUiContribution.js';
 import '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostChatInputPicker.contribution';
+import './agentHost/agentHostModeSynchronizer.js';
 
 registerAction2(FocusAgentSessionsAction);
 registerAction2(PickAgentSessionAction);
@@ -48,7 +49,7 @@ registerAction2(SetAgentSessionsOrientationStackedAction);
 registerAction2(SetAgentSessionsOrientationSideBySideAction);
 MenuRegistry.appendMenuItem(MenuId.AgentSessionsToolbar, {
     submenu: MenuId.AgentSessionsViewerFilterSubMenu,
-    title: ( localize2(5227, "Filter Agent Sessions")),
+    title: ( localize2(5293, "Filter Agent Sessions")),
     group: "navigation",
     order: 3,
     icon: Codicon.filter
@@ -118,9 +119,9 @@ MenuRegistry.appendMenuItem(MenuId.ChatViewSessionTitleToolbar, {
     prefix: AGENT_SESSIONS_QUICK_ACCESS_PREFIX,
     contextKey: "inAgentSessionsPicker",
     when: ChatContextKeys.enabled,
-    placeholder: ( localize(5228, "Search agent sessions by name")),
+    placeholder: ( localize(5294, "Search agent sessions by name")),
     helpEntries: [{
-        description: ( localize(5229, "Show All Agent Sessions")),
+        description: ( localize(5295, "Show All Agent Sessions")),
         commandId: "workbench.action.chat.history"
     }]
 });