@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/files/browser/files.explorer.contribution.js

@@ -0,0 +1,460 @@
+import { UndoCommand, RedoCommand } from '../../../../editor/browser/editorExtensions.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { Extensions } from '../../../../platform/configuration/common/configurationRegistry.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { IUndoRedoService } from '../../../../platform/undoRedo/common/undoRedo.js';
+import { registerWorkbenchContribution2 } from '../../../common/contributions.js';
+import { UNDO_REDO_SOURCE } from './explorerService.js';
+import { ExplorerViewletViewsContribution } from './explorerViewlet.js';
+import { IExplorerService } from './files.js';
+import './files.configuration.contribution.js';
+import './files.editorPane.contribution.js';
+import './files.fileEditorFactory.contribution.js';
+registerWorkbenchContribution2(ExplorerViewletViewsContribution.ID, ExplorerViewletViewsContribution, 1 );
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
+configurationRegistry.registerConfiguration({
+    'id': 'explorer',
+    'order': 10,
+    'title': ( localizeWithPath(
+        'vs/workbench/contrib/files/browser/files.explorer.contribution',
+        'explorerConfigurationTitle',
+        "File Explorer"
+    )),
+    'type': 'object',
+    'properties': {
+        'explorer.openEditors.visible': {
+            'type': 'number',
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                { key: 'openEditorsVisible', comment: ['Open is an adjective'] },
+                "The initial maximum number of editors shown in the Open Editors pane. Exceeding this limit will show a scroll bar and allow resizing the pane to display more items."
+            )),
+            'default': 9,
+            'minimum': 1
+        },
+        'explorer.openEditors.minVisible': {
+            'type': 'number',
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                { key: 'openEditorsVisibleMin', comment: ['Open is an adjective'] },
+                "The minimum number of editor slots pre-allocated in the Open Editors pane. If set to 0 the Open Editors pane will dynamically resize based on the number of editors."
+            )),
+            'default': 0,
+            'minimum': 0
+        },
+        'explorer.openEditors.sortOrder': {
+            'type': 'string',
+            'enum': ['editorOrder', 'alphabetical', 'fullPath'],
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                { key: 'openEditorsSortOrder', comment: ['Open is an adjective'] },
+                "Controls the sorting order of editors in the Open Editors pane."
+            )),
+            'enumDescriptions': [
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'sortOrder.editorOrder',
+                    'Editors are ordered in the same order editor tabs are shown.'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'sortOrder.alphabetical',
+                    'Editors are ordered alphabetically by tab name inside each editor group.'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'sortOrder.fullPath',
+                    'Editors are ordered alphabetically by full path inside each editor group.'
+                ))
+            ],
+            'default': 'editorOrder'
+        },
+        'explorer.autoReveal': {
+            'type': ['boolean', 'string'],
+            'enum': [true, false, 'focusNoScroll'],
+            'default': true,
+            'enumDescriptions': [
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'autoReveal.on',
+                    'Files will be revealed and selected.'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'autoReveal.off',
+                    'Files will not be revealed and selected.'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'autoReveal.focusNoScroll',
+                    'Files will not be scrolled into view, but will still be focused.'
+                )),
+            ],
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                'autoReveal',
+                "Controls whether the Explorer should automatically reveal and select files when opening them."
+            ))
+        },
+        'explorer.autoRevealExclude': {
+            'type': 'object',
+            'markdownDescription': ( localizeWithPath(
+                'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                'autoRevealExclude',
+                "Configure paths or [glob patterns](https://aka.ms/vscode-glob-patterns) for excluding files and folders from being revealed and selected in the Explorer when they are opened. Glob patterns are always evaluated relative to the path of the workspace folder unless they are absolute paths."
+            )),
+            'default': { '**/node_modules': true, '**/bower_components': true },
+            'additionalProperties': {
+                'anyOf': [
+                    {
+                        'type': 'boolean',
+                        'description': ( localizeWithPath(
+                            'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                            'explorer.autoRevealExclude.boolean',
+                            "The glob pattern to match file paths against. Set to true or false to enable or disable the pattern."
+                        )),
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            when: {
+                                type: 'string',
+                                pattern: '\\w*\\$\\(basename\\)\\w*',
+                                default: '$(basename).ext',
+                                description: ( localizeWithPath(
+                                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                                    'explorer.autoRevealExclude.when',
+                                    'Additional check on the siblings of a matching file. Use $(basename) as variable for the matching file name.'
+                                ))
+                            }
+                        }
+                    }
+                ]
+            }
+        },
+        'explorer.enableDragAndDrop': {
+            'type': 'boolean',
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                'enableDragAndDrop',
+                "Controls whether the Explorer should allow to move files and folders via drag and drop. This setting only effects drag and drop from inside the Explorer."
+            )),
+            'default': true
+        },
+        'explorer.confirmDragAndDrop': {
+            'type': 'boolean',
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                'confirmDragAndDrop',
+                "Controls whether the Explorer should ask for confirmation to move files and folders via drag and drop."
+            )),
+            'default': true
+        },
+        'explorer.confirmPasteNative': {
+            'type': 'boolean',
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                'confirmPasteNative',
+                "Controls whether the Explorer should ask for confirmation when pasting native files and folders."
+            )),
+            'default': true
+        },
+        'explorer.confirmDelete': {
+            'type': 'boolean',
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                'confirmDelete',
+                "Controls whether the Explorer should ask for confirmation when deleting a file via the trash."
+            )),
+            'default': true
+        },
+        'explorer.enableUndo': {
+            'type': 'boolean',
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                'enableUndo',
+                "Controls whether the Explorer should support undoing file and folder operations."
+            )),
+            'default': true
+        },
+        'explorer.confirmUndo': {
+            'type': 'string',
+            'enum': ["verbose" , "default" , "light" ],
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                'confirmUndo',
+                "Controls whether the Explorer should ask for confirmation when undoing."
+            )),
+            'default': "default" ,
+            'enumDescriptions': [
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'enableUndo.verbose',
+                    'Explorer will prompt before all undo operations.'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'enableUndo.default',
+                    'Explorer will prompt before destructive undo operations.'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'enableUndo.light',
+                    'Explorer will not prompt before undo operations when focused.'
+                )),
+            ],
+        },
+        'explorer.expandSingleFolderWorkspaces': {
+            'type': 'boolean',
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                'expandSingleFolderWorkspaces',
+                "Controls whether the Explorer should expand multi-root workspaces containing only one folder during initialization"
+            )),
+            'default': true
+        },
+        'explorer.sortOrder': {
+            'type': 'string',
+            'enum': ["default" , "mixed" , "filesFirst" , "type" , "modified" , "foldersNestsFiles" ],
+            'default': "default" ,
+            'enumDescriptions': [
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'sortOrder.default',
+                    'Files and folders are sorted by their names. Folders are displayed before files.'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'sortOrder.mixed',
+                    'Files and folders are sorted by their names. Files are interwoven with folders.'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'sortOrder.filesFirst',
+                    'Files and folders are sorted by their names. Files are displayed before folders.'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'sortOrder.type',
+                    'Files and folders are grouped by extension type then sorted by their names. Folders are displayed before files.'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'sortOrder.modified',
+                    'Files and folders are sorted by last modified date in descending order. Folders are displayed before files.'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'sortOrder.foldersNestsFiles',
+                    'Files and folders are sorted by their names. Folders are displayed before files. Files with nested children are displayed before other files.'
+                ))
+            ],
+            'markdownDescription': ( localizeWithPath(
+                'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                'sortOrder',
+                "Controls the property-based sorting of files and folders in the Explorer. When `#explorer.fileNesting.enabled#` is enabled, also controls sorting of nested files."
+            ))
+        },
+        'explorer.sortOrderLexicographicOptions': {
+            'type': 'string',
+            'enum': ["default" , "upper" , "lower" , "unicode" ],
+            'default': "default" ,
+            'enumDescriptions': [
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'sortOrderLexicographicOptions.default',
+                    'Uppercase and lowercase names are mixed together.'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'sortOrderLexicographicOptions.upper',
+                    'Uppercase names are grouped together before lowercase names.'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'sortOrderLexicographicOptions.lower',
+                    'Lowercase names are grouped together before uppercase names.'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'sortOrderLexicographicOptions.unicode',
+                    'Names are sorted in Unicode order.'
+                ))
+            ],
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                'sortOrderLexicographicOptions',
+                "Controls the lexicographic sorting of file and folder names in the Explorer."
+            ))
+        },
+        'explorer.decorations.colors': {
+            type: 'boolean',
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                'explorer.decorations.colors',
+                "Controls whether file decorations should use colors."
+            )),
+            default: true
+        },
+        'explorer.decorations.badges': {
+            type: 'boolean',
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                'explorer.decorations.badges',
+                "Controls whether file decorations should use badges."
+            )),
+            default: true
+        },
+        'explorer.incrementalNaming': {
+            'type': 'string',
+            enum: ['simple', 'smart', 'disabled'],
+            enumDescriptions: [
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'simple',
+                    "Appends the word \"copy\" at the end of the duplicated name potentially followed by a number."
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'smart',
+                    "Adds a number at the end of the duplicated name. If some number is already part of the name, tries to increase that number."
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'disabled',
+                    "Disables incremental naming. If two files with the same name exist you will be prompted to overwrite the existing file."
+                ))
+            ],
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                'explorer.incrementalNaming',
+                "Controls which naming strategy to use when giving a new name to a duplicated Explorer item on paste."
+            )),
+            default: 'simple'
+        },
+        'explorer.compactFolders': {
+            'type': 'boolean',
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                'compressSingleChildFolders',
+                "Controls whether the Explorer should render folders in a compact form. In such a form, single child folders will be compressed in a combined tree element. Useful for Java package structures, for example."
+            )),
+            'default': true
+        },
+        'explorer.copyRelativePathSeparator': {
+            'type': 'string',
+            'enum': [
+                '/',
+                '\\',
+                'auto'
+            ],
+            'enumDescriptions': [
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'copyRelativePathSeparator.slash',
+                    "Use slash as path separation character."
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'copyRelativePathSeparator.backslash',
+                    "Use backslash as path separation character."
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                    'copyRelativePathSeparator.auto',
+                    "Uses operating system specific path separation character."
+                )),
+            ],
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                'copyRelativePathSeparator',
+                "The path separation character used when copying relative file paths."
+            )),
+            'default': 'auto'
+        },
+        'explorer.excludeGitIgnore': {
+            type: 'boolean',
+            markdownDescription: ( localizeWithPath(
+                'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                'excludeGitignore',
+                "Controls whether entries in .gitignore should be parsed and excluded from the Explorer. Similar to {0}.",
+                '`#files.exclude#`'
+            )),
+            default: false,
+            scope: 4
+        },
+        'explorer.fileNesting.enabled': {
+            'type': 'boolean',
+            scope: 4 ,
+            'markdownDescription': ( localizeWithPath(
+                'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                'fileNestingEnabled',
+                "Controls whether file nesting is enabled in the Explorer. File nesting allows for related files in a directory to be visually grouped together under a single parent file."
+            )),
+            'default': false,
+        },
+        'explorer.fileNesting.expand': {
+            'type': 'boolean',
+            'markdownDescription': ( localizeWithPath(
+                'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                'fileNestingExpand',
+                "Controls whether file nests are automatically expanded. {0} must be set for this to take effect.",
+                '`#explorer.fileNesting.enabled#`'
+            )),
+            'default': true,
+        },
+        'explorer.fileNesting.patterns': {
+            'type': 'object',
+            scope: 4 ,
+            'markdownDescription': ( localizeWithPath(
+                'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                'fileNestingPatterns',
+                "Controls nesting of files in the Explorer. {0} must be set for this to take effect. Each __Item__ represents a parent pattern and may contain a single `*` character that matches any string. Each __Value__ represents a comma separated list of the child patterns that should be shown nested under a given parent. Child patterns may contain several special tokens:\n- `${capture}`: Matches the resolved value of the `*` from the parent pattern\n- `${basename}`: Matches the parent file's basename, the `file` in `file.ts`\n- `${extname}`: Matches the parent file's extension, the `ts` in `file.ts`\n- `${dirname}`: Matches the parent file's directory name, the `src` in `src/file.ts`\n- `*`:  Matches any string, may only be used once per child pattern",
+                '`#explorer.fileNesting.enabled#`'
+            )),
+            patternProperties: {
+                '^[^*]*\\*?[^*]*$': {
+                    markdownDescription: ( localizeWithPath(
+                        'vs/workbench/contrib/files/browser/files.explorer.contribution',
+                        'fileNesting.description',
+                        "Each key pattern may contain a single `*` character which will match any string."
+                    )),
+                    type: 'string',
+                    pattern: '^([^,*]*\\*?[^,*]*)(, ?[^,*]*\\*?[^,*]*)*$',
+                }
+            },
+            additionalProperties: false,
+            'default': {
+                '*.ts': '${capture}.js',
+                '*.js': '${capture}.js.map, ${capture}.min.js, ${capture}.d.ts',
+                '*.jsx': '${capture}.js',
+                '*.tsx': '${capture}.ts',
+                'tsconfig.json': 'tsconfig.*.json',
+                'package.json': 'package-lock.json, yarn.lock, pnpm-lock.yaml, bun.lockb',
+            }
+        }
+    }
+});
+UndoCommand.addImplementation(110, 'explorer', (accessor) => {
+    const undoRedoService = accessor.get(IUndoRedoService);
+    const explorerService = accessor.get(IExplorerService);
+    const configurationService = accessor.get(IConfigurationService);
+    const explorerCanUndo = configurationService.getValue().explorer.enableUndo;
+    if (explorerService.hasViewFocus() && undoRedoService.canUndo(UNDO_REDO_SOURCE) && explorerCanUndo) {
+        undoRedoService.undo(UNDO_REDO_SOURCE);
+        return true;
+    }
+    return false;
+});
+RedoCommand.addImplementation(110, 'explorer', (accessor) => {
+    const undoRedoService = accessor.get(IUndoRedoService);
+    const explorerService = accessor.get(IExplorerService);
+    const configurationService = accessor.get(IConfigurationService);
+    const explorerCanUndo = configurationService.getValue().explorer.enableUndo;
+    if (explorerService.hasViewFocus() && undoRedoService.canRedo(UNDO_REDO_SOURCE) && explorerCanUndo) {
+        undoRedoService.redo(UNDO_REDO_SOURCE);
+        return true;
+    }
+    return false;
+});

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChat.contribution.js

@@ -0,0 +1,39 @@
+import { registerEditorContribution } from '../../../../editor/browser/editorExtensions.js';
+import { registerAction2 } from '../../../../platform/actions/common/actions.js';
+import { InlineChatController } from './inlineChatController.js';
+import { InlineAccessibilityHelpContribution, StartSessionAction, CloseAction, ConfigureInlineChatAction, UnstashSessionAction, ReRunRequestAction, ReRunRequestWithIntentDetectionAction, DiscardHunkAction, DiscardAction, DiscardToClipboardAction, DiscardUndoToNewFileAction, CancelSessionAction, MoveToNextHunk, MoveToPreviousHunk, ArrowOutUpAction, ArrowOutDownAction, FocusInlineChat, ViewInChatAction, ToggleDiffForChange, ReportIssueForBugCommand, AcceptChanges, CopyRecordings } from './inlineChatActions.js';
+import { INLINE_CHAT_ID, INTERACTIVE_EDITOR_ACCESSIBILITY_HELP_ID } from '../common/inlineChat.js';
+import '../common/inlineChatServiceImpl.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { InlineChatNotebookContribution } from './inlineChatNotebook.js';
+import { Extensions } from '../../../common/contributions.js';
+import './inlineChatSavingServiceImpl.js';
+import { InlineChatAccessibleViewContribution } from './inlineChatAccessibleView.js';
+import '../../../../platform/instantiation/common/instantiation.js';
+import './inlineChatSessionServiceImpl.js';
+registerEditorContribution(INLINE_CHAT_ID, InlineChatController, 0 );
+registerEditorContribution(INTERACTIVE_EDITOR_ACCESSIBILITY_HELP_ID, InlineAccessibilityHelpContribution, 3 );
+registerAction2(StartSessionAction);
+registerAction2(CloseAction);
+registerAction2(ConfigureInlineChatAction);
+registerAction2(UnstashSessionAction);
+registerAction2(ReRunRequestAction);
+registerAction2(ReRunRequestWithIntentDetectionAction);
+registerAction2(DiscardHunkAction);
+registerAction2(DiscardAction);
+registerAction2(DiscardToClipboardAction);
+registerAction2(DiscardUndoToNewFileAction);
+registerAction2(CancelSessionAction);
+registerAction2(MoveToNextHunk);
+registerAction2(MoveToPreviousHunk);
+registerAction2(ArrowOutUpAction);
+registerAction2(ArrowOutDownAction);
+registerAction2(FocusInlineChat);
+registerAction2(ViewInChatAction);
+registerAction2(ToggleDiffForChange);
+registerAction2(ReportIssueForBugCommand);
+registerAction2(AcceptChanges);
+registerAction2(CopyRecordings);
+const workbenchContributionsRegistry = ( Registry.as(Extensions.Workbench));
+workbenchContributionsRegistry.registerWorkbenchContribution(InlineChatNotebookContribution, 3 );
+workbenchContributionsRegistry.registerWorkbenchContribution(InlineChatAccessibleViewContribution, 4 );

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatAccessibleView.js

@@ -0,0 +1,39 @@
+import { InlineChatController } from './inlineChatController.js';
+import { CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_RESPONSE_FOCUSED } from '../common/inlineChat.js';
+import { IAccessibleViewService } from '../../accessibility/browser/accessibleView.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.js';
+import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { AccessibleViewAction } from '../../accessibility/browser/accessibleViewActions.js';
+class InlineChatAccessibleViewContribution extends Disposable {
+    constructor() {
+        super();
+        this._register(AccessibleViewAction.addImplementation(100, 'inlineChat', accessor => {
+            const accessibleViewService = accessor.get(IAccessibleViewService);
+            const codeEditorService = accessor.get(ICodeEditorService);
+            const editor = (codeEditorService.getActiveCodeEditor() || codeEditorService.getFocusedCodeEditor());
+            if (!editor) {
+                return false;
+            }
+            const controller = InlineChatController.get(editor);
+            if (!controller) {
+                return false;
+            }
+            const responseContent = controller?.getMessage();
+            if (!responseContent) {
+                return false;
+            }
+            accessibleViewService.show({
+                id: "inlineChat" ,
+                verbositySettingKey: "accessibility.verbosity.inlineChat" ,
+                provideContent() { return responseContent; },
+                onClose() {
+                    controller.focus();
+                },
+                options: { type: "view"  }
+            });
+            return true;
+        }, ( ContextKeyExpr.or(CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_RESPONSE_FOCUSED))));
+    }
+}
+export { InlineChatAccessibleViewContribution };

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatNotebook.js

@@ -0,0 +1,70 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { illegalState } from '../../../../base/common/errors.js';
+import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { isEqual } from '../../../../base/common/resources.js';
+import { InlineChatController } from './inlineChatController.js';
+import { IInlineChatSessionService } from './inlineChatSessionService.js';
+import { INotebookEditorService } from '../../notebook/browser/services/notebookEditorService.js';
+import { CellUri } from '../../notebook/common/notebookCommon.js';
+let InlineChatNotebookContribution = class InlineChatNotebookContribution {
+    constructor(sessionService, notebookEditorService) {
+        this._store = ( new DisposableStore());
+        this._store.add(sessionService.registerSessionKeyComputer(Schemas.vscodeNotebookCell, {
+            getComparisonKey: (editor, uri) => {
+                const data = CellUri.parse(uri);
+                if (!data) {
+                    throw illegalState('Expected notebook cell uri');
+                }
+                let fallback;
+                for (const notebookEditor of notebookEditorService.listNotebookEditors()) {
+                    if (notebookEditor.hasModel() && isEqual(notebookEditor.textModel.uri, data.notebook)) {
+                        const candidate = `<notebook>${notebookEditor.getId()}#${uri}`;
+                        if (!fallback) {
+                            fallback = candidate;
+                        }
+                        if (notebookEditor.codeEditors.find((tuple) => tuple[1] === editor)) {
+                            return candidate;
+                        }
+                    }
+                }
+                if (fallback) {
+                    return fallback;
+                }
+                throw illegalState('Expected notebook editor');
+            }
+        }));
+        this._store.add(sessionService.onWillStartSession(newSessionEditor => {
+            const candidate = CellUri.parse(newSessionEditor.getModel().uri);
+            if (!candidate) {
+                return;
+            }
+            for (const notebookEditor of notebookEditorService.listNotebookEditors()) {
+                if (isEqual(notebookEditor.textModel?.uri, candidate.notebook)) {
+                    let found = false;
+                    const editors = [];
+                    for (const [, codeEditor] of notebookEditor.codeEditors) {
+                        editors.push(codeEditor);
+                        found = codeEditor === newSessionEditor || found;
+                    }
+                    if (found) {
+                        for (const editor of editors) {
+                            if (editor !== newSessionEditor) {
+                                InlineChatController.get(editor)?.finishExistingSession();
+                            }
+                        }
+                        break;
+                    }
+                }
+            }
+        }));
+    }
+    dispose() {
+        this._store.dispose();
+    }
+};
+InlineChatNotebookContribution = ( __decorate([
+    ( __param(0, IInlineChatSessionService)),
+    ( __param(1, INotebookEditorService))
+], InlineChatNotebookContribution));
+export { InlineChatNotebookContribution };