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

package/vscode/src/vs/sessions/contrib/chat/browser/customizationsDebugLog.contribution.js

@@ -0,0 +1,173 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { ILoggerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { IAICustomizationWorkspaceService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService.service';
+import { PromptsStorage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
+import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
+import { PromptsType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/aiCustomization/aiCustomizationManagement';
+import { IMcpService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { AICustomizationManagementSection } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService';
+
+const PROMPT_SECTIONS = [{
+    section: AICustomizationManagementSection.Agents,
+    type: PromptsType.agent
+}, {
+    section: AICustomizationManagementSection.Skills,
+    type: PromptsType.skill
+}, {
+    section: AICustomizationManagementSection.Instructions,
+    type: PromptsType.instructions
+}, {
+    section: AICustomizationManagementSection.Hooks,
+    type: PromptsType.hook
+}];
+let CustomizationsDebugLogContribution = class CustomizationsDebugLogContribution extends Disposable {
+    static {
+        this.ID = "sessions.customizationsDebugLog";
+    }
+    constructor(
+        loggerService,
+        _promptsService,
+        _workspaceService,
+        _workspaceContextService,
+        _mcpService
+    ) {
+        super();
+        this._promptsService = _promptsService;
+        this._workspaceService = _workspaceService;
+        this._workspaceContextService = _workspaceContextService;
+        this._mcpService = _mcpService;
+        this._snapshotDirty = false;
+        this._logger = this._register(loggerService.createLogger("customizationsDebug", {
+            name: "Customizations Debug"
+        }));
+        this._register(this._promptsService.onDidChangeCustomAgents(() => this._logSnapshot()));
+        this._register(this._promptsService.onDidChangeSlashCommands(() => this._logSnapshot()));
+        this._register(
+            this._workspaceContextService.onDidChangeWorkspaceFolders(() => this._logSnapshot())
+        );
+        this._register(autorun(reader => {
+            this._workspaceService.activeProjectRoot.read(reader);
+            this._logSnapshot();
+        }));
+        this._register(autorun(reader => {
+            this._mcpService.servers.read(reader);
+            this._logSnapshot();
+        }));
+    }
+    _logSnapshot() {
+        if (this._pendingSnapshot) {
+            this._snapshotDirty = true;
+            return;
+        }
+        this._pendingSnapshot = this._doLogSnapshot().finally(() => {
+            this._pendingSnapshot = undefined;
+            if (this._snapshotDirty) {
+                this._snapshotDirty = false;
+                this._logSnapshot();
+            }
+        });
+    }
+    async _doLogSnapshot() {
+        const root = this._workspaceService.getActiveProjectRoot()?.fsPath ?? "(none)";
+        this._logger.info("");
+        this._logger.info("=== Customizations Snapshot ===");
+        this._logger.info(`  Root: ${root}`);
+        this._logger.info(`  Sections: ${this._workspaceService.managementSections.join(", ")}`);
+        this._logger.info("");
+        this._logger.info(
+            `  ${"Section".padEnd(16)} ${"Local".padStart(6)} ${"User".padStart(6)} ${"Ext".padStart(6)} ${"Total".padStart(7)}`
+        );
+        this._logger.info(
+            `  ${"--------".padEnd(16)} ${"-----".padStart(6)} ${"----".padStart(6)} ${"---".padStart(6)} ${"-----".padStart(7)}`
+        );
+        for (const {
+            section,
+            type
+        } of PROMPT_SECTIONS) {
+            await this._logSectionRow(section, type);
+        }
+        this._logger.info("");
+        for (const {
+            section,
+            type
+        } of PROMPT_SECTIONS) {
+            await this._logSectionDetails(section, type);
+        }
+        this._logMcpServers();
+    }
+    _logMcpServers() {
+        const servers = this._mcpService.servers.get();
+        this._logger.info(`  -- MCP Servers (${servers.length}) --`);
+        if (servers.length === 0) {
+            this._logger.info("     (none registered)");
+        }
+        for (const server of servers) {
+            const state = server.connectionState.get();
+            const stateStr = state?.state ?? "unknown";
+            this._logger.info(`     ${server.definition.label} [${stateStr}] id=${server.definition.id}`);
+        }
+        this._logger.info("");
+    }
+    async _logSectionRow(section, type) {
+        try {
+            const [localFiles, userFiles, extensionFiles] = await Promise.all([
+                this._promptsService.listPromptFilesForStorage(type, PromptsStorage.local, CancellationToken.None),
+                this._promptsService.listPromptFilesForStorage(type, PromptsStorage.user, CancellationToken.None),
+                this._promptsService.listPromptFilesForStorage(type, PromptsStorage.extension, CancellationToken.None)
+            ]);
+            const all = [...localFiles, ...userFiles, ...extensionFiles];
+            const local = all.filter(f => f.storage === PromptsStorage.local).length;
+            const user = all.filter(f => f.storage === PromptsStorage.user).length;
+            const ext = all.filter(f => f.storage === PromptsStorage.extension).length;
+            this._logger.info(
+                `  ${section.padEnd(16)} ${String(local).padStart(6)} ${String(user).padStart(6)} ${String(ext).padStart(6)} ${String(all.length).padStart(7)}`
+            );
+        } catch {
+            this._logger.info(`  ${section.padEnd(16)}  (error)`);
+        }
+    }
+    async _logSectionDetails(section, type) {
+        try {
+            const sourceFolders = await this._promptsService.getSourceFolders(type);
+            if (sourceFolders.length > 0) {
+                this._logger.info(`  -- ${section} --`);
+                this._logger.info(`     Search paths:`);
+                for (const sf of sourceFolders) {
+                    this._logger.info(`       [${sf.storage}] ${sf.uri.fsPath}`);
+                }
+            }
+            const [localFiles, userFiles, extensionFiles] = await Promise.all([
+                this._promptsService.listPromptFilesForStorage(type, PromptsStorage.local, CancellationToken.None),
+                this._promptsService.listPromptFilesForStorage(type, PromptsStorage.user, CancellationToken.None),
+                this._promptsService.listPromptFilesForStorage(type, PromptsStorage.extension, CancellationToken.None)
+            ]);
+            const all = [...localFiles, ...userFiles, ...extensionFiles];
+            if (all.length > 0) {
+                if (sourceFolders.length === 0) {
+                    this._logger.info(`  -- ${section} --`);
+                }
+                this._logger.info(`     Found ${all.length} item(s):`);
+                for (const f of all) {
+                    this._logger.info(`       [${f.storage}] ${f.uri.fsPath}`);
+                }
+            }
+            if (sourceFolders.length > 0 || all.length > 0) {
+                this._logger.info("");
+            }
+        } catch {}
+    }
+};
+CustomizationsDebugLogContribution = ( __decorate([( __param(0, ILoggerService)), ( __param(1, IPromptsService)), ( __param(2, IAICustomizationWorkspaceService)), ( __param(3, IWorkspaceContextService)), ( __param(4, IMcpService))], CustomizationsDebugLogContribution));
+registerWorkbenchContribution2(
+    CustomizationsDebugLogContribution.ID,
+    CustomizationsDebugLogContribution,
+    WorkbenchPhase.AfterRestored
+);

package/vscode/src/vs/sessions/contrib/chat/browser/media/runScriptAction.css

@@ -0,0 +1,186 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+.run-script-action-widget {
+	display: flex;
+	flex-direction: column;
+	gap: 12px;
+	padding: 16px;
+}
+
+.run-script-action-section {
+	display: flex;
+	flex-direction: column;
+	gap: 4px;
+}
+
+.run-script-action-label {
+	font-size: var(--vscode-fontSize-label1);
+	font-weight: var(--vscode-fontWeight-semiBold);
+}
+
+.run-script-action-input .monaco-inputbox {
+	width: 100%;
+}
+
+.run-script-action-option-row {
+	display: flex;
+	align-items: center;
+	min-height: 22px;
+	gap: 8px;
+}
+
+.run-script-action-option-text {
+	cursor: pointer;
+	-webkit-user-select: none;
+	user-select: none;
+}
+
+.run-script-action-section .monaco-custom-radio {
+	display: inline-flex;
+	width: fit-content;
+	max-width: 100%;
+	gap: 2px;
+	padding: 2px;
+	border: 1px solid var(--vscode-widget-border, rgba(255, 255, 255, 0.06));
+	border-radius: var(--vscode-cornerRadius-medium);
+	background-color: var(--vscode-input-background);
+}
+
+.run-script-action-section .monaco-custom-radio > .monaco-button {
+	width: fit-content;
+	min-width: 76px;
+	padding: 4px 8px;
+	border: var(--vscode-strokeThickness) solid transparent;
+	border-radius: var(--vscode-cornerRadius-small);
+	background: transparent;
+	color: var(--vscode-foreground);
+	font-size: var(--vscode-fontSize-label1);
+	font-weight: var(--vscode-fontWeight-semiBold);
+	line-height: 14px;
+	opacity: 0.9;
+	transition: background-color 120ms ease, border-color 120ms ease, color 120ms ease, opacity 120ms ease;
+}
+
+.run-script-action-section .monaco-custom-radio > .monaco-button:first-child,
+.run-script-action-section .monaco-custom-radio > .monaco-button:last-child {
+	border-radius: var(--vscode-cornerRadius-small);
+}
+
+.run-script-action-section .monaco-custom-radio > .monaco-button:not(.active):not(:last-child),
+.run-script-action-section .monaco-custom-radio > .monaco-button.previous-active {
+	border-right: var(--vscode-strokeThickness) solid transparent;
+	border-left: var(--vscode-strokeThickness) solid transparent;
+}
+
+.run-script-action-section .monaco-custom-radio > .monaco-button:hover:not(.active):not(.disabled) {
+	background-color: var(--vscode-list-hoverBackground);
+	border-color: rgba(255, 255, 255, 0.06);
+	opacity: 1;
+}
+
+.run-script-action-section .monaco-custom-radio > .monaco-button.active,
+.run-script-action-section .monaco-custom-radio > .monaco-button.active:hover {
+	background-color: var(--vscode-quickInputList-focusBackground);
+	color: var(--vscode-quickInputList-focusForeground);
+	border-color: var(--vscode-focusBorder, transparent);
+	opacity: 1;
+}
+
+.run-script-action-section .monaco-custom-radio > .monaco-button:focus {
+	outline-offset: 0 !important;
+}
+
+.run-script-action-section .monaco-custom-radio.run-script-action-radio-disabled {
+	opacity: 0.75;
+}
+
+.run-script-action-section .monaco-custom-radio.run-script-action-radio-disabled > .monaco-button,
+.run-script-action-section .monaco-custom-radio.run-script-action-radio-disabled > .monaco-button:hover:not(.active) {
+	background-color: transparent;
+	border-color: transparent;
+	color: var(--vscode-disabledForeground);
+	opacity: 1;
+	cursor: default;
+}
+
+.run-script-action-section .monaco-custom-radio.run-script-action-radio-disabled > .monaco-button.active,
+.run-script-action-section .monaco-custom-radio.run-script-action-radio-disabled > .monaco-button.active:hover {
+	background-color: var(--vscode-quickInputList-focusBackground);
+	color: var(--vscode-quickInputList-focusForeground);
+	border-color: var(--vscode-focusBorder, transparent);
+	opacity: 0.9;
+	cursor: default;
+}
+
+.run-script-action-section .monaco-custom-radio.run-script-action-radio-disabled > .monaco-button:focus,
+.run-script-action-section .monaco-custom-radio.run-script-action-radio-disabled > .monaco-button.active:focus {
+	outline: none !important;
+}
+
+.run-script-action-hint {
+	font-size: var(--vscode-fontSize-label1);
+	color: var(--vscode-descriptionForeground);
+}
+
+.run-script-action-buttons {
+	display: flex;
+	justify-content: flex-end;
+	gap: 8px;
+	padding-top: 4px;
+}
+
+.run-script-action-buttons .monaco-text-button {
+	width: fit-content;
+	min-height: 28px;
+	padding: 6px 12px;
+	border-radius: var(--vscode-cornerRadius-medium);
+}
+
+.agent-sessions-workbench.run-script-action-modal-visible .quick-input-widget .quick-input-titlebar {
+	gap: 8px;
+	height: 32px;
+	padding: 0 6px 0 0;
+	border-top-left-radius: var(--vscode-cornerRadius-large);
+	border-top-right-radius: var(--vscode-cornerRadius-large);
+	border-bottom: 1px solid var(--vscode-titleBar-border, var(--vscode-widget-border, transparent));
+	box-sizing: border-box;
+	background-color: var(--vscode-titleBar-activeBackground);
+}
+
+.agent-sessions-workbench.run-script-action-modal-visible .quick-input-widget .quick-input-right-action-bar {
+	margin-right: 0;
+}
+
+.agent-sessions-workbench.run-script-action-modal-visible .quick-input-widget .quick-input-title {
+	padding: 0;
+	text-align: left;
+	font-size: var(--vscode-fontSize-label1);
+	font-weight: var(--vscode-fontWeight-semiBold);
+	color: var(--vscode-titleBar-activeForeground);
+}
+
+.agent-sessions-workbench.run-script-action-modal-visible .quick-input-widget {
+	border-radius: var(--vscode-cornerRadius-large);
+	box-shadow: var(--vscode-shadow-xl);
+}
+
+.agent-sessions-workbench.run-script-action-modal-visible .quick-input-widget .quick-input-html-widget {
+	border-bottom-left-radius: var(--vscode-cornerRadius-large);
+	border-bottom-right-radius: var(--vscode-cornerRadius-large);
+	overflow: hidden;
+}
+
+.agent-sessions-workbench.run-script-action-modal-visible .quick-input-widget .quick-input-header,
+.agent-sessions-workbench.run-script-action-modal-visible .quick-input-widget .run-script-action-widget {
+	background-color: var(--vscode-editor-background);
+}
+
+.run-script-action-modal-backdrop {
+	position: fixed;
+	inset: 0;
+	background: rgba(0, 0, 0, 0.5);
+	z-index: 2549;
+}

package/vscode/src/vs/sessions/contrib/chat/browser/newSession.d.ts

@@ -0,0 +1,9 @@
+import { IChatSessionProviderOptionGroup, IChatSessionProviderOptionItem } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
+export type NewSessionChangeType = "repoUri" | "isolationMode" | "branch" | "options" | "disabled" | "agent";
+/**
+ * Represents a resolved option group with its current selected value.
+ */
+export interface ISessionOptionGroup {
+    readonly group: IChatSessionProviderOptionGroup;
+    readonly value: IChatSessionProviderOptionItem | undefined;
+}

package/vscode/src/vs/sessions/contrib/chat/browser/newSessionFolderQuickPickAction.d.ts

@@ -0,0 +1,12 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
+import { IQuickPickItem, IQuickPickSeparator } from "@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput";
+import { ISessionsRecentWorkspacesService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsRecentWorkspacesService.service";
+export interface IFolderQuickPickItem extends IQuickPickItem {
+    readonly folderUri?: URI;
+    /** The provider that previously resolved this folder, so re-picking it keeps the same provider association. */
+    readonly providerId?: string;
+    readonly browse?: boolean;
+}
+/** Builds the flat folder quick pick list: own recents, then VS Code recents (deduplicated), then Browse. */
+export declare function buildFolderQuickPickItems(recentWorkspacesService: ISessionsRecentWorkspacesService, labelService: ILabelService): (IFolderQuickPickItem | IQuickPickSeparator)[];

package/vscode/src/vs/sessions/contrib/chat/browser/newSessionFolderQuickPickAction.js

@@ -0,0 +1,104 @@
+
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { KeyMod, KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Action2, registerAction2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IFileDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { KeybindingWeight } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { IsSessionsWindowContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { CHAT_CATEGORY } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { ISessionsRecentWorkspacesService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsRecentWorkspacesService.service';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { INewSessionComposerService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/newSessionComposerService.service';
+
+function buildFolderQuickPickItems(recentWorkspacesService, labelService) {
+    const recents = recentWorkspacesService.getRecentWorkspaces();
+    const items = [];
+    if (recents.length > 0) {
+        items.push({
+            type: "separator",
+            label: ( localize(3732, "Recent"))
+        });
+        for (const {
+            workspace,
+            providerId
+        } of recents) {
+            const folderUri = workspace.folders[0]?.root;
+            if (!folderUri) {
+                continue;
+            }
+            items.push({
+                folderUri,
+                providerId,
+                label: `$(${workspace.icon.id}) ${workspace.label}`,
+                description: labelService.getUriLabel(folderUri, {
+                    relative: false
+                })
+            });
+        }
+        items.push({
+            type: "separator",
+            label: ""
+        });
+    }
+    items.push({
+        label: `$(${Codicon.folderOpened.id}) ${( localize(3733, "Browse..."))}`,
+        browse: true
+    });
+    return items;
+}
+class NewSessionPickFolderQuickPickAction extends Action2 {
+    constructor() {
+        super({
+            id: "workbench.action.sessions.newSession.pickFolderQuickPick",
+            title: ( localize2(3734, "New Session in Folder...")),
+            category: CHAT_CATEGORY,
+            f1: true,
+            keybinding: {
+                weight: KeybindingWeight.SessionsContrib,
+                when: IsSessionsWindowContext,
+                primary: KeyMod.CtrlCmd | KeyCode.KeyO
+            }
+        });
+    }
+    async run(accessor) {
+        const quickInputService = accessor.get(IQuickInputService);
+        const sessionsService = accessor.get(ISessionsService);
+        const recentWorkspacesService = accessor.get(ISessionsRecentWorkspacesService);
+        const labelService = accessor.get(ILabelService);
+        const fileDialogService = accessor.get(IFileDialogService);
+        const composerService = accessor.get(INewSessionComposerService);
+        const items = buildFolderQuickPickItems(recentWorkspacesService, labelService);
+        const picked = await quickInputService.pick(items, {
+            placeHolder: ( localize(3735, "Select a folder to start a new session in")),
+            matchOnDescription: true
+        });
+        if (!picked) {
+            return;
+        }
+        let folderUri = picked.folderUri;
+        let providerId = picked.providerId;
+        if (picked.browse) {
+            const result = await fileDialogService.showOpenDialog({
+                canSelectFolders: true,
+                canSelectFiles: false,
+                canSelectMany: false
+            });
+            folderUri = result?.[0];
+            providerId = undefined;
+        }
+        if (!folderUri) {
+            return;
+        }
+        composerService.notifyUserWorkspaceSelection();
+        await sessionsService.openNewSession({
+            folderUri,
+            providerId
+        });
+    }
+}
+registerAction2(NewSessionPickFolderQuickPickAction);
+
+export { buildFolderQuickPickItems };

package/vscode/src/vs/sessions/contrib/chat/browser/nullInlineChatSessionService.d.ts

@@ -0,0 +1,15 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IActiveCodeEditor, ICodeEditor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
+import { IInlineChatSession } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService";
+import { IInlineChatSessionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService.service";
+export declare class NullInlineChatSessionService implements IInlineChatSessionService {
+    _serviceBrand: undefined;
+    readonly onWillStartSession: Event<IActiveCodeEditor>;
+    readonly onDidChangeSessions: Event<this>;
+    dispose(): void;
+    createSession(_editor: ICodeEditor, _isNotebook: boolean, _token: CancellationToken): Promise<IInlineChatSession>;
+    getSessionByTextModel(_uri: URI): IInlineChatSession | undefined;
+    getSessionBySessionUri(_uri: URI): IInlineChatSession | undefined;
+}

package/vscode/src/vs/sessions/contrib/chat/browser/nullInlineChatSessionService.js

@@ -0,0 +1,23 @@
+
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+
+class NullInlineChatSessionService {
+    constructor() {
+        this.onWillStartSession = Event.None;
+        this.onDidChangeSessions = Event.None;
+    }
+    dispose() {}
+    async createSession(_editor, _isNotebook, _token) {
+        throw ( new Error("Inline chat sessions are not supported in the sessions window"));
+    }
+    getSessionByTextModel(_uri) {
+        return undefined;
+    }
+    getSessionBySessionUri(_uri) {
+        return undefined;
+    }
+}
+
+export { NullInlineChatSessionService };

package/vscode/src/vs/sessions/contrib/chat/browser/openSessionLinkOpener.contribution.d.ts

@@ -0,0 +1,51 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable, IReader } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IAgentHostConnectionsService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostConnectionsService.service";
+import { ILinkPresentation } from "@codingame/monaco-vscode-api/vscode/vs/platform/dataChannel/common/dataChannel";
+import { ILinkPresentationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dataChannel/common/dataChannel.service";
+import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
+import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { ISessionSummaryHoverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/sessionSummaryHoverService.service";
+import { IPreferencesService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/preferences/common/preferences.service";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
+import { ISession, SessionStatus } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+import { ISessionsService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service";
+/**
+ * Handles `agent-host-session://` links (surfaced by the `create_session` /
+ * `create_chat` server tools) by resolving them to the matching Agents-window
+ * session and opening it through {@link ISessionsService}. The link carries the
+ * backend session URI; the owning session in the window uses a client scheme
+ * (e.g. `agent-host-copilotcli`), so matching goes through
+ * {@link IAgentHostConnectionsService.resolveSessionResourceIdentity}. When the link
+ * carries a chat id (from `create_chat`), that specific peer chat is opened;
+ * otherwise the session's main/default chat is opened, via
+ * {@link ISessionsService.openChat} in both cases so the correct chat becomes
+ * active even when a different chat of the same session is currently showing.
+ */
+export declare class OpenSessionLinkOpenerContribution extends Disposable implements IWorkbenchContribution {
+    private readonly _sessionsManagementService;
+    private readonly _sessionsService;
+    private readonly _connectionsService;
+    static readonly ID = "sessions.openSessionLinkOpener";
+    constructor(openerService: IOpenerService, _sessionsManagementService: ISessionsManagementService, _sessionsService: ISessionsService, _connectionsService: IAgentHostConnectionsService, linkPresentationService: ILinkPresentationService, sessionsProvidersService: ISessionsProvidersService, sessionSummaryHoverService: ISessionSummaryHoverService, labelService: ILabelService, preferencesService: IPreferencesService);
+    private _findSessionForLink;
+    private _open;
+}
+export declare function readSessionState(session: ISessionLinkState, chatId: string | undefined, reader: IReader, kind?: "session" | "chat"): ILinkPresentation;
+export interface ISessionLinkChatState {
+    readonly resource: URI;
+    readonly title: IObservable<string>;
+    readonly status: IObservable<SessionStatus>;
+}
+export interface ISessionLinkState {
+    readonly title: IObservable<string>;
+    readonly description: IObservable<{
+        readonly value: string;
+    } | undefined>;
+    readonly status: IObservable<SessionStatus>;
+    readonly chats: IObservable<readonly ISessionLinkChatState[]>;
+}
+export declare function findSessionForOpenSessionLink(backendSession: URI, sessionsManagementService: ISessionsManagementService, connectionsService: IAgentHostConnectionsService): ISession | undefined;