@codingame/monaco-vscode-chat-service-override 37.1.0 → 37.3.0

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/agentSessionSettings.contribution.d.ts

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

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/agentSessionSettings.contribution.js

@@ -0,0 +1,70 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { registerAction2, Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { SessionProviderIdContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { SessionItemContextMenuId } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/views/sessionsList';
+import { AgentSessionSettingsSchemaRegistrar, AgentSessionSettingsFileSystemProvider, AGENT_SESSION_SETTINGS_SCHEME, agentSessionSettingsUri } from './agentSessionSettingsFileSystemProvider.js';
+import { ANY_AGENT_HOST_PROVIDER_RE } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+
+let AgentSessionSettingsContribution = class AgentSessionSettingsContribution extends Disposable {
+    static {
+        this.ID = "sessions.contrib.agentSessionSettingsContribution";
+    }
+    constructor(fileService, instantiationService, labelService) {
+        super();
+        const schemaRegistrar = this._register(instantiationService.createInstance(AgentSessionSettingsSchemaRegistrar));
+        const provider = this._register(
+            instantiationService.createInstance(AgentSessionSettingsFileSystemProvider, schemaRegistrar)
+        );
+        this._register(fileService.registerProvider(AGENT_SESSION_SETTINGS_SCHEME, provider));
+        this._register(labelService.registerFormatter({
+            scheme: AGENT_SESSION_SETTINGS_SCHEME,
+            formatting: {
+                label: ( localize(4177, "Session Settings")),
+                separator: "/"
+            }
+        }));
+    }
+};
+AgentSessionSettingsContribution = ( __decorate([( __param(0, IFileService)), ( __param(1, IInstantiationService)), ( __param(2, ILabelService))], AgentSessionSettingsContribution));
+registerWorkbenchContribution2(
+    AgentSessionSettingsContribution.ID,
+    AgentSessionSettingsContribution,
+    WorkbenchPhase.AfterRestored
+);
+registerAction2(class OpenSessionSettingsAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessionsViewPane.openSessionSettings",
+            title: ( localize2(4178, "Open Session Settings")),
+            menu: [{
+                id: SessionItemContextMenuId,
+                group: "2_settings",
+                order: 1,
+                when: ( ContextKeyExpr.regex(SessionProviderIdContext.key, ANY_AGENT_HOST_PROVIDER_RE))
+            }]
+        });
+    }
+    async run(accessor, context) {
+        const session = Array.isArray(context) ? context[0] : context;
+        if (!session) {
+            return;
+        }
+        const editorService = accessor.get(IEditorService);
+        const resource = agentSessionSettingsUri(session);
+        await editorService.openEditor({
+            resource,
+            options: {
+                pinned: true
+            }
+        });
+    }
+});

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/agentSessionSettingsFileSystemProvider.d.ts

@@ -0,0 +1,69 @@
+import { IJSONSchema } from "@codingame/monaco-vscode-api/vscode/vs/base/common/jsonSchema";
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { ResolveSessionConfigResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands";
+import { IAgentHostSessionsProvider } from "@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+import { ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+import { AbstractMultiProviderAgentHostConfigSchemaRegistrar, AbstractSessionsAgentHostConfigFileSystemProvider, AgentHostConfigPropertyFilter, IAgentHostConfigLike, IAgentHostSettingsContext, IAgentHostSettingsLocale } from "./agentHostSettingsShared.js";
+/** Scheme for the synthetic agent-host session settings files. */
+export declare const AGENT_SESSION_SETTINGS_SCHEME = "agent-session-settings";
+/**
+ * Build the URI used to open the settings file for an agent-host session.
+ *
+ * URI shape: `agent-session-settings://{providerId}/{resourceScheme}{resourcePath}.jsonc`
+ *
+ * - `authority` = {@link ISession.providerId} (e.g. `local-agent-host`, `agenthost-<auth>`)
+ * - path encodes the session's resource scheme and path so the URI can be
+ *   parsed back into an {@link ISession.sessionId} via {@link toSessionId}
+ *   without having to look the session up on the provider.
+ */
+export declare function agentSessionSettingsUri(session: ISession): URI;
+interface ISessionSettingsContext extends IAgentHostSettingsContext {
+    /** Reconstructed {@link ISession.sessionId}. */
+    readonly sessionId: string;
+}
+/**
+ * Serialize the session-mutable config values for a session into a
+ * commented, pretty-printed JSON document.
+ */
+export declare function serializeSessionSettings(provider: IAgentHostSessionsProvider, sessionId: string): string;
+/**
+ * Build a JSON schema describing the editable session-mutable, non-readOnly
+ * properties of an agent-host session config. The filter mirrors the one
+ * used by {@link serializeSessionSettings} so validation matches the file
+ * contents produced by this provider.
+ */
+export declare function buildSessionSettingsJsonSchema(config: ResolveSessionConfigResult): IJSONSchema;
+/**
+ * Filesystem provider serving synthetic JSONC documents that represent the
+ * session-mutable config values of agent-host sessions.
+ */
+export declare class AgentSessionSettingsFileSystemProvider extends AbstractSessionsAgentHostConfigFileSystemProvider<ISessionSettingsContext> {
+    private readonly _schemaRegistrar;
+    protected readonly _schemeLabel = "agent-session-settings";
+    protected readonly _traceTag = "AgentSessionSettings";
+    protected readonly _locale: IAgentHostSettingsLocale;
+    constructor(_schemaRegistrar: AgentSessionSettingsSchemaRegistrar, sessionsProvidersService: ISessionsProvidersService, logService: ILogService);
+    protected _parseUri(resource: URI): ISessionSettingsContext | undefined;
+    protected _serialize(provider: IAgentHostSessionsProvider, ctx: ISessionSettingsContext): string;
+    protected _watchChanges(provider: IAgentHostSessionsProvider, ctx: ISessionSettingsContext, fire: () => void): IDisposable;
+    protected _ensureSchemaRegistered(provider: IAgentHostSessionsProvider, ctx: ISessionSettingsContext): void;
+    protected _hasConfig(provider: IAgentHostSessionsProvider, ctx: ISessionSettingsContext): boolean;
+    protected _replaceConfig(provider: IAgentHostSessionsProvider, ctx: ISessionSettingsContext, values: Record<string, unknown>): Promise<void>;
+    protected _describeForTrace(ctx: ISessionSettingsContext): string;
+}
+/**
+ * Keeps per-session JSON schemas registered so editors of the synthetic
+ * `agent-session-settings://…` files get completions, hover, and validation.
+ */
+export declare class AgentSessionSettingsSchemaRegistrar extends AbstractMultiProviderAgentHostConfigSchemaRegistrar<ISession> {
+    protected _propertyFilter(): AgentHostConfigPropertyFilter;
+    protected _settingsUri(session: ISession): string;
+    protected _schemaId(session: ISession): string;
+    protected _getConfig(session: ISession): IAgentHostConfigLike | undefined;
+    protected _targetsForProvider(provider: IAgentHostSessionsProvider): readonly ISession[];
+    protected _observeProvider(provider: IAgentHostSessionsProvider, onChanged: (session: ISession) => void, onRemoved: (session: ISession) => void): IDisposable;
+}
+export {};

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/agentSessionSettingsFileSystemProvider.js

@@ -0,0 +1,151 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { toSessionId } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { AbstractSessionsAgentHostConfigFileSystemProvider, AbstractMultiProviderAgentHostConfigSchemaRegistrar } from './agentHostSettingsShared.js';
+import { serializeAgentHostConfigDocument } from '../../../../../workbench/contrib/chat/browser/agentSessions/agentHost/agentHostConfigEditor.js';
+
+const AGENT_SESSION_SETTINGS_SCHEME = "agent-session-settings";
+function agentSessionSettingsUri(session) {
+    return ( URI.from({
+        scheme: AGENT_SESSION_SETTINGS_SCHEME,
+        authority: session.providerId,
+        path: `/${session.resource.scheme}${session.resource.path}.jsonc`
+    }));
+}
+function parseSessionSettingsUri(uri) {
+    if (uri.scheme !== AGENT_SESSION_SETTINGS_SCHEME) {
+        return undefined;
+    }
+    const providerId = uri.authority;
+    if (!providerId) {
+        return undefined;
+    }
+    const path = uri.path.startsWith("/") ? uri.path.substring(1) : uri.path;
+    const firstSlash = path.indexOf("/");
+    if (firstSlash <= 0) {
+        return undefined;
+    }
+    const resourceScheme = path.substring(0, firstSlash);
+    let rest = path.substring(firstSlash);
+    const lastDot = rest.lastIndexOf(".");
+    if (lastDot > 0) {
+        rest = rest.substring(0, lastDot);
+    }
+    if (!resourceScheme || rest === "/") {
+        return undefined;
+    }
+    const resource = ( URI.from({
+        scheme: resourceScheme,
+        path: rest
+    }));
+    return {
+        providerId,
+        sessionId: toSessionId(providerId, resource)
+    };
+}
+const sessionSettingsPropertyFilter = (_key, schema) => {
+    const s = schema;
+    return s.sessionMutable === true && s.readOnly !== true;
+};
+const sessionSettingsLocale = {
+    get header() {
+        return localize(4179, "Session settings for this agent host session.");
+    },
+    get saveHint() {
+        return localize(
+            4180,
+            "Edit values below and save to apply. Unknown or non-mutable properties are ignored."
+        );
+    },
+    get parseError() {
+        return localize(4181, "Failed to parse agent session settings as JSON.");
+    },
+    get notObject() {
+        return localize(4182, "Agent session settings must be a JSON object.");
+    }
+};
+function serializeSessionSettings(provider, sessionId) {
+    return serializeAgentHostConfigDocument(
+        provider.getSessionConfig(sessionId),
+        sessionSettingsPropertyFilter,
+        sessionSettingsLocale
+    );
+}
+let AgentSessionSettingsFileSystemProvider = class AgentSessionSettingsFileSystemProvider extends AbstractSessionsAgentHostConfigFileSystemProvider {
+    constructor(_schemaRegistrar, sessionsProvidersService, logService) {
+        super(sessionsProvidersService, logService);
+        this._schemaRegistrar = _schemaRegistrar;
+        this._schemeLabel = AGENT_SESSION_SETTINGS_SCHEME;
+        this._traceTag = "AgentSessionSettings";
+        this._locale = sessionSettingsLocale;
+    }
+    _parseUri(resource) {
+        return parseSessionSettingsUri(resource);
+    }
+    _serialize(provider, ctx) {
+        return serializeSessionSettings(provider, ctx.sessionId);
+    }
+    _watchChanges(provider, ctx, fire) {
+        return provider.onDidChangeSessionConfig(changedSessionId => {
+            if (changedSessionId === ctx.sessionId) {
+                fire();
+            }
+        });
+    }
+    _ensureSchemaRegistered(provider, ctx) {
+        const session = provider.getSessions().find(s => s.sessionId === ctx.sessionId);
+        if (session) {
+            this._schemaRegistrar.ensureRegistered(session);
+        }
+    }
+    _hasConfig(provider, ctx) {
+        return provider.getSessionConfig(ctx.sessionId) !== undefined;
+    }
+    _replaceConfig(provider, ctx, values) {
+        return provider.replaceSessionConfig(ctx.sessionId, values);
+    }
+    _describeForTrace(ctx) {
+        return `session ${ctx.sessionId}`;
+    }
+};
+AgentSessionSettingsFileSystemProvider = ( __decorate([( __param(1, ISessionsProvidersService)), ( __param(2, ILogService))], AgentSessionSettingsFileSystemProvider));
+class AgentSessionSettingsSchemaRegistrar extends AbstractMultiProviderAgentHostConfigSchemaRegistrar {
+    _propertyFilter() {
+        return sessionSettingsPropertyFilter;
+    }
+    _settingsUri(session) {
+        return ( agentSessionSettingsUri(session).toString());
+    }
+    _schemaId(session) {
+        return `vscode://schemas/agent-session-settings/${session.providerId}/${session.resource.scheme}/${session.resource.path}.jsonc`;
+    }
+    _getConfig(session) {
+        const provider = this._sessionsProvidersService.getProvider(session.providerId);
+        return provider?.getSessionConfig(session.sessionId);
+    }
+    _targetsForProvider(provider) {
+        return provider.getSessions();
+    }
+    _observeProvider(provider, onChanged, onRemoved) {
+        const store = ( new DisposableStore());
+        store.add(provider.onDidChangeSessionConfig(sessionId => {
+            const session = provider.getSessions().find(s => s.sessionId === sessionId);
+            if (session) {
+                onChanged(session);
+            }
+        }));
+        store.add(provider.onDidChangeSessions(e => {
+            for (const removed of e.removed) {
+                onRemoved(removed);
+            }
+        }));
+        return store;
+    }
+}
+
+export { AGENT_SESSION_SETTINGS_SCHEME, AgentSessionSettingsFileSystemProvider, AgentSessionSettingsSchemaRegistrar, agentSessionSettingsUri, serializeSessionSettings };

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/openAgentHostStateFileAction.d.ts

@@ -0,0 +1,17 @@
+import { Action2 } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+/**
+ * Sessions-app variant of "Open Agent Host State File". Uses the Agents
+ * window's `ISessionsService.activeSession` to find the active Agent Host
+ * session and chat, then defers to the shared workbench helper.
+ *
+ * The vscode workbench registers a separate action class
+ * (`OpenAgentHostStateFileAction` in
+ * `workbench/contrib/chat/browser/actions/openAgentHostStateFileAction.ts`)
+ * that resolves the session resource via `IChatWidgetService` instead.
+ */
+export declare class OpenAgentHostStateFileAction extends Action2 {
+    static readonly ID = "agentHost.openSessionEventsFile";
+    constructor();
+    run(accessor: ServicesAccessor): Promise<void>;
+}

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/openAgentHostStateFileAction.js

@@ -0,0 +1,39 @@
+
+import { localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Categories } from '@codingame/monaco-vscode-api/vscode/vs/platform/action/common/actionCommonCategories';
+import { Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { openAgentHostStateFile } from '../../../../../workbench/contrib/chat/browser/actions/openAgentHostStateFileAction.js';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { isAgentHostProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { IsAgentHostSession } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/agentHost/browser/agentHostSkillButtons';
+
+class OpenAgentHostStateFileAction extends Action2 {
+    static {
+        this.ID = "agentHost.openSessionEventsFile";
+    }
+    constructor() {
+        super({
+            id: OpenAgentHostStateFileAction.ID,
+            title: ( localize2(4195, "Open Agent Host State File")),
+            f1: true,
+            category: Categories.Developer,
+            precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, IsAgentHostSession))
+        });
+    }
+    async run(accessor) {
+        const sessionsService = accessor.get(ISessionsService);
+        const sessionsProvidersService = accessor.get(ISessionsProvidersService);
+        const activeSession = sessionsService.activeSession.get();
+        const provider = activeSession ? sessionsProvidersService.getProvider(activeSession.providerId) : undefined;
+        const activeChat = activeSession?.activeChat.get();
+        const chatTarget = activeChat?.resource.fragment ? {
+            backendResource: provider && isAgentHostProvider(provider) ? provider.getBackendChatResource(activeChat.resource) : undefined
+        } : undefined;
+        await openAgentHostStateFile(accessor, activeSession?.resource, chatTarget);
+    }
+}
+
+export { OpenAgentHostStateFileAction };

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/branchPicker.d.ts

@@ -0,0 +1,31 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IActiveSession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+/**
+ * Copilot-specific adapter that drives the shared BranchPicker with
+ * session state, including the optional isolation checkbox.
+ */
+export declare class BranchPicker extends Disposable {
+    private readonly _session;
+    private readonly _configurationService;
+    private readonly sessionsProvidersService;
+    private readonly telemetryService;
+    private readonly _picker;
+    private readonly _visibleKey;
+    private _hasGitRepo;
+    private _isolationOptionEnabled;
+    private _rendered;
+    constructor(_session: IObservable<IActiveSession | undefined>, _configurationService: IConfigurationService, contextKeyService: IContextKeyService, sessionsProvidersService: ISessionsProvidersService, telemetryService: ITelemetryService, instantiationService: IInstantiationService);
+    private _getSession;
+    private _getIsolationMode;
+    private _setModeOnSession;
+    private _applyIsolationToggle;
+    render(container: HTMLElement): void;
+    showPicker(): void;
+    private _update;
+}

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/branchPicker.js

@@ -0,0 +1,150 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { markOnboardingTarget } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/onboarding/browser/spotlight/onboardingTarget';
+import { reportNewChatPickerClosed } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/newChatPickerTelemetry';
+import { BranchPicker as BranchPicker$1 } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/branchPicker';
+import { SessionIsolationPickerVisibleContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { CopilotChatSessionsProvider } from './copilotChatSessionsProvider.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+let BranchPicker = class BranchPicker extends Disposable {
+    constructor(
+        _session,
+        _configurationService,
+        contextKeyService,
+        sessionsProvidersService,
+        telemetryService,
+        instantiationService
+    ) {
+        super();
+        this._session = _session;
+        this._configurationService = _configurationService;
+        this.sessionsProvidersService = sessionsProvidersService;
+        this.telemetryService = telemetryService;
+        this._hasGitRepo = false;
+        this._rendered = false;
+        this._visibleKey = SessionIsolationPickerVisibleContext.bindTo(contextKeyService);
+        this._register(toDisposable(() => this._visibleKey.reset()));
+        this._isolationOptionEnabled = this._configurationService.getValue("github.copilot.chat.cli.isolationOption.enabled") !== false;
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration("github.copilot.chat.cli.isolationOption.enabled")) {
+                this._isolationOptionEnabled = this._configurationService.getValue("github.copilot.chat.cli.isolationOption.enabled") !== false;
+                if (!this._isolationOptionEnabled) {
+                    this._setModeOnSession("worktree");
+                }
+                this._update();
+            }
+        }));
+        this._picker = this._register(instantiationService.createInstance(BranchPicker$1, {
+            user: "branchPicker",
+            onSelectBranch: branch => {
+                const session = this._getSession();
+                const selectedBranch = session?.branch.get();
+                reportNewChatPickerClosed(this.telemetryService, {
+                    id: "NewChatBranchPicker",
+                    name: "NewChatBranchPicker",
+                    optionIdBefore: selectedBranch,
+                    optionIdAfter: branch,
+                    optionLabelBefore: selectedBranch,
+                    optionLabelAfter: branch,
+                    isPII: true
+                });
+                session?.setBranch(branch);
+            },
+            isolation: {
+                label: ( localize(4196, "New Worktree")),
+                ariaLabel: ( localize(4197, "Worktree isolation")),
+                onToggle: checked => this._applyIsolationToggle(checked),
+                markTarget: element => markOnboardingTarget(element, "sessions.newSession.isolation")
+            }
+        }));
+        this._register(autorun(reader => {
+            const session = this._session.read(reader);
+            const provider = session ? this.sessionsProvidersService.getProvider(session.providerId) : undefined;
+            const providerSession = provider instanceof CopilotChatSessionsProvider ? provider.getSession(session.sessionId) : undefined;
+            if (providerSession) {
+                const isLoading = session?.loading.read(reader);
+                const gitRepo = providerSession.gitRepository;
+                const repoState = gitRepo?.state?.read?.(reader);
+                const hasHeadCommit = repoState ? !!repoState.HEAD?.commit : true;
+                this._hasGitRepo = !isLoading && !!gitRepo && hasHeadCommit;
+                providerSession.branches.read(reader);
+                providerSession.branch.read(reader);
+                providerSession.isolationMode.read(reader);
+            } else {
+                this._hasGitRepo = false;
+            }
+            this._update();
+        }));
+    }
+    _getSession() {
+        const session = this._session.get();
+        if (!session) {
+            return undefined;
+        }
+        const provider = this.sessionsProvidersService.getProvider(session.providerId);
+        return provider instanceof CopilotChatSessionsProvider ? provider.getSession(session.sessionId) : undefined;
+    }
+    _getIsolationMode() {
+        return this._getSession()?.isolationMode.get() ?? "worktree";
+    }
+    _setModeOnSession(mode) {
+        this._getSession()?.setIsolationMode(mode);
+    }
+    _applyIsolationToggle(checked) {
+        const before = this._getIsolationMode();
+        const after = checked ? "worktree" : "workspace";
+        reportNewChatPickerClosed(this.telemetryService, {
+            id: "NewChatIsolationPicker",
+            name: "NewChatIsolationPicker",
+            optionIdBefore: before,
+            optionIdAfter: after,
+            optionLabelBefore: undefined,
+            optionLabelAfter: undefined,
+            isPII: false
+        });
+        this._setModeOnSession(after);
+    }
+    render(container) {
+        this._rendered = true;
+        this._picker.render(container);
+        this._update();
+    }
+    showPicker() {
+        this._picker.showPicker();
+    }
+    _update() {
+        const session = this._getSession();
+        const branches = session?.branches.get() ?? [];
+        const selectedBranch = session?.branch.get();
+        const isLoading = session?.loading.get() ?? false;
+        const isWorkspace = session?.isolationMode.get() === "workspace";
+        const isolationState = !this._isolationOptionEnabled ? "hidden" : this._hasGitRepo ? "enabled" : "disabled";
+        this._picker.update({
+            label: selectedBranch ?? ( localize(4198, "Branch")),
+            branches: branches.map(branch => ({
+                name: branch,
+                selected: branch === selectedBranch
+            })),
+            status: isLoading ? "loading" : branches.length > 0 ? "ready" : "empty",
+            canOpen: !isLoading && !isWorkspace && branches.length > 0,
+            isolation: {
+                checked: this._getIsolationMode() === "worktree",
+                state: isolationState,
+                disabledReason: !this._hasGitRepo ? ( localize(4199, "Git repository required for worktree isolation")) : undefined
+            }
+        });
+        this._visibleKey.set(this._rendered && this._hasGitRepo && this._isolationOptionEnabled);
+    }
+};
+BranchPicker = ( __decorate([( __param(1, IConfigurationService)), ( __param(2, IContextKeyService)), ( __param(3, ISessionsProvidersService)), ( __param(4, ITelemetryService)), ( __param(5, IInstantiationService))], BranchPicker));
+
+export { BranchPicker };

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/copilotChatSessions.contribution.d.ts

@@ -0,0 +1 @@
+

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/copilotChatSessions.contribution.js

@@ -0,0 +1,42 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { COPILOT_MULTI_CHAT_SETTING, CopilotChatSessionsProvider } from './copilotChatSessionsProvider.js';
+import './copilotChatSessionsActions.js';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+
+( Registry.as(Extensions.Configuration)).registerConfiguration({
+    id: "sessions",
+    properties: {
+        [COPILOT_MULTI_CHAT_SETTING]: {
+            type: "boolean",
+            default: true,
+            tags: ["preview"],
+            description: ( localize(
+                4200,
+                "Whether to enable multiple chats within a single session in the Copilot Chat sessions provider."
+            ))
+        }
+    }
+});
+let DefaultSessionsProviderContribution = class DefaultSessionsProviderContribution extends Disposable {
+    static {
+        this.ID = "sessions.defaultSessionsProvider";
+    }
+    constructor(instantiationService, sessionsProvidersService) {
+        super();
+        const provider = this._register(instantiationService.createInstance(CopilotChatSessionsProvider));
+        this._register(sessionsProvidersService.registerProvider(provider));
+    }
+};
+DefaultSessionsProviderContribution = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, ISessionsProvidersService))], DefaultSessionsProviderContribution));
+registerWorkbenchContribution2(
+    DefaultSessionsProviderContribution.ID,
+    DefaultSessionsProviderContribution,
+    WorkbenchPhase.AfterRestored
+);

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/copilotChatSessionsActions.d.ts

@@ -0,0 +1,19 @@
+import { BaseActionViewItem } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems";
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+/**
+ * Wraps a standalone picker widget as a {@link BaseActionViewItem}
+ * so it can be rendered by a {@link MenuWorkbenchToolBar}.
+ *
+ * Exported so the web-only `CopilotPermissionPickerWebContribution`
+ * (in `mobilePermissionPicker.contribution.ts`) can reuse the same
+ * wrapper for its `MobilePermissionPicker` registration.
+ */
+export declare class PickerActionViewItem extends BaseActionViewItem {
+    private readonly picker;
+    constructor(picker: {
+        render(container: HTMLElement): void;
+        dispose(): void;
+    }, disposable?: IDisposable);
+    render(container: HTMLElement): void;
+    dispose(): void;
+}