@codingame/monaco-vscode-chat-service-override 33.0.9 → 34.0.1

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

@@ -1,34 +1,200 @@
 
 import { decodeBase64, VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { dirname, basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/charCode';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/marshallingIds';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
-import { FileSystemProviderCapabilities, FilePermission, FileType, createFileSystemProviderError, FileSystemProviderErrorCode } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
-import { fromAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
-import { ContentEncoding } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands';
-import { AhpErrorCodes } from './state/protocol/errors.js';
+import { Disposable, MutableDisposable, toDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { FileChangeType, FileSystemProviderCapabilities, FilePermission, FileType, FileSystemProviderErrorCode, createFileSystemProviderError } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+import { fromAgentHostUri, toAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { ContentEncoding } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/commands';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/commands';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/commands';
+import { AhpErrorCodes } from './state/protocol/common/errors.js';
 import { ProtocolError } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionProtocol';
+import { ROOT_STATE_URI } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
 
+async function createRemoteWatchHandle(primitives, params) {
+    const {
+        channel
+    } = await primitives.createResourceWatch(params);
+    const channelUri = ( URI.parse(channel));
+    await primitives.subscribe(channelUri);
+    const onDidChangeEmitter = ( new Emitter());
+    const listener = primitives.onDidAction(envelope => {
+        if (envelope.channel !== channel || envelope.action.type !== "resourceWatch/changed") {
+            return;
+        }
+        const items = envelope.action.changes?.items ?? [];
+        if (items.length === 0) {
+            return;
+        }
+        onDidChangeEmitter.fire(( items.map(item => ({
+            resource: ( URI.parse(item.uri)),
+            type: item.type === "added" ? FileChangeType.ADDED : item.type === "deleted" ? FileChangeType.DELETED : FileChangeType.UPDATED
+        }))));
+    });
+    let disposed = false;
+    return {
+        onDidChange: onDidChangeEmitter.event,
+        dispose: () => {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            listener.dispose();
+            onDidChangeEmitter.dispose();
+            try {
+                primitives.unsubscribe(channelUri);
+            } catch {}
+        }
+    };
+}
 class AHPFileSystemProvider extends Disposable {
-    constructor() {
-        super(...arguments);
-        this.capabilities = FileSystemProviderCapabilities.PathCaseSensitive | FileSystemProviderCapabilities.FileReadWrite;
+    static {
+        this._DEFAULT_CONNECTION_GRACE_MS = 5000;
+    }
+    constructor(_connectionGraceMs = AHPFileSystemProvider._DEFAULT_CONNECTION_GRACE_MS) {
+        super();
+        this._connectionGraceMs = _connectionGraceMs;
+        this.capabilities = FileSystemProviderCapabilities.PathCaseSensitive | FileSystemProviderCapabilities.FileReadWrite | FileSystemProviderCapabilities.FileFolderCopy;
         this._onDidChangeCapabilities = this._register(( new Emitter()));
         this.onDidChangeCapabilities = this._onDidChangeCapabilities.event;
         this._onDidChangeFile = this._register(( new Emitter()));
         this.onDidChangeFile = this._onDidChangeFile.event;
-        this._authorityToConnection = ( new Map());
+        this._onDidWatchError = this._register(( new Emitter()));
+        this.onDidWatchError = this._onDidWatchError.event;
+        this._authorities = ( new Map());
+        this._onDidChangeConnection = this._register(( new Emitter()));
     }
     registerAuthority(authority, connection) {
-        this._authorityToConnection.set(authority, connection);
-        return toDisposable(() => this._authorityToConnection.delete(authority));
+        let entry = this._authorities.get(authority);
+        if (!entry) {
+            entry = {
+                connections: [connection],
+                expiry: ( new MutableDisposable())
+            };
+            this._authorities.set(authority, entry);
+        } else {
+            entry.expiry.clear();
+            entry.connections.push(connection);
+        }
+        const adopted = entry;
+        this._onDidChangeConnection.fire(authority);
+        return toDisposable(() => {
+            const idx = adopted.connections.indexOf(connection);
+            if (idx === -1) {
+                return;
+            }
+            const wasActive = idx === adopted.connections.length - 1;
+            adopted.connections.splice(idx, 1);
+            if (adopted.connections.length === 0) {
+                adopted.expiry.value = disposableTimeout(
+                    () => this._expireAuthority(authority, adopted),
+                    this._connectionGraceMs,
+                    this._store
+                );
+            }
+            if (wasActive) {
+                this._onDidChangeConnection.fire(authority);
+            }
+        });
     }
-    watch() {
-        return Disposable.None;
+    _expireAuthority(authority, entry) {
+        if (this._authorities.get(authority) !== entry || entry.connections.length > 0) {
+            return;
+        }
+        this._authorities.delete(authority);
+        entry.expiry.dispose();
+        this._onDidChangeConnection.fire(authority);
+    }
+    dispose() {
+        for (const entry of ( this._authorities.values())) {
+            entry.expiry.dispose();
+            entry.connections.length = 0;
+        }
+        this._authorities.clear();
+        super.dispose();
+    }
+    watch(resource, opts) {
+        const store = ( new DisposableStore());
+        const handleHolder = store.add(( new MutableDisposable()));
+        const authority = resource.authority;
+        const params = {
+            channel: ROOT_STATE_URI,
+            uri: ( this._decodeUri(resource).toString()),
+            recursive: opts.recursive,
+            ...(opts.excludes.length > 0 ? {
+                excludes: {
+                    items: [...opts.excludes]
+                }
+            } : {}),
+            ...(opts.includes && opts.includes.length > 0 ? {
+                includes: {
+                    items: ( opts.includes.map(p => typeof p === "string" ? p : p.pattern))
+                }
+            } : {})
+        };
+        let attached;
+        let attaching = false;
+        let pendingReattach = false;
+        const reattach = async () => {
+            if (store.isDisposed) {
+                return;
+            }
+            if (attaching) {
+                pendingReattach = true;
+                return;
+            }
+            const entry = this._authorities.get(authority);
+            const next = entry?.connections.at(-1);
+            if (next === attached) {
+                return;
+            }
+            handleHolder.clear();
+            attached = undefined;
+            const watchResource = next?.watchResource;
+            if (!next || !watchResource) {
+                return;
+            }
+            attaching = true;
+            const target = next;
+            try {
+                const handle = await watchResource.call(target, params);
+                if (store.isDisposed) {
+                    handle.dispose();
+                    return;
+                }
+                const current = this._authorities.get(authority);
+                if (!current || current.connections.at(-1) !== target) {
+                    handle.dispose();
+                    return;
+                }
+                const sub = handle.onDidChange(changes => this._onDidChangeFile.fire(( changes.map(c => ({
+                    resource: this._encodeUri(c.resource, resource.authority),
+                    type: c.type
+                })))));
+                handleHolder.value = toDisposable(() => {
+                    sub.dispose();
+                    handle.dispose();
+                });
+                attached = target;
+            } catch (err) {
+                this._onDidWatchError.fire(err instanceof Error ? err.message : String(err));
+            } finally {
+                attaching = false;
+                if (pendingReattach) {
+                    pendingReattach = false;
+                    void reattach();
+                }
+            }
+        };
+        store.add(this._onDidChangeConnection.event(a => {
+            if (a === authority) {
+                void reattach();
+            }
+        }));
+        void reattach();
+        return store;
     }
     async stat(resource) {
         const path = resource.path;
@@ -60,27 +226,29 @@ class AHPFileSystemProvider extends Disposable {
                 permissions: FilePermission.Readonly
             };
         }
-        const parentUri = dirname(resource);
-        const name = basename(resource);
-        const entries = await this._listDirectory(resource.authority, parentUri);
-        const entry = entries.find(e => e.name === name);
-        if (!entry) {
-            throw createFileSystemProviderError(`File not found: ${path}`, FileSystemProviderErrorCode.FileNotFound);
-        }
-        return {
-            type: entry.type === "directory" ? FileType.Directory : FileType.File,
-            mtime: 0,
-            ctime: 0,
-            size: 0,
-            permissions: FilePermission.Readonly
-        };
+        const connection = await this._getConnection(resource.authority);
+        try {
+            const resolved = await connection.resourceResolve({
+                channel: ROOT_STATE_URI,
+                uri: ( decoded.toString())
+            });
+            return {
+                type: resolved.type === "directory" ? FileType.Directory : resolved.type === "symlink" ? FileType.SymbolicLink : FileType.File,
+                mtime: resolved.mtime ? Date.parse(resolved.mtime) : 0,
+                ctime: resolved.ctime ? Date.parse(resolved.ctime) : 0,
+                size: resolved.size ?? 0,
+                permissions: FilePermission.Readonly
+            };
+        } catch (err) {
+            throw this._mapError(err, FileSystemProviderErrorCode.FileNotFound);
+        }
     }
     async readdir(resource) {
         const entries = await this._listDirectory(resource.authority, resource);
         return ( entries.map(e => [e.name, e.type === "directory" ? FileType.Directory : FileType.File]));
     }
     async readFile(resource) {
-        const connection = this._getConnection(resource.authority);
+        const connection = await this._getConnection(resource.authority);
         try {
             const originalUri = this._decodeUri(resource);
             const result = await connection.resourceRead(originalUri);
@@ -93,10 +261,11 @@ class AHPFileSystemProvider extends Disposable {
         }
     }
     async writeFile(resource, content, _opts) {
-        const connection = this._getConnection(resource.authority);
+        const connection = await this._getConnection(resource.authority);
         try {
             const originalUri = this._decodeUri(resource);
             await connection.resourceWrite({
+                channel: ROOT_STATE_URI,
                 uri: ( originalUri.toString()),
                 data: ( VSBuffer.wrap(content).toString()),
                 encoding: ContentEncoding.Utf8
@@ -105,17 +274,24 @@ class AHPFileSystemProvider extends Disposable {
             throw this._mapError(err, FileSystemProviderErrorCode.NoPermissions);
         }
     }
-    async mkdir() {
-        throw createFileSystemProviderError(
-            "mkdir not supported on remote filesystem",
-            FileSystemProviderErrorCode.NoPermissions
-        );
+    async mkdir(resource) {
+        const connection = await this._getConnection(resource.authority);
+        try {
+            const originalUri = this._decodeUri(resource);
+            await connection.resourceMkdir({
+                channel: ROOT_STATE_URI,
+                uri: ( originalUri.toString())
+            });
+        } catch (err) {
+            throw this._mapError(err, FileSystemProviderErrorCode.NoPermissions);
+        }
     }
     async delete(resource, opts) {
-        const connection = this._getConnection(resource.authority);
+        const connection = await this._getConnection(resource.authority);
         try {
             const originalUri = this._decodeUri(resource);
             await connection.resourceDelete({
+                channel: ROOT_STATE_URI,
                 uri: ( originalUri.toString()),
                 recursive: opts.recursive
             });
@@ -124,11 +300,27 @@ class AHPFileSystemProvider extends Disposable {
         }
     }
     async rename(from, to, opts) {
-        const connection = this._getConnection(from.authority);
+        const connection = await this._getConnection(from.authority);
         try {
             const originalFrom = this._decodeUri(from);
             const originalTo = this._decodeUri(to);
             await connection.resourceMove({
+                channel: ROOT_STATE_URI,
+                source: ( originalFrom.toString()),
+                destination: ( originalTo.toString()),
+                failIfExists: !opts.overwrite
+            });
+        } catch (err) {
+            throw this._mapError(err, FileSystemProviderErrorCode.NoPermissions);
+        }
+    }
+    async copy(from, to, opts) {
+        const connection = await this._getConnection(from.authority);
+        try {
+            const originalFrom = this._decodeUri(from);
+            const originalTo = this._decodeUri(to);
+            await connection.resourceCopy({
+                channel: ROOT_STATE_URI,
                 source: ( originalFrom.toString()),
                 destination: ( originalTo.toString()),
                 failIfExists: !opts.overwrite
@@ -138,7 +330,7 @@ class AHPFileSystemProvider extends Disposable {
         }
     }
     async requestResourceAccess(resource, opts) {
-        const connection = this._getConnection(resource.authority);
+        const connection = await this._getConnection(resource.authority);
         if (!connection.resourceRequest) {
             throw createFileSystemProviderError(
                 `Connection for ${resource.authority} does not support resourceRequest`,
@@ -148,6 +340,7 @@ class AHPFileSystemProvider extends Disposable {
         const originalUri = this._decodeUri(resource);
         try {
             await connection.resourceRequest({
+                channel: ROOT_STATE_URI,
                 uri: ( originalUri.toString()),
                 read: opts.read,
                 write: opts.write
@@ -157,14 +350,41 @@ class AHPFileSystemProvider extends Disposable {
         }
     }
     _getConnection(authority) {
-        const connection = this._authorityToConnection.get(authority);
-        if (!connection) {
-            throw createFileSystemProviderError(
+        const entry = this._authorities.get(authority);
+        if (!entry) {
+            return Promise.reject(createFileSystemProviderError(
                 `No connection for authority: ${authority}`,
                 FileSystemProviderErrorCode.Unavailable
-            );
+            ));
+        }
+        const active = entry.connections.at(-1);
+        if (active) {
+            return Promise.resolve(active);
         }
-        return connection;
+        return ( new Promise((resolve, reject) => {
+            const settle = () => {
+                const current = this._authorities.get(authority);
+                if (!current) {
+                    sub.dispose();
+                    reject(createFileSystemProviderError(
+                        `No connection for authority: ${authority}`,
+                        FileSystemProviderErrorCode.Unavailable
+                    ));
+                    return;
+                }
+                const c = current.connections.at(-1);
+                if (c) {
+                    sub.dispose();
+                    resolve(c);
+                }
+            };
+            const sub = this._onDidChangeConnection.event(a => {
+                if (a === authority) {
+                    settle();
+                }
+            });
+            settle();
+        }));
     }
     _mapError(err, defaultCode) {
         if (err instanceof ProtocolError && err.code === AhpErrorCodes.PermissionDenied) {
@@ -173,7 +393,7 @@ class AHPFileSystemProvider extends Disposable {
         return createFileSystemProviderError(err instanceof Error ? err.message : String(err), defaultCode);
     }
     async _listDirectory(authority, resource) {
-        const connection = this._getConnection(authority);
+        const connection = await this._getConnection(authority);
         try {
             const originalUri = this._decodeUri(resource);
             const result = await connection.resourceList(originalUri);
@@ -187,6 +407,9 @@ class AgentHostFileSystemProvider extends AHPFileSystemProvider {
     _decodeUri(resource) {
         return fromAgentHostUri(resource);
     }
+    _encodeUri(resource, authority) {
+        return toAgentHostUri(resource, authority);
+    }
 }
 
-export { AHPFileSystemProvider, AgentHostFileSystemProvider };
+export { AHPFileSystemProvider, AgentHostFileSystemProvider, createRemoteWatchHandle };

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

@@ -7,12 +7,12 @@ import '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import './agentHostFileSystemProvider.js';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/charCode';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/marshallingIds';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands';
 
 const SYNCED_CUSTOMIZATION_SCHEME = "vscode-synced-customization";
 

package/vscode/src/vs/platform/agentHost/common/{agentHostPermissionService.d.ts → agentHostResourceService.d.ts}

@@ -1,4 +1,12 @@
+import { VSBuffer } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buffer";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { DirectoryEntry, ResourceRequestParams } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands";
+/**
+ * Stable sentinel address used for the in-process local agent host. Keyed
+ * persisted grants in user settings live under this name so that "Always
+ * allow" survives window reloads.
+ */
+export declare const LOCAL_AGENT_HOST_ADDRESS = "local";
 /** Configuration key for persisted per-host filesystem grants. */
 export declare const AgentHostLocalFilePermissionsSettingId = "chat.agentHost.localFilePermissions";
 /** Persisted access mode for a granted URI. */
@@ -35,3 +43,21 @@ export interface IPendingResourceRequest {
     /** Reject this request. */
     deny(): void;
 }
+/**
+ * Thrown by gated FS operations on {@link IAgentHostResourceService} when
+ * the calling address lacks the required permission. Carries the
+ * {@link ResourceRequestParams} that, if approved, would unlock the
+ * operation, so wire adapters can echo it back to the agent host inside a
+ * `PermissionDenied` frame and let the host run the standard
+ * `resourceRequest` → retry loop.
+ */
+export declare class AgentHostResourcePermissionError extends Error {
+    readonly request: ResourceRequestParams | undefined;
+    constructor(request: ResourceRequestParams | undefined);
+}
+export interface IResourceReadResult {
+    readonly bytes: VSBuffer;
+}
+export interface IResourceListResult {
+    readonly entries: readonly DirectoryEntry[];
+}

package/vscode/src/vs/platform/agentHost/common/{agentHostPermissionService.js → agentHostResourceService.js}

@@ -1,5 +1,6 @@
 
 
+const LOCAL_AGENT_HOST_ADDRESS = 'local';
 const AgentHostLocalFilePermissionsSettingId = 'chat.agentHost.localFilePermissions';
 var AgentHostAccessMode;
 (function (AgentHostAccessMode) {
@@ -11,5 +12,14 @@ var AgentHostPermissionMode;
     AgentHostPermissionMode["Read"] = "read";
     AgentHostPermissionMode["Write"] = "write";
 })(AgentHostPermissionMode || (AgentHostPermissionMode = {}));
+class AgentHostResourcePermissionError extends Error {
+    constructor(request) {
+        super(request
+            ? `Access to ${request.uri} is not granted.`
+            : 'Access to the requested resource is not granted.');
+        this.request = request;
+        this.name = 'AgentHostResourcePermissionError';
+    }
+}
 
-export { AgentHostAccessMode, AgentHostLocalFilePermissionsSettingId, AgentHostPermissionMode };
+export { AgentHostAccessMode, AgentHostLocalFilePermissionsSettingId, AgentHostPermissionMode, AgentHostResourcePermissionError, LOCAL_AGENT_HOST_ADDRESS };

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

@@ -126,9 +126,22 @@ export declare const platformSessionSchema: ISchema<{
  *   rules.
  */
 export declare const AgentHostTelemetryLevelConfigKey = "telemetryLevel";
+/**
+ * Root config key forwarded from the renderer when VS Code's
+ * `chat.sessionSync.enabled` setting changes. Controls the `remote` flag
+ * passed to the copilot-sdk `CopilotClientOptions`.
+ */
+export declare const AgentHostSessionSyncEnabledConfigKey = "sessionSyncEnabled";
+/**
+ * The VS Code setting ID for session sync. Defined here so the platform
+ * layer (renderer-side forwarding) can reference it without importing from
+ * `workbench/contrib/chat`.
+ */
+export declare const SESSION_SYNC_ENABLED_SETTING_ID = "chat.sessionSync.enabled";
 export declare function telemetryLevelToAgentHostConfigValue(telemetryLevel: TelemetryLevel): TelemetryConfiguration;
 export declare function agentHostConfigValueToTelemetryLevel(value: unknown): TelemetryLevel | undefined;
 export declare const platformRootSchema: ISchema<{
     permissions: ISchemaProperty<IPermissionsValue>;
     telemetryLevel: ISchemaProperty<TelemetryConfiguration>;
+    sessionSyncEnabled: ISchemaProperty<boolean>;
 }>;

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

@@ -3,7 +3,7 @@ import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { TelemetryLevel, TelemetryConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry';
 import { SessionConfigKey } from '@codingame/monaco-vscode-katex-common/vscode/vs/platform/agentHost/common/sessionConfigKeys';
 import { ProtocolError } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionProtocol';
-import { JsonRpcErrorCodes } from './state/protocol/errors.js';
+import { JsonRpcErrorCodes } from './state/protocol/common/errors.js';
 
 function schemaProperty(protocol) {
     const assertFn = buildAssert(protocol);
@@ -173,26 +173,26 @@ function safeStringify(value) {
 }
 const permissionsProperty = schemaProperty({
     type: "object",
-    title: ( localize(1820, "Permissions")),
+    title: ( localize(1824, "Permissions")),
     description: ( localize(
-        1821,
+        1825,
         "Per-tool session permissions. Updated automatically when approving a tool \"in this Session\"."
     )),
     properties: {
         allow: {
             type: "array",
-            title: ( localize(1822, "Allowed tools")),
+            title: ( localize(1826, "Allowed tools")),
             items: {
                 type: "string",
-                title: ( localize(1823, "Tool name"))
+                title: ( localize(1827, "Tool name"))
             }
         },
         deny: {
             type: "array",
-            title: ( localize(1824, "Denied tools")),
+            title: ( localize(1828, "Denied tools")),
             items: {
                 type: "string",
-                title: ( localize(1823, "Tool name"))
+                title: ( localize(1827, "Tool name"))
             }
         }
     },
@@ -205,27 +205,29 @@ const permissionsProperty = schemaProperty({
 createSchema({
     [SessionConfigKey.AutoApprove]: schemaProperty({
         type: "string",
-        title: ( localize(1825, "Approvals")),
-        description: ( localize(1826, "Tool approval behavior for this session")),
+        title: ( localize(1829, "Approvals")),
+        description: ( localize(1830, "Tool approval behavior for this session")),
         enum: ["default", "autoApprove", "autopilot"],
-        enumLabels: [( localize(1827, "Default Approvals")), ( localize(1828, "Bypass Approvals")), ( localize(1829, "Autopilot (Preview)"))],
-        enumDescriptions: [( localize(1830, "Copilot uses your configured settings")), ( localize(1831, "All tool calls are auto-approved")), ( localize(1832, "Autonomously iterates from start to finish"))],
+        enumLabels: [( localize(1831, "Default Approvals")), ( localize(1832, "Bypass Approvals")), ( localize(1833, "Autopilot (Preview)"))],
+        enumDescriptions: [( localize(1834, "Copilot uses your configured settings")), ( localize(1835, "All tool calls are auto-approved")), ( localize(1836, "Autonomously iterates from start to finish"))],
         default: "default",
         sessionMutable: true
     }),
     [SessionConfigKey.Permissions]: permissionsProperty,
     [SessionConfigKey.Mode]: schemaProperty({
         type: "string",
-        title: ( localize(1833, "Agent Mode")),
-        description: ( localize(1834, "How the agent should approach this turn")),
+        title: ( localize(1837, "Agent Mode")),
+        description: ( localize(1838, "How the agent should approach this turn")),
         enum: ["interactive", "plan"],
-        enumLabels: [( localize(1835, "Interactive")), ( localize(1836, "Plan"))],
-        enumDescriptions: [( localize(1837, "Ask for input and approval for each action")), ( localize(1838, "Generate a plan first, then choose how to execute it"))],
+        enumLabels: [( localize(1839, "Interactive")), ( localize(1840, "Plan"))],
+        enumDescriptions: [( localize(1841, "Ask for input and approval for each action")), ( localize(1842, "Generate a plan first, then choose how to execute it"))],
         default: "interactive",
         sessionMutable: true
     })
 });
 const AgentHostTelemetryLevelConfigKey = "telemetryLevel";
+const AgentHostSessionSyncEnabledConfigKey = "sessionSyncEnabled";
+const SESSION_SYNC_ENABLED_SETTING_ID = "chat.sessionSync.enabled";
 function telemetryLevelToAgentHostConfigValue(telemetryLevel) {
     switch (telemetryLevel) {
     case TelemetryLevel.NONE:
@@ -242,8 +244,8 @@ createSchema({
     [SessionConfigKey.Permissions]: permissionsProperty,
     [AgentHostTelemetryLevelConfigKey]: schemaProperty({
         type: "string",
-        title: ( localize(1839, "Telemetry Level")),
-        description: ( localize(1840, "Most restrictive telemetry level requested by connected clients.")),
+        title: ( localize(1843, "Telemetry Level")),
+        description: ( localize(1844, "Most restrictive telemetry level requested by connected clients.")),
         enum: [
             TelemetryConfiguration.ON,
             TelemetryConfiguration.ERROR,
@@ -251,7 +253,13 @@ createSchema({
             TelemetryConfiguration.OFF
         ],
         default: TelemetryConfiguration.ON
+    }),
+    [AgentHostSessionSyncEnabledConfigKey]: schemaProperty({
+        type: "boolean",
+        title: ( localize(1845, "Session Sync")),
+        description: ( localize(1846, "Whether remote session sync is enabled for the copilot-sdk CLI.")),
+        default: false
     })
 });
 
-export { AgentHostTelemetryLevelConfigKey, createSchema, schemaProperty, telemetryLevelToAgentHostConfigValue };
+export { AgentHostSessionSyncEnabledConfigKey, AgentHostTelemetryLevelConfigKey, SESSION_SYNC_ENABLED_SETTING_ID, createSchema, schemaProperty, telemetryLevelToAgentHostConfigValue };

package/vscode/src/vs/platform/agentHost/common/agentHostStarter.config.contribution.d.ts

@@ -0,0 +1 @@
+export {};